open-multi-agent-kit 0.78.0

package/dist/awareness/classifiers/browser-console-classifier.js

@@ -0,0 +1,47 @@
+import { readFile } from "fs/promises";
+import { pathExists } from "../../util/fs.js";
+function isConsoleEvent(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const obj = value;
+    return typeof obj.type === "string" && typeof obj.text === "string";
+}
+export async function classifyBrowserConsole(observation) {
+    const path = observation.consoleEventsPath;
+    if (!(await pathExists(path)))
+        return null;
+    let content;
+    try {
+        content = await readFile(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const lines = content.split("\n").filter((line) => line.trim().length > 0);
+    let errorCount = 0;
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (isConsoleEvent(parsed) && (parsed.type === "error" || parsed.type === "pageerror")) {
+                errorCount++;
+            }
+        }
+        catch {
+            // skip corrupt lines
+        }
+    }
+    if (errorCount === 0)
+        return null;
+    const confidence = Math.min(0.5 + errorCount * 0.1, 0.95);
+    return {
+        id: `ntc_bc_${Date.now()}`,
+        createdAt: new Date().toISOString(),
+        source: "browser",
+        type: "console-error",
+        severity: errorCount > 5 ? "warning" : "info",
+        confidence,
+        summary: `${errorCount} console error(s) detected on ${observation.url}`,
+        evidenceRefs: [observation.consoleEventsPath, observation.screenshotPath],
+        suggestedAction: "open-browser-feedback",
+    };
+}

package/dist/awareness/classifiers/evidence-gap-classifier.d.ts

@@ -0,0 +1,3 @@
+import type { GoalSpec, GoalEvidence } from "../../contracts/goal.js";
+import type { Notice } from "../notice.js";
+export declare function classifyEvidenceGap(goal: GoalSpec, evidence: GoalEvidence[]): Notice | null;

package/dist/awareness/classifiers/evidence-gap-classifier.js

@@ -0,0 +1,31 @@
+export function classifyEvidenceGap(goal, evidence) {
+    const requiredCriteria = goal.successCriteria.filter((c) => c.requirement === "required");
+    if (requiredCriteria.length === 0)
+        return null;
+    const evidenceMap = new Map();
+    for (const e of evidence) {
+        if (!evidenceMap.has(e.criterionId)) {
+            evidenceMap.set(e.criterionId, e);
+        }
+    }
+    const missing = requiredCriteria.filter((c) => {
+        const ev = evidenceMap.get(c.id);
+        return !ev || !ev.passed;
+    });
+    if (missing.length === 0)
+        return null;
+    const confidence = Math.min(0.6 + missing.length * 0.05, 0.95);
+    return {
+        id: `ntc_eg_${Date.now()}`,
+        createdAt: new Date().toISOString(),
+        source: "goal",
+        type: "evidence-gap",
+        severity: "warning",
+        confidence,
+        summary: `Goal "${goal.title}" is missing evidence for ${missing.length} required criterion(s): ${missing
+            .map((m) => m.description)
+            .join(", ")}`,
+        evidenceRefs: [],
+        suggestedAction: "continue-goal",
+    };
+}

package/dist/awareness/classifiers/stalled-run-classifier.d.ts

@@ -0,0 +1,2 @@
+import type { Notice } from "../notice.js";
+export declare function classifyStalledRun(runId: string, status: string, lastActivity: string): Notice | null;

package/dist/awareness/classifiers/stalled-run-classifier.js

@@ -0,0 +1,24 @@
+const STALL_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
+export function classifyStalledRun(runId, status, lastActivity) {
+    if (status !== "running")
+        return null;
+    const last = new Date(lastActivity).getTime();
+    const now = Date.now();
+    if (Number.isNaN(last))
+        return null;
+    const elapsed = now - last;
+    if (elapsed < STALL_THRESHOLD_MS)
+        return null;
+    const minutes = Math.round(elapsed / 60_000);
+    return {
+        id: `ntc_sr_${Date.now()}`,
+        createdAt: new Date().toISOString(),
+        source: "run",
+        type: "stalled-run",
+        severity: "blocker",
+        confidence: 0.9,
+        summary: `Run ${runId} has been stalled for ${minutes} minute(s) with no activity.`,
+        evidenceRefs: [],
+        suggestedAction: "replan-goal",
+    };
+}

package/dist/awareness/notice-store.d.ts

@@ -0,0 +1,6 @@
+import type { Notice } from "./notice.js";
+export declare function saveNotice(notice: Omit<Notice, "id" | "createdAt">): Promise<Notice>;
+export declare function listNotices(): Promise<Notice[]>;
+export declare function getNotice(id: string): Promise<Notice | undefined>;
+export declare function resolveNotice(id: string): Promise<Notice | undefined>;
+export declare function listActiveNotices(): Promise<Notice[]>;

package/dist/awareness/notice-store.js

@@ -0,0 +1,91 @@
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { getProjectRoot, pathExists } from "../util/fs.js";
+const STORE_DIR = ".omk/awareness";
+const STORE_FILE = "notices.jsonl";
+function getStorePath() {
+    return join(getProjectRoot(), STORE_DIR, STORE_FILE);
+}
+async function ensureStoreDir() {
+    const dir = join(getProjectRoot(), STORE_DIR);
+    await mkdir(dir, { recursive: true });
+}
+function generateId() {
+    return `ntc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+async function readLines() {
+    const path = getStorePath();
+    if (!(await pathExists(path)))
+        return [];
+    try {
+        const content = await readFile(path, "utf-8");
+        const lines = content.split("\n").filter((line) => line.trim().length > 0);
+        const notices = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (isNotice(parsed))
+                    notices.push(parsed);
+            }
+            catch {
+                // skip corrupt lines
+            }
+        }
+        return notices;
+    }
+    catch {
+        return [];
+    }
+}
+function isNotice(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const obj = value;
+    return (typeof obj.id === "string" &&
+        typeof obj.createdAt === "string" &&
+        typeof obj.source === "string" &&
+        typeof obj.type === "string" &&
+        typeof obj.severity === "string" &&
+        typeof obj.confidence === "number" &&
+        typeof obj.summary === "string" &&
+        Array.isArray(obj.evidenceRefs) &&
+        typeof obj.suggestedAction === "string");
+}
+export async function saveNotice(notice) {
+    const full = {
+        ...notice,
+        id: generateId(),
+        createdAt: new Date().toISOString(),
+    };
+    await ensureStoreDir();
+    const path = getStorePath();
+    const line = JSON.stringify(full) + "\n";
+    await writeFile(path, line, { flag: "a", encoding: "utf-8" });
+    return full;
+}
+export async function listNotices() {
+    return readLines();
+}
+export async function getNotice(id) {
+    const notices = await readLines();
+    return notices.find((n) => n.id === id);
+}
+export async function resolveNotice(id) {
+    const path = getStorePath();
+    const notices = await readLines();
+    const target = notices.find((n) => n.id === id);
+    if (!target)
+        return undefined;
+    const updated = {
+        ...target,
+        resolved: true,
+        resolvedAt: new Date().toISOString(),
+    };
+    const lines = notices.map((n) => (n.id === id ? JSON.stringify(updated) : JSON.stringify(n)));
+    await writeFile(path, lines.join("\n") + "\n", "utf-8");
+    return updated;
+}
+export async function listActiveNotices() {
+    const notices = await readLines();
+    return notices.filter((n) => !n.resolved);
+}

package/dist/awareness/notice.d.ts

@@ -0,0 +1,17 @@
+export type NoticeSource = "appshot" | "browser" | "goal" | "run" | "git" | "test" | "user";
+export type NoticeType = "visual-regression" | "console-error" | "network-failure" | "evidence-gap" | "stalled-run" | "goal-drift" | "duplicate-work" | "missing-test" | "possible-secret" | "user-feedback";
+export type NoticeSeverity = "info" | "warning" | "blocker";
+export type SuggestedAction = "continue-goal" | "replan-goal" | "open-browser-feedback" | "capture-appshot" | "run-tests" | "ask-human" | "block";
+export interface Notice {
+    id: string;
+    createdAt: string;
+    source: NoticeSource;
+    type: NoticeType;
+    severity: NoticeSeverity;
+    confidence: number;
+    summary: string;
+    evidenceRefs: string[];
+    suggestedAction: SuggestedAction;
+    resolved?: boolean;
+    resolvedAt?: string;
+}

package/dist/awareness/notice.js

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

package/dist/awareness/noticer-engine.d.ts

@@ -0,0 +1,42 @@
+import type { BrowserObservation } from "../browser/browser-observer.js";
+import type { GoalEvidence, GoalSpec } from "../contracts/goal.js";
+import type { Notice } from "./notice.js";
+export interface BrowserObservationEvent {
+    kind: "browser-observation";
+    observation: BrowserObservation;
+}
+export interface GoalEvidenceEvent {
+    kind: "goal-evidence";
+    goal: GoalSpec;
+    evidence: GoalEvidence[];
+}
+export interface RunStateEvent {
+    kind: "run-state";
+    runId: string;
+    status: string;
+    lastActivity: string;
+}
+export interface GitDiffEvent {
+    kind: "git-diff";
+    diff: string;
+    ref?: string;
+}
+export interface TestOutputEvent {
+    kind: "test-output";
+    output: string;
+    passed: boolean;
+    suiteName?: string;
+}
+export interface UserFeedbackEvent {
+    kind: "user-feedback";
+    text: string;
+    context?: string;
+}
+export type NoticerEvent = BrowserObservationEvent | GoalEvidenceEvent | RunStateEvent | GitDiffEvent | TestOutputEvent | UserFeedbackEvent;
+export type Classifier = (event: NoticerEvent) => Promise<Notice | Notice[] | null | undefined> | Notice | Notice[] | null | undefined;
+export interface NoticerEngine {
+    ingest(event: NoticerEvent): Promise<Notice[]>;
+    getNotices(): Notice[];
+    addClassifier(classifier: Classifier): void;
+}
+export declare function createNoticerEngine(): NoticerEngine;

package/dist/awareness/noticer-engine.js

@@ -0,0 +1,63 @@
+import { classifyBrowserConsole } from "./classifiers/browser-console-classifier.js";
+import { classifyEvidenceGap } from "./classifiers/evidence-gap-classifier.js";
+import { classifyStalledRun } from "./classifiers/stalled-run-classifier.js";
+export function createNoticerEngine() {
+    const notices = [];
+    const classifiers = [
+        defaultClassifier,
+    ];
+    async function defaultClassifier(event) {
+        switch (event.kind) {
+            case "browser-observation":
+                return classifyBrowserConsole(event.observation);
+            case "goal-evidence":
+                return classifyEvidenceGap(event.goal, event.evidence);
+            case "run-state":
+                return classifyStalledRun(event.runId, event.status, event.lastActivity);
+            case "user-feedback":
+                return classifyUserFeedback(event);
+            default:
+                return null;
+        }
+    }
+    function classifyUserFeedback(event) {
+        return {
+            id: `ntc_uf_${Date.now()}`,
+            createdAt: new Date().toISOString(),
+            source: "user",
+            type: "user-feedback",
+            severity: "info",
+            confidence: 1.0,
+            summary: event.text.slice(0, 200),
+            evidenceRefs: event.context ? [event.context] : [],
+            suggestedAction: "ask-human",
+        };
+    }
+    return {
+        addClassifier(classifier) {
+            classifiers.push(classifier);
+        },
+        async ingest(event) {
+            const produced = [];
+            for (const classifier of classifiers) {
+                try {
+                    const result = await classifier(event);
+                    if (!result)
+                        continue;
+                    const batch = Array.isArray(result) ? result : [result];
+                    for (const notice of batch) {
+                        notices.push(notice);
+                        produced.push(notice);
+                    }
+                }
+                catch {
+                    // classifier errors are swallowed to keep engine resilient
+                }
+            }
+            return produced;
+        },
+        getNotices() {
+            return [...notices];
+        },
+    };
+}

package/dist/awareness/router.d.ts

@@ -0,0 +1,6 @@
+import type { Notice } from "./notice.js";
+export declare function routeNotice(notice: Notice): string;
+export declare function noticeToAction(notice: Notice): {
+    command: string;
+    args: string[];
+} | null;

package/dist/awareness/router.js

@@ -0,0 +1,46 @@
+const ACTION_DESCRIPTIONS = {
+    "continue-goal": "Continue working on the current goal.",
+    "replan-goal": "Replan the current goal based on new information.",
+    "open-browser-feedback": "Open browser feedback to inspect the page.",
+    "capture-appshot": "Capture an appshot for visual verification.",
+    "run-tests": "Run the test suite to verify behavior.",
+    "ask-human": "Ask a human for guidance or confirmation.",
+    block: "Block further progress until this notice is resolved.",
+};
+const ROUTE_MESSAGES = {
+    "visual-regression": "A visual change was detected. Review the screenshot or capture a new appshot.",
+    "console-error": "Console errors were detected during browser observation. Inspect the browser session for details.",
+    "network-failure": "Network failures were detected. Check connectivity and retry.",
+    "evidence-gap": "Required goal evidence is missing. Continue the goal to gather missing evidence.",
+    "stalled-run": "A run appears to be stalled. Consider replanning or asking a human.",
+    "goal-drift": "The current work may have drifted from the original goal. Review and replan if needed.",
+    "duplicate-work": "Possible duplicate work detected. Review existing artifacts before continuing.",
+    "missing-test": "Tests are missing for recent changes. Run tests or add coverage.",
+    "possible-secret": "A possible secret was detected in output. Review and rotate if confirmed.",
+    "user-feedback": "User feedback received. Review and decide on next steps.",
+};
+export function routeNotice(notice) {
+    const base = ROUTE_MESSAGES[notice.type] ?? "Review this notice and take appropriate action.";
+    const action = ACTION_DESCRIPTIONS[notice.suggestedAction];
+    return `${base}\nSuggested action: ${action}`;
+}
+export function noticeToAction(notice) {
+    switch (notice.suggestedAction) {
+        case "continue-goal":
+            return { command: "omk", args: ["goal", "continue"] };
+        case "replan-goal":
+            return { command: "omk", args: ["goal", "replan"] };
+        case "open-browser-feedback":
+            return { command: "omk", args: ["browser", "inspect"] };
+        case "capture-appshot":
+            return { command: "omk", args: ["appshot", "capture"] };
+        case "run-tests":
+            return { command: "omk", args: ["test"] };
+        case "ask-human":
+            return null;
+        case "block":
+            return null;
+        default:
+            return null;
+    }
+}

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,132 @@
+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/omk-matrix-art.d.ts

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

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+/**
+ * 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");