open-multi-agent-kit 0.78.8 → 0.79.3

package/dist/tui/terminal-frame-renderer.js

@@ -1,29 +1,35 @@
+function useScrollSafe(optionsScrollSafe) {
+    if (optionsScrollSafe !== undefined)
+        return optionsScrollSafe;
+    const env = process.env.OMK_TUI_ALT_SCREEN ?? process.env.PI_TUI_ALT_SCREEN ?? "";
+    return !/^(1|true|yes|on|full|alt-screen)$/i.test(env);
+}
 export class TerminalFrameRenderer {
     prevLines = [];
     mode;
     height;
     write;
     clearFrame;
+    scrollSafe;
     constructor(modeOrOptions = "diff", height) {
         if (typeof modeOrOptions === "string") {
             this.mode = modeOrOptions;
             this.height = height;
             this.write = (chunk) => process.stdout.write(chunk);
-            this.clearFrame = () => clearTerminalScreen(this.write);
+            this.scrollSafe = useScrollSafe(undefined);
+            this.clearFrame = () => clearTerminalScreen(this.write, this.scrollSafe);
             return;
         }
         this.mode = modeOrOptions.mode ?? "diff";
         this.height = modeOrOptions.height;
         this.write = modeOrOptions.write ?? ((chunk) => process.stdout.write(chunk));
-        this.clearFrame = modeOrOptions.clear ?? (() => clearTerminalScreen(this.write));
+        this.scrollSafe = useScrollSafe(modeOrOptions.scrollSafe);
+        this.clearFrame = modeOrOptions.clear ?? (() => clearTerminalScreen(this.write, this.scrollSafe));
     }
     render(frame) {
         const newLines = frame.split("\n");
         if (this.mode === "full") {
-            this.clear();
-            const fillsFixedFrame = this.height != null && newLines.length >= Math.max(1, Math.floor(this.height));
-            this.write(fillsFixedFrame ? frame : `${frame}\n`);
-            this.prevLines = [...newLines];
+            this.renderFull(newLines, frame);
             return;
         }
         if (this.mode === "append") {
@@ -31,6 +37,63 @@ export class TerminalFrameRenderer {
             this.prevLines = [...newLines];
             return;
         }
+        if (this.scrollSafe) {
+            this.renderDiffScrollSafe(newLines);
+        }
+        else {
+            this.renderDiffAltScreen(newLines);
+        }
+    }
+    renderFull(newLines, frame) {
+        if (this.scrollSafe) {
+            // On the main screen, do not clear+home. Start a fresh frame below the
+            // current cursor so the user's scrollback position is preserved.
+            if (this.prevLines.length > 0) {
+                this.write("\n\n");
+            }
+        }
+        else {
+            this.clear();
+        }
+        const fillsFixedFrame = this.height != null && newLines.length >= Math.max(1, Math.floor(this.height));
+        this.write(fillsFixedFrame ? frame : `${frame}\n`);
+        this.prevLines = [...newLines];
+    }
+    renderDiffScrollSafe(newLines) {
+        // First render: just output the frame and remember its line count.
+        if (this.prevLines.length === 0) {
+            this.write(newLines.join("\r\n") + "\r\n");
+            this.prevLines = [...newLines];
+            return;
+        }
+        // Move cursor from the end of the previous frame back to its first line.
+        const parts = [];
+        const moveUp = this.prevLines.length - 1;
+        if (moveUp > 0) {
+            parts.push(`\x1b[${moveUp}A`);
+        }
+        parts.push("\r");
+        const maxLen = Math.max(newLines.length, this.prevLines.length);
+        for (let i = 0; i < maxLen; i++) {
+            const newLine = newLines[i] ?? "";
+            const oldLine = this.prevLines[i] ?? "";
+            if (i < newLines.length) {
+                if (newLine !== oldLine) {
+                    parts.push(`${newLine}\x1b[K`);
+                }
+            }
+            else {
+                // Old line no longer exists: clear it.
+                parts.push("\x1b[K");
+            }
+            if (i < maxLen - 1) {
+                parts.push("\r\n");
+            }
+        }
+        this.write(parts.join(""));
+        this.prevLines = [...newLines];
+    }
+    renderDiffAltScreen(newLines) {
         const parts = ["\x1b[H"];
         const maxLen = Math.max(newLines.length, this.prevLines.length);
         for (let i = 0; i < maxLen; i++) {
@@ -55,6 +118,13 @@ export class TerminalFrameRenderer {
         this.clearFrame();
     }
 }
-export function clearTerminalScreen(write = (chunk) => process.stdout.write(chunk)) {
+export function clearTerminalScreen(write = (chunk) => process.stdout.write(chunk), scrollSafe) {
+    const safe = scrollSafe ?? useScrollSafe(undefined);
+    if (safe) {
+        // Main-screen safe: append blank lines to push old content up instead of
+        // snapping the viewport to the top with clear+home.
+        write("\n\n");
+        return;
+    }
     write("\x1b[2J\x1b[H");
 }

package/dist/util/chat-cockpit.d.ts

@@ -32,7 +32,7 @@ export declare function buildRightPaneCommand(options: {
     height?: number;
     theme?: string;
 }): string;
-export declare function buildTmuxBrandChromeOptions(brand?: string): {
+export declare function buildTmuxBrandChromeOptions(brand?: string, entryDisplayName?: string): {
     sessionOptions: Array<readonly [string, string]>;
     windowOptions: Array<readonly [string, string]>;
 };
@@ -50,5 +50,7 @@ export declare function buildLeftPaneCommand(options: {
     model?: string;
     execution?: string;
     ui?: string;
+    entryDisplayName?: string;
+    entrySurface?: string;
 }): string;
 export declare function shellQuote(value: string): string;

package/dist/util/chat-cockpit.js

@@ -119,6 +119,18 @@ export function resolveCockpitChromeTheme(options) {
     return normalizeBrandChromeTheme(options.env?.OMK_THEME)
         ?? normalizeBrandChromeTheme(options.brand);
 }
+function normalizeEntryDisplayName(value) {
+    const normalized = value
+        ?.replace(/[^A-Za-z0-9+:/._ -]/g, "")
+        .trim();
+    return normalized && normalized.length > 0 ? normalized.slice(0, 20) : undefined;
+}
+function normalizeEntrySurface(value) {
+    const normalized = value
+        ?.replace(/[^A-Za-z0-9._:-]/g, "")
+        .trim();
+    return normalized && normalized.length > 0 ? normalized.slice(0, 64) : undefined;
+}
 export function buildRightPaneCommand(options) {
     let cmd = `${options.nodeCmd} ${options.cliCmd} cockpit --run-id ${shellQuote(options.runId)} --watch --refresh ${options.refreshMs}`;
     const theme = normalizeBrandChromeTheme(options.theme);
@@ -135,9 +147,10 @@ export function buildRightPaneCommand(options) {
 }
 // Active brand tmux chrome. Values are built at launch time so P/BRAND_HEX
 // mutations from setBrandPaletteTheme() are reflected without changing imports.
-export function buildTmuxBrandChromeOptions(brand) {
+export function buildTmuxBrandChromeOptions(brand, entryDisplayName) {
     setBrandPaletteTheme(brand);
-    const statusLeft = `#[fg=${BRAND_HEX.mint},bold] OMK//CONTROL #[fg=${BRAND_HEX.gray}]${getActiveBrandChromeLabel()}`;
+    const controlLabel = normalizeEntryDisplayName(entryDisplayName) ?? "OMK//CONTROL";
+    const statusLeft = `#[fg=${BRAND_HEX.mint},bold] ${controlLabel} #[fg=${BRAND_HEX.gray}]${getActiveBrandChromeLabel()}`;
     const statusRight = `#[fg=${BRAND_HEX.cyan}]#S #[fg=${BRAND_HEX.gray}]%H:%M`;
     return {
         sessionOptions: [
@@ -156,7 +169,7 @@ export function buildTmuxBrandChromeOptions(brand) {
     };
 }
 async function applyTmuxBrandTheme(session, cwd, brand) {
-    const chrome = buildTmuxBrandChromeOptions(brand);
+    const chrome = buildTmuxBrandChromeOptions(brand, process.env.OMK_ENTRY_DISPLAY_NAME);
     for (const [option, value] of chrome.sessionOptions) {
         const result = await runShell("tmux", ["set-option", "-t", session, option, value], { cwd, timeout: 5000 });
         if (result.failed) {
@@ -232,7 +245,24 @@ export async function launchChatCockpit(options = {}) {
         terminalWidth >= 80 &&
         terminalHeight >= MIN_CHAT_COCKPIT_HEIGHT + minHistoryPaneHeight;
     const chromeTheme = resolveCockpitChromeTheme({ brand, env: process.env });
-    const leftCmd = buildLeftPaneCommand({ nodeCmd, cliCmd, runId, brand, agentFile: options.agentFile, workers: options.workers, maxStepsPerTurn: options.maxStepsPerTurn, mcpScope: options.mcpScope, provider: options.provider, model: options.model, execution: options.execution, ui: options.ui });
+    const entryDisplayName = normalizeEntryDisplayName(process.env.OMK_ENTRY_DISPLAY_NAME);
+    const entrySurface = normalizeEntrySurface(process.env.OMK_ENTRY_SURFACE);
+    const leftCmd = buildLeftPaneCommand({
+        nodeCmd,
+        cliCmd,
+        runId,
+        brand,
+        agentFile: options.agentFile,
+        workers: options.workers,
+        maxStepsPerTurn: options.maxStepsPerTurn,
+        mcpScope: options.mcpScope,
+        provider: options.provider,
+        model: options.model,
+        execution: options.execution,
+        ui: options.ui,
+        entrySurface,
+        entryDisplayName,
+    });
     // When no explicit --cockpit-height is provided, pass undefined so the child
     // measures its actual tmux pane after splits/resizes and keeps the right rail pinned.
     const rightTopCmd = buildRightPaneCommand({
@@ -325,7 +355,7 @@ export async function launchChatCockpit(options = {}) {
     }
 }
 export function buildLeftPaneCommand(options) {
-    const { nodeCmd, cliCmd, runId, brand, agentFile, workers, maxStepsPerTurn, mcpScope, provider, model, execution, ui } = options;
+    const { nodeCmd, cliCmd, runId, brand, agentFile, workers, maxStepsPerTurn, mcpScope, provider, model, execution, ui, entrySurface, entryDisplayName, } = options;
     let cmd = `${nodeCmd} ${cliCmd} chat --layout plain --run-id ${shellQuote(runId)} --brand ${shellQuote(brand)}`;
     if (agentFile)
         cmd += ` --agent-file ${shellQuote(agentFile)}`;
@@ -343,6 +373,15 @@ export function buildLeftPaneCommand(options) {
         cmd += ` --execution ${shellQuote(execution)}`;
     if (ui)
         cmd += ` --ui ${shellQuote(ui)}`;
+    const envAssignments = [];
+    const normalizedEntrySurface = normalizeEntrySurface(entrySurface);
+    if (normalizedEntrySurface)
+        envAssignments.push(`OMK_ENTRY_SURFACE=${shellQuote(normalizedEntrySurface)}`);
+    const normalizedEntryDisplayName = normalizeEntryDisplayName(entryDisplayName);
+    if (normalizedEntryDisplayName)
+        envAssignments.push(`OMK_ENTRY_DISPLAY_NAME=${shellQuote(normalizedEntryDisplayName)}`);
+    if (envAssignments.length > 0)
+        cmd = `${envAssignments.join(" ")} ${cmd}`;
     return cmd;
 }
 export function shellQuote(value) {

package/dist/util/command-envelope.d.ts

@@ -0,0 +1,19 @@
+import type { OmkCommandDiagnostic, OmkCommandEnvelope, OmkCommandEnvelopeStatus } from "../contracts/command.js";
+import type { EvidenceRef } from "../contracts/evidence.js";
+export type CreateOmkCommandEnvelopeOptions<TData> = {
+    command: string;
+    status: OmkCommandEnvelopeStatus;
+    data: TData;
+    diagnostics?: OmkCommandDiagnostic[];
+    evidenceRefs?: EvidenceRef[];
+    exitCode?: number;
+    runId?: string;
+    commit?: string;
+    startedAt?: string;
+    finishedAt?: string;
+};
+export declare function createOmkCommandEnvelope<TData>(options: CreateOmkCommandEnvelopeOptions<TData>): OmkCommandEnvelope<TData>;
+export declare function commandDiagnostic(severity: OmkCommandDiagnostic["severity"], code: string, message: string, options?: Partial<Omit<OmkCommandDiagnostic, "severity" | "code" | "message" | "redacted">> & {
+    redacted?: boolean;
+}): OmkCommandDiagnostic;
+export declare function createCommandRunId(prefix?: string): string;

package/dist/util/command-envelope.js

@@ -0,0 +1,31 @@
+import { randomUUID } from "node:crypto";
+import { OMK_COMMAND_SCHEMA_VERSION } from "../version.js";
+export function createOmkCommandEnvelope(options) {
+    const startedAt = options.startedAt ?? new Date().toISOString();
+    return {
+        schemaVersion: OMK_COMMAND_SCHEMA_VERSION,
+        command: options.command,
+        status: options.status,
+        ...(options.runId ? { runId: options.runId } : {}),
+        ...(options.commit ? { commit: options.commit } : {}),
+        startedAt,
+        finishedAt: options.finishedAt ?? startedAt,
+        data: options.data,
+        diagnostics: options.diagnostics ?? [],
+        evidenceRefs: options.evidenceRefs ?? [],
+        exitCode: options.exitCode ?? (options.status === "fail" ? 1 : 0),
+    };
+}
+export function commandDiagnostic(severity, code, message, options = {}) {
+    return {
+        severity,
+        code,
+        message,
+        redacted: options.redacted ?? true,
+        ...(options.remediation ? { remediation: options.remediation } : {}),
+        ...(options.path ? { path: options.path } : {}),
+    };
+}
+export function createCommandRunId(prefix = "cmd") {
+    return `${prefix}-${randomUUID()}`;
+}

package/dist/util/events-logger.d.ts

@@ -1,5 +1,5 @@
 export type ReplayEventType = "replay-start" | "replay-end" | "node-start" | "node-complete" | "node-fallback" | "state-change";
-export type TelemetryEventType = ReplayEventType | "lane.started" | "lane.activity" | "lane.heartbeat" | "lane.completed" | "lane.failed" | "lane.stalled" | "agent.spawned" | "tool.started" | "tool.completed" | "mcp.started" | "mcp.completed" | "mcp.failed" | "hook.started" | "hook.completed" | "provider.route" | "provider.fallback" | "provider.request.started" | "provider.request.completed" | "provider.request.failed" | "provider.advisory.started" | "provider.advisory.completed" | "provider.advisory.failed" | "evidence.result";
+export type TelemetryEventType = ReplayEventType | "lane.started" | "lane.activity" | "lane.heartbeat" | "lane.completed" | "lane.failed" | "lane.stalled" | "agent.spawned" | "tool.started" | "tool.completed" | "mcp.started" | "mcp.completed" | "mcp.failed" | "hook.started" | "hook.completed" | "provider.route" | "provider.fallback" | "provider.request.started" | "provider.request.completed" | "provider.request.failed" | "provider.advisory.started" | "provider.advisory.completed" | "provider.advisory.failed" | "evidence.result" | "run.started" | "run.completed" | "dag.node.started" | "dag.node.completed" | "provider.selected" | "tool.allowed" | "tool.denied" | "evidence.attached" | "verifier.verdict";
 export interface TelemetryEvent {
     schemaVersion: "telemetry.v1";
     type: TelemetryEventType;

package/dist/util/events-logger.js

@@ -98,32 +98,39 @@ export async function appendEvent(runDir, event) {
     const write = previous.then(async () => {
         const seq = await nextSeq(runDir, event.seq);
         const line = JSON.stringify(sanitizeTelemetryEvent({ ...event, timestamp: event.timestamp ?? new Date().toISOString() }, seq)) + "\n";
+        await appendFile(join(runDir, "events.ndjson"), line, "utf-8");
         await appendFile(join(runDir, "events.jsonl"), line, "utf-8");
     });
     appendQueueByRunDir.set(runDir, write.catch(() => { }));
     await write;
 }
 export async function readEvents(runDir) {
+    let content;
     try {
-        const content = await readFile(join(runDir, "events.jsonl"), "utf-8");
-        const events = [];
-        for (const line of content.split("\n")) {
-            if (!line.trim())
-                continue;
-            try {
-                const parsed = JSON.parse(line);
-                const seq = typeof parsed.seq === "number" && Number.isFinite(parsed.seq) ? parsed.seq : events.length + 1;
-                events.push(sanitizeTelemetryEvent(parsed, seq));
-            }
-            catch {
-                // Keep append-only logs readable even if one line is corrupt.
-            }
-        }
-        return events;
+        content = await readFile(join(runDir, "events.ndjson"), "utf-8");
     }
     catch {
-        return [];
+        try {
+            content = await readFile(join(runDir, "events.jsonl"), "utf-8");
+        }
+        catch {
+            return [];
+        }
+    }
+    const events = [];
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            const seq = typeof parsed.seq === "number" && Number.isFinite(parsed.seq) ? parsed.seq : events.length + 1;
+            events.push(sanitizeTelemetryEvent(parsed, seq));
+        }
+        catch {
+            // Keep append-only logs readable even if one line is corrupt.
+        }
     }
+    return events;
 }
 export async function tailEvents(runDir, options = {}) {
     const afterSeq = options.afterSeq ?? 0;

package/dist/util/fs/mcp-diagnose.js

@@ -12,6 +12,7 @@ export async function collectMcpConfigs(scope = "project") {
     const home = getUserHome();
     const projectOmkMcp = join(root, ".omk", "mcp.json");
     const projectKimiMcp = join(root, ".kimi", "mcp.json");
+    const globalAgentMcp = join(home, ".omk", "agent", "mcp.json");
     const globalOmkMcp = join(home, ".omk", "mcp.json");
     const globalKimiMcp = join(home, ".kimi", "mcp.json");
     // Precedence is left-to-right with later files winning during runtime merge:
@@ -19,7 +20,7 @@ export async function collectMcpConfigs(scope = "project") {
     // compatibility surface; `.omk/mcp.json` is used only as a project fallback
     // when the `.kimi` companion does not exist.
     if (scope === "all") {
-        for (const candidate of [globalOmkMcp, globalKimiMcp]) {
+        for (const candidate of [globalAgentMcp, globalOmkMcp, globalKimiMcp]) {
             if (await pathExists(candidate))
                 configs.push(candidate);
         }

package/dist/util/fs/mcp-runtime-config.js

@@ -140,11 +140,23 @@ function normalizeRuntimeMcpServer(name, server) {
             }],
     };
 }
+function normalizeRuntimeMcpEnv(env) {
+    if (Array.isArray(env)) {
+        return Object.fromEntries(env
+            .filter((key) => typeof key === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            .map((key) => [key, `\${${key}}`]));
+    }
+    return isRecord(env) ? env : {};
+}
 function prepareRuntimeMcpServer(server) {
-    if (!isRecord(server) || typeof server.url === "string" || !isPackageManagerRuntimeServer(server)) {
+    if (!isRecord(server) || typeof server.url === "string") {
         return server;
     }
-    const existingEnv = isRecord(server.env) ? server.env : {};
+    const existingEnv = normalizeRuntimeMcpEnv(server.env);
+    const hasEnvArray = Array.isArray(server.env);
+    if (!isPackageManagerRuntimeServer(server)) {
+        return hasEnvArray ? { ...server, env: existingEnv } : server;
+    }
     const env = { ...QUIET_PACKAGE_MANAGER_ENV, ...existingEnv };
     return { ...server, env };
 }

package/dist/util/i18n.js

@@ -77,7 +77,7 @@ const en = {
     "cli.menuExit": "exit     — Exit",
     "cli.menuUnavailable": "\n  (Cannot display menu in this environment. Type a command below.)\n",
     "cli.unknownChoice": "Unknown choice: {0}, proceeding to chat.",
-    "cli.description": "open-multi-agent-kit: multi-agent control plane for AI coding teams",
+    "cli.description": "omk: multi-agent control plane for AI coding teams",
     "cli.runIdOption": "run ID (resume / reference)",
     "cli.sudoOption": "Run shell commands with sudo (admin privileges)",
     // Command descriptions (cli.ts)
@@ -485,7 +485,7 @@ const ko = {
     "cli.menuExit": "exit     — 종료",
     "cli.menuUnavailable": "\n  (메뉴를 표시할 수 없는 환경입니다. 아래 명령어를 직접 입력하세요.)\n",
     "cli.unknownChoice": "알 수 없는 선택: {0}, chat으로 진행합니다.",
-    "cli.description": "open-multi-agent-kit: AI 코딩 팀용 멀티 에이전트 컨트롤 플레인",
+    "cli.description": "omk: AI 코딩 팀용 멀티 에이전트 컨트롤 플레인",
     "cli.runIdOption": "run ID 지정 (resume / 참조)",
     "cli.sudoOption": "셸 명령어를 sudo로 실행 (관리자 권한)",
     // Command descriptions

package/dist/util/screenshot-store.d.ts

@@ -12,6 +12,13 @@ export interface PasteScreenshotOptions {
     timeoutMs?: number;
     procVersion?: string;
 }
+export interface ScreenshotCaptureCapability {
+    readonly name: string;
+    readonly supported: boolean;
+    readonly mode: "image" | "text" | "raw-key";
+    readonly note: string;
+}
+export declare function listScreenshotCaptureCapabilities(options?: PasteScreenshotOptions): ScreenshotCaptureCapability[];
 export declare function validateMagicBytes(buf: Buffer): {
     ok: boolean;
     ext: string;

package/dist/util/screenshot-store.js

@@ -14,6 +14,36 @@ export const SCREENSHOT_DIR = ".omk/screenshots";
 export const MAX_SIZE_BYTES = 20 * 1024 * 1024;
 const CLIPBOARD_TIMEOUT_MS = 5000;
 const CLIPBOARD_MAX_BUFFER_BYTES = MAX_SIZE_BYTES * 2;
+export function listScreenshotCaptureCapabilities(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const wsl = platform === "linux" && isWslEnvironment(options.env, options.procVersion);
+    return [
+        {
+            name: "windows-clipboard-image",
+            supported: platform === "win32" || wsl,
+            mode: "image",
+            note: "PowerShell STA bridge reads Snipping Tool / Ctrl+V image clipboard data.",
+        },
+        {
+            name: "macos-clipboard-image",
+            supported: platform === "darwin",
+            mode: "image",
+            note: "pngpaste or osascript reads image clipboard data.",
+        },
+        {
+            name: "linux-clipboard-image",
+            supported: platform === "linux",
+            mode: "image",
+            note: "wl-paste/xclip reads image clipboard data; WSL tries Windows first.",
+        },
+        {
+            name: "terminal-kit-ctrl-v-text",
+            supported: true,
+            mode: "raw-key",
+            note: "terminal-kit can capture Ctrl+V-style raw key/text clipboard hooks, not image screenshots.",
+        },
+    ];
+}
 const IMAGE_MAGIC = new Map([
     ["png", [0x89, 0x50, 0x4e, 0x47]],
     ["jpg", [0xff, 0xd8, 0xff]],

package/dist/util/terminal-kit-bridge.d.ts

@@ -0,0 +1,24 @@
+export interface TerminalKitBridgeCapabilities {
+    readonly available: boolean;
+    readonly rawInput: boolean;
+    readonly ctrlVPasteKey: boolean;
+    readonly textClipboard: boolean;
+    readonly imageClipboard: false;
+    readonly windowsImageCapture: false;
+    readonly reason?: string;
+}
+export declare function getTerminalKitBridgeCapabilities(): TerminalKitBridgeCapabilities;
+export declare function isTerminalKitPasteKey(key: string | undefined): boolean;
+export declare function readTerminalKitClipboardText(source?: string): Promise<{
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare function writeTerminalKitClipboardText(text: string, source?: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/util/terminal-kit-bridge.js

@@ -0,0 +1,60 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+function loadTerminalKit() {
+    try {
+        return require("terminal-kit");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function getTerminalKitBridgeCapabilities() {
+    const terminal = loadTerminalKit()?.terminal;
+    if (!terminal) {
+        return {
+            available: false,
+            rawInput: false,
+            ctrlVPasteKey: false,
+            textClipboard: false,
+            imageClipboard: false,
+            windowsImageCapture: false,
+            reason: "terminal-kit is not available",
+        };
+    }
+    return {
+        available: true,
+        rawInput: typeof terminal.grabInput === "function" && typeof terminal.on === "function",
+        ctrlVPasteKey: typeof terminal.grabInput === "function" && typeof terminal.on === "function",
+        textClipboard: typeof terminal.getClipboard === "function" && typeof terminal.setClipboard === "function",
+        imageClipboard: false,
+        windowsImageCapture: false,
+        reason: "terminal-kit supports raw key and text clipboard bridges; image/window capture remains OMK platform-specific",
+    };
+}
+export function isTerminalKitPasteKey(key) {
+    return key === "CTRL_V" || key === "META_P" || key === "CTRL_P";
+}
+export async function readTerminalKitClipboardText(source = "c") {
+    const terminal = loadTerminalKit()?.terminal;
+    if (!terminal?.getClipboard)
+        return { ok: false, error: "terminal-kit clipboard is unavailable" };
+    try {
+        const text = await terminal.getClipboard(source);
+        return { ok: true, text };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+export async function writeTerminalKitClipboardText(text, source = "c") {
+    const terminal = loadTerminalKit()?.terminal;
+    if (!terminal?.setClipboard)
+        return { ok: false, error: "terminal-kit clipboard is unavailable" };
+    try {
+        await terminal.setClipboard(text, source);
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/dist/util/terminal-owner.d.ts

@@ -15,5 +15,6 @@ export declare class TerminalOwner {
     get state(): TerminalOwnerState;
     claimReadline(): () => void;
     withChildProcess<T>(readline: ReadlineOwnerLike | undefined, fn: () => Promise<T>): Promise<T>;
+    withRawSelector<T>(readline: ReadlineOwnerLike | undefined, fn: () => Promise<T>): Promise<T>;
     private assertCanOwn;
 }

package/dist/util/terminal-owner.js

@@ -56,6 +56,37 @@ export class TerminalOwner {
             this.active = previous;
         }
     }
+    async withRawSelector(readline, fn) {
+        if (this.active !== "idle" && this.active !== "readline") {
+            throw new Error(`Terminal already owned by ${this.active}; cannot start raw selector`);
+        }
+        const previous = this.active;
+        this.active = "raw-selector";
+        try {
+            try {
+                readline?.pause();
+            }
+            catch {
+                // Piped input can close readline before queued work finishes.
+            }
+            try {
+                this.input.resume();
+            }
+            catch {
+                // Non-standard test streams may already be closed.
+            }
+            return await fn();
+        }
+        finally {
+            try {
+                readline?.resume();
+            }
+            catch {
+                // Readline may already be closed; ownership must still reset.
+            }
+            this.active = previous;
+        }
+    }
     assertCanOwn(next) {
         if (this.active !== "idle") {
             throw new Error(`Terminal already owned by ${this.active}; cannot start ${next}`);

package/dist/version.d.ts

@@ -1,11 +1,13 @@
 export declare const OMK_PACKAGE_NAME = "open-multi-agent-kit";
 export declare const OMK_RUNTIME_VERSION = "v1.2";
 export declare const OMK_CONTRACT_VERSION = "omk.contract.v1";
+export declare const OMK_COMMAND_SCHEMA_VERSION = "omk.command.v1";
 export declare const OMK_EVIDENCE_SCHEMA_VERSION = "omk.evidence.v1";
+export declare const OMK_EVIDENCE_BUNDLE_SCHEMA_VERSION = "omk.evidence-bundle.v1";
 export declare const OMK_DECISION_SCHEMA_VERSION = "omk.decision.v1";
 export declare const OMK_RUN_MANIFEST_SCHEMA_VERSION = "omk.run-manifest.v1";
 export declare const OMK_PROVIDER_SCHEMA_VERSION = "omk.provider.v1";
 export declare const OMK_VERSION_SCHEMA_VERSION = "omk.version.v1";
 export declare const OMK_PROOF_BUNDLE_SCHEMA_VERSION = "omk.proof-bundle.v1";
 export declare const OMK_RELEASE_CHANNEL = "pre-1.0";
-export declare const OMK_SCHEMA_VERSIONS: readonly ["omk.evidence.v1", "omk.decision.v1", "omk.run-manifest.v1", "omk.provider.v1", "omk.version.v1", "omk.proof-bundle.v1"];
+export declare const OMK_SCHEMA_VERSIONS: readonly ["omk.command.v1", "omk.evidence.v1", "omk.evidence-bundle.v1", "omk.decision.v1", "omk.run-manifest.v1", "omk.provider.v1", "omk.version.v1", "omk.proof-bundle.v1"];

package/dist/version.js

@@ -1,7 +1,9 @@
 export const OMK_PACKAGE_NAME = "open-multi-agent-kit";
 export const OMK_RUNTIME_VERSION = "v1.2";
 export const OMK_CONTRACT_VERSION = "omk.contract.v1";
+export const OMK_COMMAND_SCHEMA_VERSION = "omk.command.v1";
 export const OMK_EVIDENCE_SCHEMA_VERSION = "omk.evidence.v1";
+export const OMK_EVIDENCE_BUNDLE_SCHEMA_VERSION = "omk.evidence-bundle.v1";
 export const OMK_DECISION_SCHEMA_VERSION = "omk.decision.v1";
 export const OMK_RUN_MANIFEST_SCHEMA_VERSION = "omk.run-manifest.v1";
 export const OMK_PROVIDER_SCHEMA_VERSION = "omk.provider.v1";
@@ -9,7 +11,9 @@ export const OMK_VERSION_SCHEMA_VERSION = "omk.version.v1";
 export const OMK_PROOF_BUNDLE_SCHEMA_VERSION = "omk.proof-bundle.v1";
 export const OMK_RELEASE_CHANNEL = "pre-1.0";
 export const OMK_SCHEMA_VERSIONS = [
+    OMK_COMMAND_SCHEMA_VERSION,
     OMK_EVIDENCE_SCHEMA_VERSION,
+    OMK_EVIDENCE_BUNDLE_SCHEMA_VERSION,
     OMK_DECISION_SCHEMA_VERSION,
     OMK_RUN_MANIFEST_SCHEMA_VERSION,
     OMK_PROVIDER_SCHEMA_VERSION,

package/docs/2026-05-18-project-direction.md

@@ -2,7 +2,7 @@
 
 ## Summary
 
-open-multi-agent-kit(OMK)의 현재 방향성은 **provider-neutral verified agent runtime**이다. Kimi는 하나의 강한 adapter/provider lane일 뿐이며, OMK는 그 주변의 실행 제어면을 담당한다: DAG 실행, evidence gate, 로컬 그래프 메모리, MCP/skills/hooks 라우팅, provider fallback, run replay/inspect, HUD/cockpit 가시성, worktree 격리.
+open-multi-agent-kit(OMK)의 현재 방향성은 **Kimi-native verified agent runtime**이다. Kimi가 작성·병합·최종 판단 권한을 유지하고, OMK는 그 주변의 실행 제어면을 담당한다: DAG 실행, evidence gate, 로컬 그래프 메모리, MCP/skills/hooks 라우팅, provider fallback, run replay/inspect, HUD/cockpit 가시성, worktree 격리.
 
 핵심 문장: