open-multi-agent-kit 0.78.0

package/dist/runtime/tool-plane.d.ts

@@ -0,0 +1,31 @@
+import type { OmkRuntimeScope } from "../util/resource-profile.js";
+import { type OmkToolPrefixSpec } from "./tool-registry-contract.js";
+export interface OmkToolPlaneDiagnostic {
+    readonly level: "warning" | "error";
+    readonly code: "mcp_config_parse_failed" | "mcp_config_read_failed" | "runtime_mcp_config_parse_failed" | "runtime_mcp_required_unavailable";
+    readonly path?: string;
+    readonly message: string;
+}
+export interface OmkToolPlaneManifest {
+    readonly owner: "omk";
+    readonly mcpServers: readonly string[];
+    readonly mcpConfigFile?: string;
+    readonly skills: readonly string[];
+    readonly hooks: readonly string[];
+    readonly tools: readonly string[];
+    readonly toolContracts: readonly OmkToolPrefixSpec[];
+    readonly toolSpecsHash: string;
+    readonly runtimeOwnsMcp: false;
+    readonly requiresRuntimeMcp: boolean;
+    readonly diagnostics: readonly OmkToolPlaneDiagnostic[];
+}
+export interface BuildOmkToolPlaneManifestInput {
+    readonly mcpScope: OmkRuntimeScope;
+    readonly mcpAllowlist?: readonly string[];
+    readonly skills?: readonly string[];
+    readonly hooks?: readonly string[];
+    readonly tools?: readonly string[];
+    readonly toolContracts?: readonly OmkToolPrefixSpec[];
+    readonly requiresRuntimeMcp?: boolean;
+}
+export declare function buildOmkToolPlaneManifest(input: BuildOmkToolPlaneManifestInput): Promise<OmkToolPlaneManifest>;

package/dist/runtime/tool-plane.js

@@ -0,0 +1,112 @@
+import { readFile } from "fs/promises";
+import { isAbsolute, relative, resolve, sep } from "path";
+import { collectMcpConfigs, getProjectRootAsync, getUserHome, writeBuiltinMcpConfig, writeRuntimeMcpConfig } from "../util/fs.js";
+import { stableValueHash } from "./stable-json.js";
+import { sortToolPrefixSpecs } from "./tool-registry-contract.js";
+export async function buildOmkToolPlaneManifest(input) {
+    const requiresRuntimeMcp = input.requiresRuntimeMcp === true;
+    const resolved = await resolveRuntimeMcpConfigFile(input.mcpScope, input.mcpAllowlist);
+    const runtimeRead = resolved.mcpConfigFile ? await readMcpServerNames(resolved.mcpConfigFile) : { servers: [], diagnostics: [] };
+    const diagnostics = [...resolved.diagnostics, ...runtimeRead.diagnostics];
+    if (requiresRuntimeMcp && (diagnostics.some((diagnostic) => diagnostic.level === "error") || !resolved.mcpConfigFile || runtimeRead.servers.length === 0)) {
+        throw new Error(formatRequiredRuntimeMcpError(diagnostics, resolved.mcpConfigFile, runtimeRead.servers));
+    }
+    const toolContracts = sortToolPrefixSpecs(input.toolContracts ?? []);
+    const manifest = {
+        owner: "omk",
+        mcpServers: runtimeRead.servers,
+        mcpConfigFile: resolved.mcpConfigFile ?? undefined,
+        skills: unique(input.skills ?? []),
+        hooks: unique(input.hooks ?? []),
+        tools: unique(input.tools ?? []),
+        toolContracts,
+        toolSpecsHash: stableValueHash(toolContracts),
+        runtimeOwnsMcp: false,
+        requiresRuntimeMcp,
+        diagnostics,
+    };
+    return manifest;
+}
+async function resolveRuntimeMcpConfigFile(scope, allowlist) {
+    if (scope === "none")
+        return { mcpConfigFile: null, diagnostics: [] };
+    const configPaths = await collectMcpConfigs(scope);
+    const diagnostics = await readMcpConfigDiagnostics(configPaths);
+    const builtinMcp = await writeBuiltinMcpConfig();
+    const runtimeAllowlist = allowlist !== undefined
+        ? unique([...allowlist, "omk-project"])
+        : undefined;
+    const mcpConfigFile = await writeRuntimeMcpConfig(builtinMcp ? [...configPaths, builtinMcp] : configPaths, runtimeAllowlist);
+    return { mcpConfigFile, diagnostics };
+}
+async function readMcpServerNames(configFile) {
+    try {
+        const parsed = JSON.parse(await readFile(configFile, "utf-8"));
+        const servers = parsed.mcpServers;
+        if (!servers || typeof servers !== "object" || Array.isArray(servers))
+            return { servers: [], diagnostics: [] };
+        return { servers: unique(Object.keys(servers)), diagnostics: [] };
+    }
+    catch (err) {
+        return {
+            servers: [],
+            diagnostics: [await createMcpDiagnostic("runtime_mcp_config_parse_failed", configFile, err)],
+        };
+    }
+}
+async function readMcpConfigDiagnostics(configPaths) {
+    const diagnostics = [];
+    for (const configPath of configPaths) {
+        try {
+            JSON.parse(await readFile(configPath, "utf-8"));
+        }
+        catch (err) {
+            diagnostics.push(await createMcpDiagnostic(err instanceof SyntaxError ? "mcp_config_parse_failed" : "mcp_config_read_failed", configPath, err));
+        }
+    }
+    return diagnostics;
+}
+async function createMcpDiagnostic(code, path, err) {
+    return {
+        level: "error",
+        code,
+        path: await formatDiagnosticPath(path),
+        message: mcpDiagnosticMessage(err),
+    };
+}
+async function formatDiagnosticPath(path) {
+    const root = resolve(await getProjectRootAsync());
+    const resolvedPath = resolve(path);
+    const rootRelative = relative(root, resolvedPath);
+    if (isRelativeChildPath(rootRelative))
+        return rootRelative.split(sep).join("/");
+    const home = resolve(getUserHome());
+    const homeRelative = relative(home, resolvedPath);
+    if (isRelativeChildPath(homeRelative))
+        return `~/${homeRelative.split(sep).join("/")}`;
+    return resolvedPath;
+}
+function isRelativeChildPath(path) {
+    return path !== "" && path !== ".." && !path.startsWith(`..${sep}`) && !path.startsWith("../") && !isAbsolute(path);
+}
+function mcpDiagnosticMessage(err) {
+    if (err instanceof SyntaxError)
+        return "invalid JSON";
+    if (err && typeof err === "object" && "code" in err && typeof err.code === "string") {
+        return `unreadable MCP config (${err.code})`;
+    }
+    return "invalid MCP config";
+}
+function formatRequiredRuntimeMcpError(diagnostics, mcpConfigFile, servers) {
+    const errors = diagnostics
+        .filter((diagnostic) => diagnostic.level === "error")
+        .map((diagnostic) => `${diagnostic.path ?? "runtime MCP"}: ${diagnostic.message}`);
+    if (!mcpConfigFile)
+        errors.push("runtime MCP config was not generated");
+    if (mcpConfigFile && servers.length === 0)
+        errors.push("runtime MCP config contains no servers");
+    return `[omk] Runtime MCP is required but unavailable: ${unique(errors).join("; ")}`;
+}
+function unique(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}

package/dist/runtime/tool-proxy.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ToolProxy — intercepts and compresses tool results before they enter context.
+ *
+ * Applies format-aware compressors for common OMK tool outputs (git, grep, etc.)
+ * to keep context bounded within ContextBudget limits.
+ */
+export interface ToolResultCompression {
+    readonly original: string;
+    readonly compressed: string;
+    readonly savedBytes: number;
+    readonly method: string;
+}
+export interface ToolProxyOptions {
+    readonly maxResultTokens: number;
+    readonly compressors?: Map<string, (input: string) => string>;
+}
+export declare function createToolProxy(options?: Partial<ToolProxyOptions>): {
+    compress: (toolName: string, output: string) => ToolResultCompression;
+    compressAuto(output: string): ToolResultCompression;
+};

package/dist/runtime/tool-proxy.js

@@ -0,0 +1,109 @@
+/**
+ * ToolProxy — intercepts and compresses tool results before they enter context.
+ *
+ * Applies format-aware compressors for common OMK tool outputs (git, grep, etc.)
+ * to keep context bounded within ContextBudget limits.
+ */
+const GIT_DIFF_COMPRESSOR = (input) => {
+    const lines = input.split("\n");
+    if (lines.length <= 20)
+        return input;
+    const header = lines.slice(0, 5).join("\n");
+    const stats = lines.filter((l) => /^[\d-]+ files? changed/.test(l)).join("\n");
+    const hunks = lines.filter((l) => /^@@/.test(l)).slice(0, 3).join("\n");
+    return [header, hunks, stats, `... (${lines.length} lines total)`].filter(Boolean).join("\n");
+};
+const GIT_STATUS_COMPRESSOR = (input) => {
+    const lines = input.split("\n").filter((l) => l.trim());
+    if (lines.length <= 10)
+        return input;
+    return lines.slice(0, 10).join("\n") + `\n... (${lines.length} files total)`;
+};
+const GREP_COMPRESSOR = (input) => {
+    const lines = input.split("\n").filter((l) => l.trim());
+    if (lines.length <= 15)
+        return input;
+    return lines.slice(0, 15).join("\n") + `\n... (${lines.length} matches total)`;
+};
+const FIND_COMPRESSOR = (input) => {
+    const lines = input.split("\n").filter((l) => l.trim());
+    if (lines.length <= 15)
+        return input;
+    return lines.slice(0, 15).join("\n") + `\n... (${lines.length} results total)`;
+};
+const TREE_COMPRESSOR = (input) => {
+    const lines = input.split("\n").filter((l) => l.trim());
+    if (lines.length <= 20)
+        return input;
+    return lines.slice(0, 20).join("\n") + `\n... (${lines.length} entries total)`;
+};
+const LS_COMPRESSOR = (input) => {
+    const lines = input.split("\n").filter((l) => l.trim());
+    if (lines.length <= 20)
+        return input;
+    return lines.slice(0, 20).join("\n") + `\n... (${lines.length} entries total)`;
+};
+const READ_FILE_COMPRESSOR = (input) => {
+    if (input.length <= 4000)
+        return input;
+    return input.slice(0, 4000) + `\n... (truncated, ${input.length} chars total)`;
+};
+const DEFAULT_COMPRESSORS = new Map([
+    ["git_diff", GIT_DIFF_COMPRESSOR],
+    ["git_status", GIT_STATUS_COMPRESSOR],
+    ["grep", GREP_COMPRESSOR],
+    ["find", FIND_COMPRESSOR],
+    ["tree", TREE_COMPRESSOR],
+    ["ls", LS_COMPRESSOR],
+    ["read_file", READ_FILE_COMPRESSOR],
+    ["ctx_read", READ_FILE_COMPRESSOR],
+    ["read_text_file", READ_FILE_COMPRESSOR],
+]);
+function detectToolName(output) {
+    const first = output.slice(0, 1024);
+    if (first.includes("diff --git") || first.includes("--- a/") || first.includes("+++ b/"))
+        return "git_diff";
+    if (/^[MADRC]\s+/m.test(first) || first.includes("Changes to be committed"))
+        return "git_status";
+    if (/:\d+:/m.test(first))
+        return "grep";
+    if (first.includes("├──") || first.includes("└──") || first.includes("│"))
+        return "tree";
+    return "generic";
+}
+export function createToolProxy(options = {}) {
+    const maxTokens = options.maxResultTokens ?? 512;
+    const compressors = options.compressors ?? DEFAULT_COMPRESSORS;
+    function compress(toolName, output) {
+        const maxChars = maxTokens * 4;
+        if (output.length <= maxChars) {
+            return { original: output, compressed: output, savedBytes: 0, method: "none" };
+        }
+        const compressor = compressors.get(toolName);
+        if (compressor) {
+            const compressed = compressor(output);
+            if (compressed.length < output.length) {
+                return {
+                    original: output,
+                    compressed,
+                    savedBytes: output.length - compressed.length,
+                    method: toolName,
+                };
+            }
+        }
+        const compressed = output.slice(0, maxChars) + `\n... (truncated from ${output.length} chars)`;
+        return {
+            original: output,
+            compressed,
+            savedBytes: output.length - compressed.length,
+            method: "truncation",
+        };
+    }
+    return {
+        compress,
+        compressAuto(output) {
+            const toolName = detectToolName(output);
+            return compress(toolName, output);
+        },
+    };
+}

package/dist/runtime/tool-registry-contract.d.ts

@@ -0,0 +1,40 @@
+import { type JsonObject, type JsonValue } from "./stable-json.js";
+export interface OmkToolContext {
+    readonly runId?: string;
+    readonly nodeId?: string;
+    readonly signal?: AbortSignal;
+}
+export interface OmkToolDefinition<A = unknown, R = unknown> {
+    readonly name: string;
+    readonly description?: string;
+    readonly parameters?: JsonObject;
+    readonly readOnly?: boolean;
+    readonly readOnlyCheck?: (args: A) => boolean;
+    readonly parallelSafe?: boolean;
+    readonly stormExempt?: boolean;
+    readonly skipRetentionSave?: boolean;
+    readonly fn: (args: A, ctx: OmkToolContext) => Promise<R> | R;
+}
+export interface OmkToolPrefixSpec {
+    readonly name: string;
+    readonly description?: string;
+    readonly parameters?: JsonValue;
+    readonly readOnly: boolean;
+    readonly parallelSafe: boolean;
+    readonly stormExempt: boolean;
+    readonly skipRetentionSave: boolean;
+}
+export interface OmkToolCall<A = unknown> {
+    readonly toolName: string;
+    readonly args: A;
+}
+export type OmkToolExecutionBatchKind = "parallel" | "serial";
+export interface OmkToolExecutionBatch<A = unknown> {
+    readonly kind: OmkToolExecutionBatchKind;
+    readonly calls: readonly OmkToolCall<A>[];
+}
+export declare function toToolPrefixSpec(definition: OmkToolDefinition): OmkToolPrefixSpec;
+export declare function sortToolPrefixSpecs(specs: readonly OmkToolPrefixSpec[]): OmkToolPrefixSpec[];
+export declare function toSortedToolPrefixSpecs(definitions: readonly OmkToolDefinition[]): OmkToolPrefixSpec[];
+export declare function isToolReadOnly<A>(definition: OmkToolDefinition<A>, args: A): boolean;
+export declare function createToolExecutionBatches<A>(calls: readonly OmkToolCall<A>[], registry: ReadonlyMap<string, OmkToolDefinition<A>>): OmkToolExecutionBatch<A>[];

package/dist/runtime/tool-registry-contract.js

@@ -0,0 +1,52 @@
+import { compareCodepoints, stableJsonStringify, } from "./stable-json.js";
+export function toToolPrefixSpec(definition) {
+    return {
+        name: definition.name,
+        description: definition.description,
+        parameters: definition.parameters,
+        readOnly: definition.readOnly === true,
+        parallelSafe: definition.parallelSafe === true,
+        stormExempt: definition.stormExempt === true,
+        skipRetentionSave: definition.skipRetentionSave === true,
+    };
+}
+export function sortToolPrefixSpecs(specs) {
+    return [...specs].sort((left, right) => {
+        const byName = compareCodepoints(left.name, right.name);
+        if (byName !== 0)
+            return byName;
+        return compareCodepoints(stableJsonStringify(left), stableJsonStringify(right));
+    });
+}
+export function toSortedToolPrefixSpecs(definitions) {
+    return sortToolPrefixSpecs(definitions.map((definition) => toToolPrefixSpec(definition)));
+}
+export function isToolReadOnly(definition, args) {
+    if (definition.readOnlyCheck)
+        return definition.readOnlyCheck(args);
+    return definition.readOnly === true;
+}
+export function createToolExecutionBatches(calls, registry) {
+    const batches = [];
+    let parallelCalls = [];
+    const flushParallel = () => {
+        if (parallelCalls.length === 0)
+            return;
+        batches.push({ kind: "parallel", calls: parallelCalls });
+        parallelCalls = [];
+    };
+    for (const call of calls) {
+        const definition = registry.get(call.toolName);
+        const canRunInParallel = definition !== undefined &&
+            definition.parallelSafe === true &&
+            isToolReadOnly(definition, call.args);
+        if (canRunInParallel) {
+            parallelCalls.push(call);
+            continue;
+        }
+        flushParallel();
+        batches.push({ kind: "serial", calls: [call] });
+    }
+    flushParallel();
+    return batches;
+}

package/dist/runtime/ui-components.d.ts

@@ -0,0 +1,64 @@
+/**
+ * UI Components — Semantic card/box components for ThemeRenderer.
+ *
+ * Uses ThemePalette semantic tokens for consistent theming.
+ * All components return formatted strings ready for terminal output.
+ *
+ * Components: statusCard, providerCard, memoryCard, mcpHealthCard,
+ *             errorBox, traceSummary, consentNotice
+ */
+import type { ThemePalette } from "../cli/theme/theme-registry.js";
+import type { ReasoningTrace, TraceSummary } from "./contracts/reasoning-trace.js";
+export interface StatusCardData {
+    intent: string;
+    provider: string;
+    model?: string;
+    runtime?: string;
+    risk?: string;
+    mcpCount?: number;
+    skillCount?: number;
+    durationMs?: number;
+}
+export declare function statusCard(p: ThemePalette | undefined, data: StatusCardData): string;
+export interface ProviderCardData {
+    provider: string;
+    model: string;
+    runtimeMode?: string;
+    apiBase?: string;
+    connected?: boolean;
+}
+export declare function providerCard(p: ThemePalette | undefined, data: ProviderCardData): string;
+export interface MemoryCardData {
+    projectId?: string;
+    decisions?: number;
+    todos?: number;
+    facts?: number;
+    lastUpdated?: string;
+}
+export declare function memoryCard(p: ThemePalette | undefined, data: MemoryCardData): string;
+export interface McpServerHealth {
+    name: string;
+    status: "connected" | "failed" | "disabled" | "pending";
+    toolCount?: number;
+    error?: string;
+}
+export interface McpHealthCardData {
+    servers: McpServerHealth[];
+    totalTools?: number;
+}
+export declare function mcpHealthCard(p: ThemePalette | undefined, data: McpHealthCardData): string;
+export interface ErrorBoxData {
+    message: string;
+    recoverable?: boolean;
+    code?: string;
+    suggestion?: string;
+}
+export declare function errorBox(p: ThemePalette | undefined, data: ErrorBoxData): string;
+export declare function traceSummaryCard(p: ThemePalette | undefined, trace: ReasoningTrace): string;
+export declare function traceSummaryCompact(p: ThemePalette | undefined, summary: TraceSummary): string;
+export interface ConsentNoticeData {
+    level: "l0" | "l1" | "l2" | "l3";
+    includedInDataset: boolean;
+    redactedFields?: string[];
+}
+export declare function consentNotice(p: ThemePalette | undefined, data: ConsentNoticeData): string;

package/dist/runtime/ui-components.js

@@ -0,0 +1,232 @@
+/**
+ * UI Components — Semantic card/box components for ThemeRenderer.
+ *
+ * Uses ThemePalette semantic tokens for consistent theming.
+ * All components return formatted strings ready for terminal output.
+ *
+ * Components: statusCard, providerCard, memoryCard, mcpHealthCard,
+ *             errorBox, traceSummary, consentNotice
+ */
+import { t } from "../util/i18n.js";
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const BOX_H = "─";
+const BOX_V = "│";
+const BOX_TL = "┌";
+const BOX_TR = "┐";
+const BOX_BL = "└";
+const BOX_BR = "┘";
+function themed(p, token, text) {
+    if (!p || !p.supportsColor)
+        return text;
+    return p.render(token, text);
+}
+function dim(p, text) {
+    return themed(p, "dim", text);
+}
+function separator(p, width = 50) {
+    return dim(p, BOX_H.repeat(width));
+}
+function boxLine(p, content, width = 50) {
+    const stripped = stripAnsi(content);
+    const padding = Math.max(0, width - stripped.length - 2);
+    return `${dim(p, BOX_V)} ${content}${" ".repeat(padding)}${dim(p, BOX_V)}`;
+}
+function boxTop(p, title, width = 50) {
+    const titleStr = ` ${title} `;
+    const remain = width - stripAnsi(titleStr).length - 2;
+    const left = Math.floor(remain / 2);
+    const right = remain - left;
+    return `${dim(p, BOX_TL)}${dim(p, BOX_H.repeat(left))}${titleStr}${dim(p, BOX_H.repeat(right))}${dim(p, BOX_TR)}`;
+}
+function boxBottom(p, width = 50) {
+    return `${dim(p, BOX_BL)}${dim(p, BOX_H.repeat(width))}${dim(p, BOX_BR)}`;
+}
+function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+export function statusCard(p, data) {
+    const w = 52;
+    const lines = [];
+    lines.push(boxTop(p, themed(p, "header", t("ui.statusCard.title")), w));
+    lines.push(boxLine(p, `${dim(p, t("ui.statusCard.intent"))} ${themed(p, "info", data.intent)}`, w));
+    lines.push(boxLine(p, `${dim(p, t("ui.statusCard.provider"))} ${themed(p, "agent", data.provider)}${data.model ? ` / ${themed(p, "task", data.model)}` : ""}`, w));
+    if (data.runtime)
+        lines.push(boxLine(p, `${dim(p, t("ui.statusCard.runtime"))} ${data.runtime}`, w));
+    if (data.risk)
+        lines.push(boxLine(p, `${dim(p, t("ui.statusCard.risk"))} ${themed(p, "warning", data.risk)}`, w));
+    if (data.mcpCount !== undefined)
+        lines.push(boxLine(p, `${dim(p, t("ui.statusCard.mcp"))} ${themed(p, "tool", String(data.mcpCount))}`, w));
+    if (data.skillCount !== undefined)
+        lines.push(boxLine(p, `${dim(p, t("ui.statusCard.skills"))} ${themed(p, "tool", String(data.skillCount))}`, w));
+    if (data.durationMs !== undefined) {
+        const dur = data.durationMs >= 1000 ? `${(data.durationMs / 1000).toFixed(1)}s` : `${data.durationMs}ms`;
+        lines.push(boxLine(p, `${dim(p, t("ui.statusCard.duration"))} ${themed(p, "info", dur)}`, w));
+    }
+    lines.push(boxBottom(p, w));
+    return lines.join("\n");
+}
+export function providerCard(p, data) {
+    const w = 52;
+    const lines = [];
+    lines.push(boxTop(p, themed(p, "header", t("ui.providerCard.title")), w));
+    lines.push(boxLine(p, `${dim(p, t("ui.providerCard.provider"))} ${themed(p, "agent", data.provider)}`, w));
+    lines.push(boxLine(p, `${dim(p, t("ui.providerCard.model"))} ${themed(p, "task", data.model)}`, w));
+    if (data.runtimeMode)
+        lines.push(boxLine(p, `${dim(p, t("ui.providerCard.mode"))} ${data.runtimeMode}`, w));
+    if (data.apiBase)
+        lines.push(boxLine(p, `${dim(p, t("ui.providerCard.api"))} ${dim(p, data.apiBase)}`, w));
+    if (data.connected !== undefined) {
+        const statusText = data.connected ? themed(p, "success", "●") : themed(p, "error", "○");
+        lines.push(boxLine(p, `${dim(p, t("ui.providerCard.status"))} ${statusText}`, w));
+    }
+    lines.push(boxBottom(p, w));
+    return lines.join("\n");
+}
+export function memoryCard(p, data) {
+    const w = 52;
+    const lines = [];
+    lines.push(boxTop(p, themed(p, "header", t("ui.memoryCard.title")), w));
+    if (data.projectId)
+        lines.push(boxLine(p, `${dim(p, t("ui.memoryCard.project"))} ${dim(p, data.projectId.slice(0, 12))}`, w));
+    if (data.decisions !== undefined)
+        lines.push(boxLine(p, `${dim(p, t("ui.memoryCard.decisions"))} ${themed(p, "info", String(data.decisions))}`, w));
+    if (data.todos !== undefined)
+        lines.push(boxLine(p, `${dim(p, t("ui.memoryCard.todos"))} ${themed(p, "warning", String(data.todos))}`, w));
+    if (data.facts !== undefined)
+        lines.push(boxLine(p, `${dim(p, t("ui.memoryCard.facts"))} ${themed(p, "tool", String(data.facts))}`, w));
+    if (data.lastUpdated)
+        lines.push(boxLine(p, `${dim(p, t("ui.memoryCard.updated"))} ${dim(p, data.lastUpdated)}`, w));
+    lines.push(boxBottom(p, w));
+    return lines.join("\n");
+}
+export function mcpHealthCard(p, data) {
+    const w = 52;
+    const lines = [];
+    lines.push(boxTop(p, themed(p, "header", t("ui.mcpCard.title")), w));
+    for (const srv of data.servers) {
+        let statusIcon;
+        switch (srv.status) {
+            case "connected":
+                statusIcon = themed(p, "success", "●");
+                break;
+            case "failed":
+                statusIcon = themed(p, "error", "✖");
+                break;
+            case "disabled":
+                statusIcon = dim(p, "○");
+                break;
+            case "pending":
+                statusIcon = themed(p, "warning", "◌");
+                break;
+        }
+        const toolStr = srv.toolCount !== undefined ? dim(p, ` (${srv.toolCount})`) : "";
+        const errStr = srv.error ? ` ${dim(p, "—")} ${themed(p, "error", srv.error)}` : "";
+        lines.push(boxLine(p, `  ${statusIcon} ${themed(p, "tool", srv.name)}${toolStr}${errStr}`, w));
+    }
+    if (data.totalTools !== undefined) {
+        lines.push(boxLine(p, separator(p, w - 4), w));
+        lines.push(boxLine(p, `${dim(p, t("ui.mcpCard.total"))} ${themed(p, "info", String(data.totalTools))}`, w));
+    }
+    lines.push(boxBottom(p, w));
+    return lines.join("\n");
+}
+export function errorBox(p, data) {
+    const w = 52;
+    const lines = [];
+    const title = data.recoverable ? t("ui.errorBox.recoverable") : t("ui.errorBox.fatal");
+    lines.push(boxTop(p, themed(p, "error", title), w));
+    lines.push(boxLine(p, themed(p, "error", data.message), w));
+    if (data.code)
+        lines.push(boxLine(p, `${dim(p, t("ui.errorBox.code"))} ${themed(p, "warning", data.code)}`, w));
+    if (data.suggestion)
+        lines.push(boxLine(p, `${dim(p, t("ui.errorBox.suggestion"))} ${data.suggestion}`, w));
+    lines.push(boxBottom(p, w));
+    return lines.join("\n");
+}
+// ─── traceSummary ─────────────────────────────────────────────────────────────
+export function traceSummaryCard(p, trace) {
+    const w = 52;
+    const lines = [];
+    lines.push(boxTop(p, themed(p, "header", t("ui.traceCard.title")), w));
+    lines.push(boxLine(p, `${dim(p, t("ui.traceCard.intent"))} ${themed(p, "info", trace.userIntent.classified)}`, w));
+    lines.push(boxLine(p, `${dim(p, t("ui.traceCard.risk"))} ${themed(p, "warning", trace.userIntent.risk)}`, w));
+    lines.push(boxLine(p, `${dim(p, t("ui.traceCard.plan"))} ${trace.plan.summary.slice(0, 40)}`, w));
+    const tools = trace.execution.toolSequence.map(tc => tc.name).join(", ");
+    lines.push(boxLine(p, `${dim(p, t("ui.traceCard.tools"))} ${dim(p, tools.slice(0, 40))}`, w));
+    const statusIcon = trace.result.status === "success" ? themed(p, "success", "✔") :
+        trace.result.status === "partial" ? themed(p, "warning", "◐") :
+            themed(p, "error", "✖");
+    lines.push(boxLine(p, `${dim(p, t("ui.traceCard.result"))} ${statusIcon} ${trace.result.summary.slice(0, 35)}`, w));
+    lines.push(boxLine(p, `${dim(p, t("ui.traceCard.confidence"))} ${themed(p, "info", `${(trace.result.confidence * 100).toFixed(0)}%`)}`, w));
+    lines.push(boxBottom(p, w));
+    return lines.join("\n");
+}
+export function traceSummaryCompact(p, summary) {
+    const statusIcon = summary.outcome === "success" ? themed(p, "success", "✔") :
+        summary.outcome === "partial" ? themed(p, "warning", "◐") :
+            themed(p, "error", "✖");
+    return `${statusIcon} ${dim(p, summary.intent)} → ${summary.planSummary.slice(0, 60)} ${dim(p, `[${summary.confidence}%]`)}`;
+}
+export function consentNotice(p, data) {
+    const w = 52;
+    const lines = [];
+    lines.push(boxTop(p, themed(p, "header", t("ui.consent.title")), w));
+    const levelLabel = t(`ui.consent.level.${data.level}`);
+    lines.push(boxLine(p, `${dim(p, t("ui.consent.level"))} ${themed(p, "info", levelLabel)}`, w));
+    const datasetIcon = data.includedInDataset
+        ? themed(p, "success", t("ui.consent.eligible"))
+        : themed(p, "warning", t("ui.consent.notEligible"));
+    lines.push(boxLine(p, `${dim(p, t("ui.consent.dataset"))} ${datasetIcon}`, w));
+    if (data.redactedFields && data.redactedFields.length > 0) {
+        lines.push(boxLine(p, `${dim(p, t("ui.consent.redacted"))} ${dim(p, data.redactedFields.join(", "))}`, w));
+    }
+    lines.push(boxBottom(p, w));
+    return lines.join("\n");
+}
+// ─── i18n keys for UI components ──────────────────────────────────────────────
+// These should be added to src/util/i18n.ts EN/KO dictionaries.
+//
+// EN:
+//   ui.statusCard.title: "Runtime Status"
+//   ui.statusCard.intent: "Intent:"
+//   ui.statusCard.provider: "Provider:"
+//   ui.statusCard.runtime: "Runtime:"
+//   ui.statusCard.risk: "Risk:"
+//   ui.statusCard.mcp: "MCP:"
+//   ui.statusCard.skills: "Skills:"
+//   ui.statusCard.duration: "Duration:"
+//   ui.providerCard.title: "Provider"
+//   ui.providerCard.provider: "Provider:"
+//   ui.providerCard.model: "Model:"
+//   ui.providerCard.mode: "Mode:"
+//   ui.providerCard.api: "API:"
+//   ui.providerCard.status: "Status:"
+//   ui.memoryCard.title: "Memory"
+//   ui.memoryCard.project: "Project:"
+//   ui.memoryCard.decisions: "Decisions:"
+//   ui.memoryCard.todos: "Todos:"
+//   ui.memoryCard.facts: "Facts:"
+//   ui.memoryCard.updated: "Updated:"
+//   ui.mcpCard.title: "MCP Health"
+//   ui.mcpCard.total: "Total tools:"
+//   ui.errorBox.recoverable: "Recoverable Error"
+//   ui.errorBox.fatal: "Fatal Error"
+//   ui.errorBox.code: "Code:"
+//   ui.errorBox.suggestion: "Suggestion:"
+//   ui.traceCard.title: "Reasoning Trace"
+//   ui.traceCard.intent: "Intent:"
+//   ui.traceCard.risk: "Risk:"
+//   ui.traceCard.plan: "Plan:"
+//   ui.traceCard.tools: "Tools:"
+//   ui.traceCard.result: "Result:"
+//   ui.traceCard.confidence: "Confidence:"
+//   ui.consent.title: "Data Consent"
+//   ui.consent.level: "Level:"
+//   ui.consent.level.l0: "L0 — Ops Stats"
+//   ui.consent.level.l1: "L1 — Trace Meta"
+//   ui.consent.level.l2: "L2 — Trajectory"
+//   ui.consent.level.l3: "L3 — Sample Pack"
+//   ui.consent.dataset: "Dataset:"
+//   ui.consent.eligible: "Eligible"
+//   ui.consent.notEligible: "Not eligible"
+//   ui.consent.redacted: "Redacted:"