open-multi-agent-kit 0.80.2 → 0.80.3

package/dist/benchmark/harness.js

@@ -1,191 +0,0 @@
-/**
- * Benchmark Harness — run benchmark suite, compute metrics, write report.
- */
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { performance } from "node:perf_hooks";
-import { generateSyntheticTraces, loadRecordedTraces, hashConfig } from "./fixtures.js";
-import { createShadowModeEngine } from "./shadow-mode.js";
-import { createEvidenceTrustScoreV2Engine } from "../evidence/evidence-trust-score.js";
-function capsuleFromTask(task) {
-    return {
-        runId: task.taskId,
-        nodeId: task.taskId,
-        goal: task.description,
-        system: "Benchmark system prompt",
-        task: task.description,
-        dependencySummaries: [],
-        relevantFiles: task.relevantFiles.map((path) => ({
-            path,
-            startLine: 1,
-            endLine: 10,
-            content: "// synthetic",
-        })),
-        graphMemory: [],
-        priorAttempts: [],
-        evidenceRequirements: [],
-        budget: { maxInputTokens: 8000, reservedOutputTokens: 4096, maxFileTokens: 4096, maxToolResultTokens: 2048, maxMemoryFacts: 10, compression: "lossless-ish" },
-        node: {
-            id: task.taskId,
-            name: task.description,
-            role: "coder",
-            dependsOn: [],
-            status: "running",
-            retries: 0,
-            maxRetries: 1,
-        },
-    };
-}
-function mapGateToKind(gate) {
-    switch (gate) {
-        case "test": return "test";
-        case "lint": return "command";
-        case "audit": return "audit";
-        case "review": return "review";
-        case "command": return "command";
-        case "stdout-match": return "trace";
-        case "diff": return "diff";
-        default: return "trace";
-    }
-}
-function attemptToEvidenceItem(attempt) {
-    return attempt.evidenceResults.map((ev) => ({
-        id: `${attempt.attemptId}-${ev.gate}`,
-        kind: mapGateToKind(ev.gate),
-        source: "runner",
-        description: ev.gate,
-        verdict: (ev.passed ? "pass" : "fail"),
-        timestamp: new Date().toISOString(),
-        confidence: 0.9,
-        linkedFilePaths: [...attempt.changedFiles],
-    }));
-}
-export async function runBenchmarkSuite(options) {
-    const startedAt = new Date().toISOString();
-    const startedMs = performance.now();
-    const { config, runtimes, history = [] } = options;
-    await mkdir(config.outputDir, { recursive: true });
-    // Load tasks
-    const tasks = [];
-    if (config.mode === "shadow") {
-        const version = process.env.npm_package_version ?? "0.0.0";
-        const treeHash = config.pinTreeHash ?? "synthetic";
-        const seed = config.pinSeed ?? 42;
-        const providerHash = config.pinProviderConfigHash ?? hashConfig(runtimes.map((r) => r.id));
-        const fixture = generateSyntheticTraces(2, seed, version, treeHash, providerHash);
-        tasks.push(...fixture.tasks);
-    }
-    else {
-        const fixture = await loadRecordedTraces(config.tasksDir);
-        tasks.push(...fixture.tasks);
-    }
-    if (config.categories && config.categories.length > 0) {
-        const allowed = new Set(config.categories);
-        const filtered = tasks.filter((t) => allowed.has(t.category));
-        tasks.length = 0;
-        tasks.push(...filtered);
-    }
-    const shadowEngine = createShadowModeEngine({ runtimes, history });
-    const etsEngine = createEvidenceTrustScoreV2Engine();
-    const results = [];
-    for (const task of tasks) {
-        const capsule = capsuleFromTask(task);
-        const shadowRecord = shadowEngine.evaluate(task.taskId, task.taskId, capsule);
-        const decisions = shadowEngine.toBenchmarkDecision(shadowRecord);
-        // Simulate execution using recorded attempts
-        const lastAttempt = task.recordedAttempts[task.recordedAttempts.length - 1];
-        const solved = lastAttempt?.status === "success";
-        const fallbackUsed = task.recordedAttempts.length > 1;
-        const fallbackSucceeded = fallbackUsed && solved;
-        const rolledBack = task.recordedAttempts.some((a) => a.status === "cancelled");
-        const sandboxViolations = task.recordedAttempts.some((a) => a.changedFiles.some((f) => f.startsWith("/") && !f.includes("worktree")))
-            ? 1
-            : 0;
-        // ETS v2 evaluation
-        const allEvidence = task.recordedAttempts.flatMap((a) => attemptToEvidenceItem(a));
-        const etsResult = await etsEngine.evaluate({
-            output: lastAttempt?.summary ?? "",
-            taskType: task.category.includes("security") ? "security" : "feature",
-            risk: task.category.includes("security") ? "critical" : "medium",
-            runArtifacts: {
-                items: allEvidence,
-                meta: {
-                    runId: task.taskId,
-                    nodeId: task.taskId,
-                    provider: lastAttempt?.provider ?? "unknown",
-                    model: lastAttempt?.model ?? "unknown",
-                    cwd: "[repo-root]",
-                    treeHashBefore: task.treeHash,
-                    treeHashAfter: task.treeHash,
-                    commandHash: hashConfig(task.recordedAttempts.map((a) => a.commandsRun)),
-                    timestamp: new Date().toISOString(),
-                    command: task.recordedAttempts.map((a) => a.commandsRun.join("; ")).join(" || "),
-                },
-            },
-            dependencyGraphFiles: task.relevantFiles,
-        });
-        const falseDone = !solved && etsResult.verdict === "pass";
-        const totalLatency = task.recordedAttempts.reduce((s, a) => s + a.latencyMs, 0);
-        const totalCost = task.recordedAttempts.reduce((s, a) => s + a.costUsdEstimated, 0);
-        results.push({
-            taskId: task.taskId,
-            solved,
-            evidenceTrustScore: etsResult.score,
-            falseDone,
-            fallbackUsed,
-            fallbackSucceeded,
-            routerRegret: shadowRecord.regretV2,
-            costUsd: totalCost,
-            latencyMs: totalLatency,
-            rolledBack,
-            sandboxViolations,
-            attemptCount: task.recordedAttempts.length,
-            decisions,
-        });
-    }
-    const completedAt = new Date().toISOString();
-    const durationMs = Math.round(performance.now() - startedMs);
-    const solvedCount = results.filter((r) => r.solved).length;
-    const totalTasks = results.length;
-    const solveRate = totalTasks > 0 ? solvedCount / totalTasks : 0;
-    const evidenceMean = totalTasks > 0 ? results.reduce((s, r) => s + r.evidenceTrustScore, 0) / totalTasks : 0;
-    const falseDoneRate = totalTasks > 0 ? results.filter((r) => r.falseDone).length / totalTasks : 0;
-    const fallbackAttempts = results.filter((r) => r.fallbackUsed);
-    const fallbackSuccessRate = fallbackAttempts.length > 0
-        ? fallbackAttempts.filter((r) => r.fallbackSucceeded).length / fallbackAttempts.length
-        : 0;
-    const routerRegretMean = totalTasks > 0 ? results.reduce((s, r) => s + r.routerRegret, 0) / totalTasks : 0;
-    const costPerSolved = solvedCount > 0 ? results.reduce((s, r) => s + r.costUsd, 0) / solvedCount : 0;
-    const latencies = results.map((r) => r.latencyMs).sort((a, b) => a - b);
-    const p95Latency = latencies.length > 0 ? latencies[Math.floor(latencies.length * 0.95)] ?? latencies[latencies.length - 1] : 0;
-    const rollbackRate = totalTasks > 0 ? results.filter((r) => r.rolledBack).length / totalTasks : 0;
-    const sandboxViolationCount = results.reduce((s, r) => s + r.sandboxViolations, 0);
-    const summary = {
-        schemaVersion: "omk.benchmark.v1",
-        runId: config.runId,
-        startedAt,
-        completedAt,
-        durationMs,
-        treeHash: config.pinTreeHash ?? "synthetic",
-        seed: config.pinSeed ?? 42,
-        providerConfigHash: config.pinProviderConfigHash ?? hashConfig(runtimes.map((r) => r.id)),
-        omkVersion: process.env.npm_package_version ?? "0.0.0",
-        mode: config.mode,
-        totalTasks,
-        solvedCount,
-        solveRate,
-        evidenceTrustScoreMean: evidenceMean,
-        falseDoneRate,
-        fallbackSuccessRate,
-        routerRegretMean,
-        costPerSolvedTask: costPerSolved,
-        p95LatencyMs: p95Latency,
-        rollbackRate,
-        sandboxViolationCount,
-        results,
-    };
-    const outPath = join(config.outputDir, `${config.runId}.json`);
-    await writeFile(outPath, JSON.stringify(summary, null, 2), "utf-8");
-    return summary;
-}
-export { createShadowModeEngine, computeRouterRegret } from "./shadow-mode.js";

package/dist/benchmark/shadow-mode.d.ts

@@ -1,17 +0,0 @@
-/**
- * Shadow Mode Engine — side-by-side router v1/v2 recording.
- */
-import type { AgentRuntime } from "../runtime/agent-runtime.js";
-import type { ContextCapsule } from "../runtime/context-capsule.js";
-import type { EvidenceHistoryEntry } from "../runtime/contracts/router-v2.js";
-import type { ShadowModeRecord, BenchmarkDecisionRecord } from "./contracts.js";
-export interface ShadowModeOptions {
-    readonly runtimes: AgentRuntime[];
-    readonly history: EvidenceHistoryEntry[];
-}
-export interface ShadowModeEngine {
-    evaluate(taskId: string, nodeId: string, capsule: ContextCapsule): ShadowModeRecord;
-    toBenchmarkDecision(record: ShadowModeRecord): BenchmarkDecisionRecord[];
-}
-export declare function createShadowModeEngine(options: ShadowModeOptions): ShadowModeEngine;
-export declare function computeRouterRegret(candidates: AgentRuntime[], intent: string, history: EvidenceHistoryEntry[], selectedId: string): number;

package/dist/benchmark/shadow-mode.js

@@ -1,95 +0,0 @@
-/**
- * Shadow Mode Engine — side-by-side router v1/v2 recording.
- */
-import { createRuntimeRouter } from "../runtime/runtime-router.js";
-import { createRouterV2ScoringEngine, scoreRuntimes } from "../runtime/router-v2-scoring.js";
-export function createShadowModeEngine(options) {
-    const v1Router = createRuntimeRouter({ runtimes: options.runtimes });
-    const v2Engine = createRouterV2ScoringEngine();
-    function computeRegret(scores, selectedId) {
-        if (scores.length === 0)
-            return 0;
-        const best = Math.max(...scores.map((s) => s.composite));
-        const selected = scores.find((s) => s.runtimeId === selectedId)?.composite ?? 0;
-        return Math.max(0, best - selected);
-    }
-    function evaluate(taskId, nodeId, capsule) {
-        const intent = v1Router.classifyIntent(capsule);
-        let v1Decision = null;
-        let regretV1 = 0;
-        try {
-            v1Decision = v1Router.selectByIntent(capsule, options.history);
-            const v1Scores = v1Decision.scores.map((s) => ({
-                runtimeId: s.runtime,
-                composite: 0.35 * s.qualityScore +
-                    0.25 * s.evidencePassRate +
-                    0.15 * s.costScore +
-                    0.1 * s.latencyScore +
-                    0.15 * (1 - s.recentFailurePenalty),
-            }));
-            regretV1 = computeRegret(v1Scores, v1Decision.runtime.id);
-        }
-        catch {
-            v1Decision = null;
-            regretV1 = 1;
-        }
-        let v2Decision = null;
-        let regretV2 = 0;
-        try {
-            v2Decision = v2Engine.select(options.runtimes, intent, options.history);
-            const v2Scores = v2Decision.scores.map((s) => ({
-                runtimeId: s.runtimeId,
-                composite: s.composite,
-            }));
-            regretV2 = computeRegret(v2Scores, v2Decision.runtime.id);
-        }
-        catch {
-            v2Decision = null;
-            regretV2 = 1;
-        }
-        const disagreement = v1Decision?.runtime.id !== v2Decision?.runtime.id;
-        return {
-            taskId,
-            nodeId,
-            intent,
-            v1Decision,
-            v2Decision,
-            regretV1,
-            regretV2,
-            disagreement,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    function toBenchmarkDecision(record) {
-        const out = [];
-        if (record.v1Decision) {
-            out.push({
-                component: "runtime-router-v1",
-                selectedRuntime: record.v1Decision.runtime.id,
-                bestAvailableRuntime: record.v2Decision?.scores[0]?.runtimeId ?? record.v1Decision.runtime.id,
-                regret: record.regretV1,
-                reason: record.v1Decision.reason,
-            });
-        }
-        if (record.v2Decision) {
-            out.push({
-                component: "runtime-router-v2",
-                selectedRuntime: record.v2Decision.runtime.id,
-                bestAvailableRuntime: record.v2Decision.scores[0]?.runtimeId ?? record.v2Decision.runtime.id,
-                regret: record.regretV2,
-                reason: record.v2Decision.reason,
-                scoresV2: record.v2Decision.scores,
-            });
-        }
-        return out;
-    }
-    return { evaluate, toBenchmarkDecision };
-}
-export function computeRouterRegret(candidates, intent, history, selectedId) {
-    const scores = scoreRuntimes(candidates, intent, history);
-    if (scores.length === 0)
-        return 0;
-    const best = Math.max(...scores.map((s) => s.composite));
-    const selected = scores.find((s) => s.runtimeId === selectedId)?.composite ?? 0;
-    return Math.max(0, best - selected);
-}

package/dist/brand/matrix-rain.d.ts

@@ -1,15 +0,0 @@
-interface Drop {
-    x: number;
-    y: number;
-    speed: number;
-    length: number;
-    chars: string[];
-    tick: number;
-    brightness: number;
-}
-export declare function generateMatrixRainFrame(width: number, height: number, drops: Drop[]): {
-    frame: string;
-    drops: Drop[];
-};
-export declare function renderMatrixRain(runId: string, width?: number, height?: number): string;
-export {};

package/dist/brand/matrix-rain.js

@@ -1,132 +0,0 @@
-const KA = "ｦｧｨｩｪｫｬｭｮｯｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜﾝ";
-const HEX = "0123456789ABCDEF";
-const SYMBOLS = "!@#$%^&*()_+-=[]{}|;:',.<>?/`~";
-const CHARS = KA + HEX + SYMBOLS + KA;
-function randChar() {
-    return CHARS[Math.floor(Math.random() * CHARS.length)];
-}
-export function generateMatrixRainFrame(width, height, drops) {
-    if (drops.length === 0) {
-        const count = Math.max(4, Math.floor(width / 6));
-        for (let i = 0; i < count; i++) {
-            drops.push({
-                x: Math.floor(Math.random() * width),
-                y: -Math.floor(Math.random() * height),
-                speed: 1 + Math.floor(Math.random() * 3),
-                length: 3 + Math.floor(Math.random() * 12),
-                chars: [],
-                tick: 0,
-                brightness: 0.3 + Math.random() * 0.7,
-            });
-        }
-    }
-    const grid = Array.from({ length: height }, () => Array(width).fill(" "));
-    const gridAlpha = Array.from({ length: height }, () => Array(width).fill(0));
-    for (const drop of drops) {
-        drop.tick++;
-        if (drop.tick % drop.speed === 0) {
-            drop.y++;
-            drop.chars.unshift(randChar());
-            if (drop.chars.length > drop.length)
-                drop.chars.pop();
-        }
-        for (let i = 0; i < drop.chars.length; i++) {
-            const row = drop.y - i;
-            if (row >= 0 && row < height && drop.x >= 0 && drop.x < width) {
-                grid[row][drop.x] = i === 0 && drop.brightness > 0.7
-                    ? drop.chars[i]
-                    : i === 1 ? randChar() : drop.chars[i];
-                const alpha = i === 0 ? drop.brightness : Math.max(0.05, drop.brightness - i * 0.08);
-                gridAlpha[row][drop.x] = Math.max(gridAlpha[row][drop.x], alpha);
-            }
-        }
-        if (drop.y - drop.length > height) {
-            drop.y = -drop.length;
-            drop.x = Math.floor(Math.random() * width);
-            drop.speed = 1 + Math.floor(Math.random() * 3);
-            drop.length = 3 + Math.floor(Math.random() * 12);
-            drop.brightness = 0.3 + Math.random() * 0.7;
-            drop.chars = [];
-        }
-    }
-    let frame = "";
-    for (let row = 0; row < height; row++) {
-        for (let col = 0; col < width; col++) {
-            const c = grid[row][col];
-            const a = gridAlpha[row][col];
-            if (c === " ") {
-                frame += " ";
-            }
-            else if (a > 0.7) {
-                frame += c;
-            }
-            else if (a > 0.4) {
-                frame += c;
-            }
-            else if (a > 0.15) {
-                frame += c;
-            }
-            else {
-                frame += " ";
-            }
-        }
-        if (row < height - 1)
-            frame += "\n";
-    }
-    return { frame, drops };
-}
-export function renderMatrixRain(runId, width = 40, height = 5) {
-    let hash = 0;
-    for (let i = 0; i < runId.length; i++) {
-        hash = ((hash << 5) - hash) + runId.charCodeAt(i);
-        hash |= 0;
-    }
-    const SEED = (n) => {
-        let h = hash + n;
-        h = Math.imul(h ^ (h >>> 16), 0x85ebca6b);
-        h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);
-        return (h ^ (h >>> 16)) >>> 0;
-    };
-    const rows = [];
-    const dropPositions = new Set();
-    const dropCount = Math.max(3, Math.floor(width / 8));
-    for (let i = 0; i < dropCount; i++) {
-        dropPositions.add(SEED(i * 7) % width);
-    }
-    for (let row = 0; row < height; row++) {
-        let line = "";
-        for (let col = 0; col < width; col++) {
-            if (dropPositions.has(col)) {
-                const offset = (row + SEED(col * 13) % 8) % (height + 4);
-                const headPos = SEED(col * 17 + row * 3) % (height + 4);
-                const dropLen = 2 + (SEED(col * 19) % 6);
-                if (offset <= headPos) {
-                    const distFromHead = headPos - offset;
-                    if (distFromHead === 0 && offset < height) {
-                        line += CHARS.charAt(SEED(col * 23 + row * 7) % CHARS.length);
-                    }
-                    else if (distFromHead <= dropLen && offset < height) {
-                        const char = CHARS.charAt(SEED(col * 29 + row * 11) % CHARS.length);
-                        if (distFromHead === 1)
-                            line += char;
-                        else if (distFromHead <= 3)
-                            line += char;
-                        else
-                            line += " ";
-                    }
-                    else {
-                        line += " ";
-                    }
-                }
-                else {
-                    line += " ";
-                }
-            }
-            else {
-                line += " ";
-            }
-        }
-        rows.push(line);
-    }
-    return rows.join("\n");
-}

package/dist/brand/night-city.theme.json

@@ -1,178 +0,0 @@
-{
-    "$schema": "../schemas/omk.theme.v1.schema.json",
-    "schemaVersion": "omk.theme.v1",
-    "name": "night-city",
-    "displayName": "OMK//CONTROL — Night City Ops Console",
-    "mode": "dark",
-    "primitives": {
-        "dark": "#070B14",
-        "surface": "#101826",
-        "cyan": "#00D6FF",
-        "mint": "#00FFC2",
-        "magenta": "#FF47B2",
-        "purple": "#9D4EDD",
-        "amber": "#FFB000",
-        "red": "#FF5874",
-        "cream": "#E8F8FF",
-        "muted": "#9DB3C7",
-        "gray": "#758FA8"
-    },
-    "backgrounds": [
-        "dark",
-        "surface"
-    ],
-    "semantics": {
-        "route.active": {
-            "color": "cyan",
-            "glyph": "▸",
-            "usage": "text"
-        },
-        "route.fallback": {
-            "color": "amber",
-            "glyph": "↻",
-            "usage": "text"
-        },
-        "route.dead": {
-            "color": "red",
-            "glyph": "✕",
-            "usage": "text"
-        },
-        "evidence.pass": {
-            "color": "mint",
-            "glyph": "✓",
-            "usage": "text"
-        },
-        "evidence.fail": {
-            "color": "red",
-            "glyph": "✗",
-            "usage": "text"
-        },
-        "evidence.pending": {
-            "color": "amber",
-            "glyph": "◐",
-            "usage": "text"
-        },
-        "dag.lane.running": {
-            "color": "cyan",
-            "glyph": "▶",
-            "usage": "text"
-        },
-        "dag.lane.blocked": {
-            "color": "amber",
-            "glyph": "⏸",
-            "usage": "text"
-        },
-        "dag.lane.done": {
-            "color": "mint",
-            "glyph": "●",
-            "usage": "text"
-        },
-        "dag.lane.queued": {
-            "color": "muted",
-            "glyph": "◌",
-            "usage": "text"
-        },
-        "telemetry.info": {
-            "color": "cream",
-            "glyph": "·",
-            "usage": "text"
-        },
-        "telemetry.warn": {
-            "color": "amber",
-            "glyph": "▲",
-            "usage": "text"
-        },
-        "telemetry.error": {
-            "color": "red",
-            "glyph": "✖",
-            "usage": "text"
-        },
-        "control.accent": {
-            "color": "purple",
-            "glyph": "◆",
-            "kind": "chrome",
-            "usage": "indicator"
-        },
-        "control.dim": {
-            "color": "gray",
-            "glyph": "┊",
-            "kind": "chrome",
-            "usage": "text"
-        },
-        "control.fg": {
-            "color": "cream",
-            "kind": "chrome",
-            "usage": "text"
-        },
-        "control.bg": {
-            "color": "dark",
-            "kind": "background",
-            "usage": "background"
-        }
-    },
-    "components": {
-        "statusCard": {
-            "border": "control.accent",
-            "title": "control.fg",
-            "body": "telemetry.info",
-            "meta": "control.dim"
-        },
-        "routerTable": {
-            "active": "route.active",
-            "fallback": "route.fallback",
-            "dead": "route.dead",
-            "header": "control.accent"
-        },
-        "evidenceGate": {
-            "pass": "evidence.pass",
-            "fail": "evidence.fail",
-            "pending": "evidence.pending"
-        },
-        "dagLanes": {
-            "running": "dag.lane.running",
-            "blocked": "dag.lane.blocked",
-            "done": "dag.lane.done",
-            "queued": "dag.lane.queued"
-        },
-        "logStream": {
-            "info": "telemetry.info",
-            "warn": "telemetry.warn",
-            "error": "telemetry.error",
-            "dim": "control.dim"
-        }
-    },
-    "fallback16": {
-        "route.active": "brightCyan",
-        "route.fallback": "brightYellow",
-        "route.dead": "brightRed",
-        "evidence.pass": "brightGreen",
-        "evidence.fail": "brightRed",
-        "evidence.pending": "brightYellow",
-        "dag.lane.running": "brightCyan",
-        "dag.lane.blocked": "brightYellow",
-        "dag.lane.done": "brightGreen",
-        "dag.lane.queued": "white",
-        "telemetry.info": "brightWhite",
-        "telemetry.warn": "brightYellow",
-        "telemetry.error": "brightRed",
-        "control.accent": "brightMagenta",
-        "control.dim": "white",
-        "control.fg": "brightWhite",
-        "control.bg": "black"
-    },
-    "meta": {
-        "provenance": "Canonical Night City palette extracted from readmeasset/ASSET_PROVENANCE.md theme mapping + SVG frequency analysis (proof/theme-2026-06-10/phase0-recon.md). #101826 surface and #9DB3C7 muted promoted from SVG/provenance into primitives; src/brand/palette.ts gray #758FA8 kept as control.dim.",
-        "reservedPrimitives": {
-            "magenta": "#FF47B2 is reserved brand accent, referenced by no semantic role yet, so it is not contrast-gated. If a future role adopts it the theme:check gate applies automatically (quantizes to xterm idx 205 #FF5FAF; CR 7.07/6.39 on quantized dark/surface — passes). See proof/theme-2026-06-10/t3-a11y-review.md §5."
-        },
-        "tierAssumptions": "16-color tier is gated against stock VGA/xterm ANSI values; terminals with remapped ANSI-16 palettes (e.g. Solarized) are outside the contract — glyphs are the safety net. NO_COLOR note: control.dim uses ┊ so logStream info (telemetry.info ·) and dim rows stay distinguishable without color (t3-a11y-review.md §4).",
-        "derivedAssets": [
-            "readmeasset/omk-badges.svg",
-            "readmeasset/omk-core-loop.svg",
-            "readmeasset/omk-evidence-ledger.svg",
-            "readmeasset/omk-logo-mark.svg",
-            "readmeasset/omk-provider-lanes.svg"
-        ],
-        "omkVersion": "0.80.2"
-    }
-}

package/dist/brand/omk-matrix-art.d.ts

@@ -1 +0,0 @@
-export declare const OMK_MATRIX_ASCII_ART: string;

package/dist/brand/omk-matrix-art.js

@@ -1,10 +0,0 @@
-export const OMK_MATRIX_ASCII_ART = [
-    "  ╔═ OMK//CONTROL ═════════════════════════════════════════════╗",
-    "  ║ NIGHT CITY OPS      TOKENS: hot   LATENCY: stable         ║",
-    "  ║ NEON GRID ONLINE    ROUTE: armed  VERIFY: gated           ║",
-    "  ║ CYBER SIGNAL BUS    MCP: scoped   HOOKS: armed            ║",
-    "  ║ PARALLEL AGENTS     SKILLS: bound MEMORY: graph           ║",
-    "  ║ METRICS WALL        DIFF: live    WORKTREES: sealed       ║",
-    "  ╚═ route // evidence // telemetry // orchestration ═════════╝",
-    "      ░▒▓  OPEN MULTI-AGENT KIT  ·  GREEN RAIN MODE  ▓▒░      ",
-].join("\n");

package/dist/brand/omk-simple-art.d.ts

@@ -1,7 +0,0 @@
-/**
- * Canonical compact OMK control-plane banner.
- *
- * This intentionally stays <= 5 lines and narrow-terminal friendly for logs,
- * smoke tests, fallback provider paths, and Rust/native safety surfaces.
- */
-export declare const OMK_SIMPLE_ASCII_ART: string;

package/dist/brand/omk-simple-art.js

@@ -1,13 +0,0 @@
-/**
- * Canonical compact OMK control-plane banner.
- *
- * This intentionally stays <= 5 lines and narrow-terminal friendly for logs,
- * smoke tests, fallback provider paths, and Rust/native safety surfaces.
- */
-export const OMK_SIMPLE_ASCII_ART = [
-    "  ╔═ OMK//CONTROL ═══════╗",
-    "  ║ ROUTE  │ VERIFY      ║",
-    "  ║ TOKENS │ AGENTS      ║",
-    "  ║ MCP    │ HOOKS       ║",
-    "  ╚═ METRICS // LIVE ════╝",
-].join("\n");