open-multi-agent-kit 0.78.0

package/dist/util/events-logger.js

@@ -0,0 +1,135 @@
+import { appendFile, readFile } from "fs/promises";
+import { join } from "path";
+import { redactSecrets } from "../orchestration/state-persister.js";
+const MAX_STRING_LENGTH = 500;
+const MAX_ARRAY_ITEMS = 20;
+const MAX_OBJECT_KEYS = 40;
+const MAX_DEPTH = 4;
+const seqByRunDir = new Map();
+const appendQueueByRunDir = new Map();
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function shouldRedactPayloadKey(key) {
+    const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+    return normalized === "env" ||
+        normalized === "headers" ||
+        normalized === "header" ||
+        normalized === "args" ||
+        normalized === "arguments" ||
+        normalized === "toolargs" ||
+        normalized === "rawargs" ||
+        normalized === "stdout" ||
+        normalized === "stderr" ||
+        normalized === "rawstdout" ||
+        normalized === "rawstderr";
+}
+function boundString(value) {
+    return value.length > MAX_STRING_LENGTH
+        ? `${value.slice(0, MAX_STRING_LENGTH)}…[truncated ${value.length - MAX_STRING_LENGTH} chars]`
+        : value;
+}
+function sanitizeTelemetryValue(value, depth = 0, key) {
+    if (key && shouldRedactPayloadKey(key))
+        return "[redacted]";
+    const redacted = redactSecrets(value);
+    if (typeof redacted === "string")
+        return boundString(redacted);
+    if (typeof redacted !== "object" || redacted === null)
+        return redacted;
+    if (depth >= MAX_DEPTH)
+        return "[truncated-depth]";
+    if (Array.isArray(redacted)) {
+        const out = redacted
+            .slice(0, MAX_ARRAY_ITEMS)
+            .map((item) => sanitizeTelemetryValue(item, depth + 1));
+        if (redacted.length > MAX_ARRAY_ITEMS) {
+            out.push(`[truncated ${redacted.length - MAX_ARRAY_ITEMS} items]`);
+        }
+        return out;
+    }
+    const out = {};
+    const entries = Object.entries(redacted);
+    for (const [entryKey, entryValue] of entries.slice(0, MAX_OBJECT_KEYS)) {
+        out[entryKey] = sanitizeTelemetryValue(entryValue, depth + 1, entryKey);
+    }
+    if (entries.length > MAX_OBJECT_KEYS) {
+        out.truncatedKeys = entries.length - MAX_OBJECT_KEYS;
+    }
+    return out;
+}
+function sanitizeTelemetryEvent(event, seq) {
+    const sanitized = sanitizeTelemetryValue(event);
+    const record = isRecord(sanitized) ? sanitized : {};
+    return {
+        schemaVersion: "telemetry.v1",
+        type: String(record.type ?? event.type),
+        timestamp: typeof record.timestamp === "string" ? record.timestamp : new Date().toISOString(),
+        seq,
+        runId: String(record.runId ?? event.runId),
+        nodeId: typeof record.nodeId === "string" ? record.nodeId : undefined,
+        laneId: typeof record.laneId === "string" ? record.laneId : undefined,
+        agentId: typeof record.agentId === "string" ? record.agentId : undefined,
+        toolName: typeof record.toolName === "string" ? record.toolName : undefined,
+        provider: typeof record.provider === "string" ? record.provider : undefined,
+        status: typeof record.status === "string" ? record.status : undefined,
+        data: isRecord(record.data) ? record.data : undefined,
+    };
+}
+async function nextSeq(runDir, explicitSeq) {
+    if (typeof explicitSeq === "number" && Number.isFinite(explicitSeq) && explicitSeq > 0) {
+        seqByRunDir.set(runDir, explicitSeq);
+        return explicitSeq;
+    }
+    const current = seqByRunDir.get(runDir);
+    if (current != null) {
+        const next = current + 1;
+        seqByRunDir.set(runDir, next);
+        return next;
+    }
+    const events = await readEvents(runDir);
+    const maxSeq = events.reduce((max, event) => Math.max(max, event.seq || 0), 0);
+    const next = maxSeq + 1;
+    seqByRunDir.set(runDir, next);
+    return next;
+}
+export async function appendEvent(runDir, event) {
+    const previous = appendQueueByRunDir.get(runDir) ?? Promise.resolve();
+    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.jsonl"), line, "utf-8");
+    });
+    appendQueueByRunDir.set(runDir, write.catch(() => { }));
+    await write;
+}
+export async function readEvents(runDir) {
+    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;
+    }
+    catch {
+        return [];
+    }
+}
+export async function tailEvents(runDir, options = {}) {
+    const afterSeq = options.afterSeq ?? 0;
+    const filtered = (await readEvents(runDir)).filter((event) => event.seq > afterSeq);
+    if (options.limit != null && options.limit >= 0) {
+        return filtered.slice(-options.limit);
+    }
+    return filtered;
+}

package/dist/util/execution-selection.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionPromptPolicy, ExecutionSelectionDecision, ExecutionStrategy, UserIntent } from "../contracts/orchestration.js";
+export declare const EXECUTION_PROMPT_POLICIES: readonly ExecutionPromptPolicy[];
+export declare const EXECUTION_PROMPT_CHOICES: readonly ExecutionStrategy[];
+export declare function normalizeExecutionPromptPolicy(value: string | undefined): ExecutionPromptPolicy | undefined;
+export declare function parseExecutionPromptPolicy(value: string | undefined, sourceLabel?: string): ExecutionPromptPolicy | undefined;
+export declare function isNonTrivialIntent(intent: UserIntent): boolean;
+export declare function resolveExecutionSelectionDecision(input: {
+    cliValue?: string;
+    configValue?: string | ExecutionPromptPolicy;
+    intent: UserIntent;
+    isTTY: boolean;
+}): ExecutionSelectionDecision;
+export declare function resolvePromptExecutionDecision(base: ExecutionSelectionDecision, strategy: Exclude<ExecutionStrategy, "prompt">): ExecutionSelectionDecision;

package/dist/util/execution-selection.js

@@ -0,0 +1,82 @@
+import { UsageError } from "./cli-contract.js";
+export const EXECUTION_PROMPT_POLICIES = [
+    "ask",
+    "auto",
+    "parallel",
+    "sequential",
+];
+export const EXECUTION_PROMPT_CHOICES = [
+    "parallel",
+    "sequential",
+    "plan-only",
+];
+export function normalizeExecutionPromptPolicy(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === "one-by-one" || normalized === "one_by_one" || normalized === "serial")
+        return "sequential";
+    if (normalized === "agents" || normalized === "subagents")
+        return "parallel";
+    if (EXECUTION_PROMPT_POLICIES.includes(normalized)) {
+        return normalized;
+    }
+    return undefined;
+}
+export function parseExecutionPromptPolicy(value, sourceLabel = "--execution") {
+    if (value === undefined || value.trim() === "")
+        return undefined;
+    const policy = normalizeExecutionPromptPolicy(value);
+    if (policy)
+        return policy;
+    throw new UsageError(`Invalid ${sourceLabel}: ${value}. Expected ask | auto | parallel | sequential.`);
+}
+export function isNonTrivialIntent(intent) {
+    return intent.complexity !== "simple" || intent.estimatedWorkers > 1 || intent.parallelizable === true;
+}
+export function resolveExecutionSelectionDecision(input) {
+    const cliPolicy = parseExecutionPromptPolicy(input.cliValue, "--execution");
+    const configPolicy = typeof input.configValue === "string"
+        ? parseExecutionPromptPolicy(input.configValue, "execution config")
+        : input.configValue;
+    const policy = cliPolicy ?? configPolicy ?? "ask";
+    const source = cliPolicy ? "cli" : configPolicy ? "config" : "default";
+    const isNonTrivial = isNonTrivialIntent(input.intent);
+    if (policy === "parallel") {
+        return makeDecision(policy, source, "parallel", "execution policy forces parallel agents", input.isTTY, isNonTrivial);
+    }
+    if (policy === "sequential") {
+        return makeDecision(policy, source, "sequential", "execution policy forces one-by-one execution", input.isTTY, isNonTrivial);
+    }
+    if (policy === "auto") {
+        const strategy = shouldAutoParallel(input.intent) ? "parallel" : "sequential";
+        return makeDecision(policy, source, strategy, strategy === "parallel"
+            ? "auto selected parallel agents for a non-trivial or parallelizable intent"
+            : "auto selected one-by-one execution for a simple intent", input.isTTY, isNonTrivial);
+    }
+    if (input.isTTY && isNonTrivial) {
+        return makeDecision(policy, source, "prompt", "TTY non-trivial intent must ask before execution", input.isTTY, isNonTrivial);
+    }
+    const strategy = isNonTrivial ? "parallel" : "sequential";
+    return makeDecision(policy, source, strategy, isNonTrivial
+        ? "non-TTY ask policy cannot prompt, so complex work defaults to parallel agents"
+        : "simple intent can run one by one without prompting", input.isTTY, isNonTrivial);
+}
+export function resolvePromptExecutionDecision(base, strategy) {
+    return {
+        ...base,
+        source: "prompt",
+        strategy,
+        reason: strategy === "parallel"
+            ? "user selected parallel agents"
+            : strategy === "sequential"
+                ? "user selected one-by-one execution"
+                : "user selected plan-only",
+    };
+}
+function shouldAutoParallel(intent) {
+    return intent.complexity === "complex" || intent.estimatedWorkers > 1 || intent.parallelizable === true;
+}
+function makeDecision(policy, source, strategy, reason, isTTY, isNonTrivial) {
+    return { policy, source, strategy, reason, isTTY, isNonTrivial };
+}

package/dist/util/first-run-star.d.ts

@@ -0,0 +1,49 @@
+export type StarPromptResult = "yes" | "no" | "seen" | "skipped" | "error";
+export interface StarPromptState {
+    promptedAt: string;
+    answer: "yes" | "no";
+    version: string;
+    repoUrl: string;
+    action: "github-star";
+    starred?: boolean;
+    starError?: string;
+}
+export interface StarPromptOptions {
+    version: string;
+    repoUrl?: string;
+    homeDir?: string;
+    env?: NodeJS.ProcessEnv;
+    argv?: string[];
+    stdin?: {
+        isTTY?: boolean;
+    };
+    stdout?: {
+        isTTY?: boolean;
+    };
+    commandName?: string;
+    prompt?: (repoUrl: string) => Promise<boolean>;
+    starRepo?: (repoUrl: string) => Promise<void> | void;
+    now?: () => Date;
+}
+export declare function getStarPromptStatePath(homeDir?: string): string;
+export declare function isStarPromptEligible(options?: Omit<StarPromptOptions, "version" | "prompt" | "openUrl" | "now"> & {
+    allowChat?: boolean;
+}): boolean;
+export declare function readStarPromptState(homeDir?: string): Promise<StarPromptState | null>;
+export declare function maybeAskForGitHubStar(options: StarPromptOptions & {
+    allowChat?: boolean;
+}): Promise<StarPromptResult>;
+export declare function maybeAskForGitHubStarAtChatStart(options: StarPromptOptions): Promise<StarPromptResult>;
+export interface StarPromptAfterCommandOptions extends StarPromptOptions {
+    commandName: string;
+}
+export declare function maybeAskForGitHubStarAfterCommand(options: StarPromptAfterCommandOptions): Promise<StarPromptResult>;
+export interface StarPromptSummary {
+    answered: boolean;
+    starred?: boolean;
+    starError?: string;
+}
+export declare function getStarPromptSummary(homeDir?: string): Promise<StarPromptSummary | null>;
+export declare function parseGitHubRepoSlug(repoUrl: string): string | null;
+export declare function checkGhAuth(): Promise<void>;
+export declare function starGitHubRepo(repoUrl: string): Promise<void>;

package/dist/util/first-run-star.js

@@ -0,0 +1,223 @@
+import { execFile } from "child_process";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { promisify } from "util";
+import { select } from "@inquirer/prompts";
+import { ExitPromptError } from "@inquirer/core";
+import { OMK_REPO_URL } from "./version.js";
+import { t } from "./i18n.js";
+import { style } from "./theme.js";
+const execFileAsync = promisify(execFile);
+export function getStarPromptStatePath(homeDir = homedir()) {
+    return join(homeDir, ".omk", "star-prompt.json");
+}
+export function isStarPromptEligible(options = {}) {
+    const env = options.env ?? process.env;
+    const argv = options.argv ?? process.argv;
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    const setting = env.OMK_STAR_PROMPT?.trim().toLowerCase();
+    if (["0", "false", "off", "no", "never"].includes(setting ?? ""))
+        return false;
+    if (env.CI || env.GITHUB_ACTIONS)
+        return false;
+    if (!stdin.isTTY || !stdout.isTTY)
+        return false;
+    if (!options.allowChat && (options.commandName === "chat" || options.commandName === "omk"))
+        return false;
+    if (options.commandName === "lsp")
+        return false;
+    if (argv.some((arg) => ["--help", "-h", "--version", "-V", "--json"].includes(arg)))
+        return false;
+    return true;
+}
+export async function readStarPromptState(homeDir) {
+    try {
+        const raw = await readFile(getStarPromptStatePath(homeDir), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.answer === "yes" || parsed.answer === "no") {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function maybeAskForGitHubStar(options) {
+    const env = options.env ?? process.env;
+    const force = env.OMK_STAR_PROMPT?.trim().toLowerCase() === "force";
+    const repoUrl = options.repoUrl ?? OMK_REPO_URL;
+    if (!isStarPromptEligible({ ...options, allowChat: options.allowChat }))
+        return "skipped";
+    if (!force && await readStarPromptState(options.homeDir))
+        return "seen";
+    try {
+        const accepted = options.prompt
+            ? await options.prompt(repoUrl)
+            : await promptForGitHubStar(repoUrl);
+        const answer = accepted ? "yes" : "no";
+        let starred;
+        let starError;
+        if (accepted) {
+            try {
+                await (options.starRepo ?? starGitHubRepo)(repoUrl);
+                starred = true;
+            }
+            catch (error) {
+                starred = false;
+                starError = error instanceof Error ? error.message : String(error);
+                const slug = parseGitHubRepoSlug(repoUrl);
+                console.error(style.gray(`GitHub star failed: ${starError}`));
+                if (slug)
+                    console.error(style.gray(`Visit ${style.cream(`https://github.com/${slug}`)} to star manually.`));
+            }
+        }
+        await writeStarPromptState({
+            promptedAt: (options.now ?? (() => new Date()))().toISOString(),
+            answer,
+            version: options.version,
+            repoUrl,
+            action: "github-star",
+            starred,
+            starError,
+        }, options.homeDir);
+        return answer;
+    }
+    catch (err) {
+        if (err instanceof ExitPromptError)
+            return "skipped";
+        return "error";
+    }
+}
+const POST_COMMAND_WHITELIST = new Set(["doctor", "hud", "plan", "parallel", "run"]);
+export async function maybeAskForGitHubStarAtChatStart(options) {
+    if ((options.env ?? process.env).OMK_CHAT_COCKPIT_CHILD === "1")
+        return "skipped";
+    return maybeAskForGitHubStar({ ...options, allowChat: true });
+}
+export async function maybeAskForGitHubStarAfterCommand(options) {
+    const repoUrl = options.repoUrl ?? OMK_REPO_URL;
+    if (!POST_COMMAND_WHITELIST.has(options.commandName))
+        return "skipped";
+    if (!isStarPromptEligible(options))
+        return "skipped";
+    if (await readStarPromptState(options.homeDir))
+        return "seen";
+    try {
+        const accepted = options.prompt
+            ? await options.prompt(repoUrl)
+            : await promptForStarAfterCommand();
+        const answer = accepted ? "yes" : "no";
+        let starred;
+        let starError;
+        if (accepted) {
+            try {
+                await (options.starRepo ?? starGitHubRepo)(repoUrl);
+                starred = true;
+            }
+            catch (error) {
+                starred = false;
+                starError = error instanceof Error ? error.message : String(error);
+                const slug = parseGitHubRepoSlug(repoUrl);
+                console.error(style.gray(`GitHub star failed: ${starError}`));
+                if (slug)
+                    console.error(style.gray(`Visit ${style.cream(`https://github.com/${slug}`)} to star manually.`));
+            }
+        }
+        await writeStarPromptState({
+            promptedAt: (options.now ?? (() => new Date()))().toISOString(),
+            answer,
+            version: options.version,
+            repoUrl,
+            action: "github-star",
+            starred,
+            starError,
+        }, options.homeDir);
+        return answer;
+    }
+    catch (err) {
+        if (err instanceof ExitPromptError)
+            return "skipped";
+        return "error";
+    }
+}
+export async function getStarPromptSummary(homeDir) {
+    const state = await readStarPromptState(homeDir);
+    if (!state)
+        return null;
+    return {
+        answered: true,
+        starred: state.starred,
+        starError: state.starError,
+    };
+}
+async function promptForGitHubStar(repoUrl) {
+    try {
+        const answer = await select({
+            message: t("star.prompt", repoUrl),
+            choices: [
+                { name: t("star.yes"), value: "yes" },
+                { name: t("star.no"), value: "no" },
+            ],
+            default: "no",
+        });
+        return answer === "yes";
+    }
+    catch (err) {
+        if (err instanceof ExitPromptError)
+            return false;
+        throw err;
+    }
+}
+async function promptForStarAfterCommand() {
+    try {
+        const answer = await select({
+            message: t("star.promptShort"),
+            choices: [
+                { name: t("star.yesStarIt"), value: "yes" },
+                { name: t("star.no"), value: "no" },
+            ],
+            default: "no",
+        });
+        return answer === "yes";
+    }
+    catch (err) {
+        if (err instanceof ExitPromptError)
+            return false;
+        throw err;
+    }
+}
+async function writeStarPromptState(state, homeDir) {
+    const statePath = getStarPromptStatePath(homeDir);
+    await mkdir(dirname(statePath), { recursive: true });
+    await writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+}
+export function parseGitHubRepoSlug(repoUrl) {
+    const normalized = repoUrl.trim().replace(/\.git$/i, "");
+    const match = normalized.match(/github\.com[:/]([^/\s]+)\/([^/\s#?]+)/i);
+    if (!match)
+        return null;
+    return `${match[1]}/${match[2]}`;
+}
+export async function checkGhAuth() {
+    try {
+        await execFileAsync("gh", ["auth", "status"], {
+            timeout: 10_000,
+        });
+    }
+    catch {
+        throw new Error("GitHub CLI not authenticated. Run `gh auth login` first.");
+    }
+}
+export async function starGitHubRepo(repoUrl) {
+    const slug = parseGitHubRepoSlug(repoUrl);
+    if (!slug) {
+        throw new Error(`Unsupported GitHub repo URL: ${repoUrl}`);
+    }
+    await checkGhAuth();
+    await execFileAsync("gh", ["api", "--silent", "--method", "PUT", `/user/starred/${slug}`], {
+        timeout: 10_000,
+    });
+}

package/dist/util/fs.d.ts

@@ -0,0 +1,128 @@
+import { SyncManifestEntry } from "./sync-manifest.js";
+import { type OmkRuntimeScope } from "./resource-profile.js";
+import { getProjectRootDiagnostics, resolveProjectRoot, resolveProjectRootAsync, displayProjectRootPath, type ProjectRootResolution, type ProjectRootSource } from "./project-root.js";
+export { getProjectRootDiagnostics, resolveProjectRoot, resolveProjectRootAsync, displayProjectRootPath, type ProjectRootResolution, type ProjectRootSource, };
+type KimiGlobalSyncStepName = "hooks" | "mcp" | "skills" | "memory";
+export interface KimiGlobalSyncOptions {
+    dryRun?: boolean;
+    diff?: boolean;
+    quiet?: boolean;
+    manifest?: SyncManifestEntry[];
+    timestamp?: string;
+}
+export interface KimiGlobalSyncStepReport {
+    name: KimiGlobalSyncStepName;
+    changed: boolean;
+    blocked: boolean;
+    skipped: boolean;
+    error?: string;
+    manifest: SyncManifestEntry[];
+}
+export interface KimiGlobalSyncReport {
+    changed: boolean;
+    blocked: boolean;
+    steps: KimiGlobalSyncStepReport[];
+    actions: string[];
+    skipped: string[];
+    errors: string[];
+    manifest: SyncManifestEntry[];
+}
+export declare function ensureDir(path: string): Promise<void>;
+export declare function writeFileSafe(path: string, content: string): Promise<void>;
+export declare function pathExists(path: string): Promise<boolean>;
+export interface RuntimeMcpPruneDiagnostic {
+    name: string;
+    kind: string;
+    message: string;
+}
+export interface RuntimeMcpNormalization {
+    name: string;
+    kind: string;
+    message: string;
+}
+export declare function getManifestPath(): string;
+export declare function getBackupDir(timestamp: string): string;
+export declare function readManifest(): Promise<SyncManifestEntry[]>;
+export declare function writeManifest(entries: SyncManifestEntry[]): Promise<void>;
+export declare function backupFile(sourcePath: string, backupDir: string, relativePath: string): Promise<string>;
+export declare function isDirectory(path: string): Promise<boolean>;
+export declare function readTextFile(path: string, defaultValue?: string): Promise<string>;
+export declare function getProjectRoot(): string;
+export declare function getProjectRootAsync(): Promise<string>;
+export declare function getUserHome(env?: NodeJS.ProcessEnv): string;
+export declare function normalizeUserHomePath(value: string | undefined): string | undefined;
+export declare function getOmkPath(subPath?: string): string;
+export { validateRunId, sanitizeRunId, validateRunArtifactPath, getRunsDir, getRunPath, getRunArtifactPath, listValidRunIds, } from "./run-store.js";
+export declare function getKimiConfigPath(): string;
+/**
+ * .omk/kimi.config.toml 의 hooks 를 ~/.kimi/config.toml 에 병합.
+ * 상대 경로를 절대 경로로 변환하여 어디서 실행돼도 작동하도록 함.
+ */
+export declare function mergeKimiHooks(omkConfigPath: string, options?: KimiGlobalSyncOptions): Promise<boolean>;
+export declare function extractHooksBlocks(content: string): string;
+/** 프로젝트의 .omk/mcp.json + .kimi/mcp.json → ~/.kimi/mcp.json 병합 */
+export declare function syncKimiMcpGlobal(options?: KimiGlobalSyncOptions): Promise<boolean>;
+/** 프로젝트의 .kimi/skills/* → ~/.kimi/skills/ 심링크 */
+export declare function syncKimiSkillsGlobal(options?: KimiGlobalSyncOptions): Promise<boolean>;
+/** local graph memory policy를 ~/.kimi/omk.memory.toml 에 동기화 */
+export declare function syncKimiMemoryGlobal(options?: KimiGlobalSyncOptions): Promise<boolean>;
+/** Sync hooks + MCP + skills to ~/.kimi/ at once */
+export declare function syncAllKimiGlobals(options?: KimiGlobalSyncOptions): Promise<KimiGlobalSyncReport>;
+/** Canonical OMK MCP config collection with project `.kimi/mcp.json` compatibility. */
+export declare function collectMcpConfigs(scope?: OmkRuntimeScope): Promise<string[]>;
+export declare const STALE_PACKAGE_NAMES: Record<string, string>;
+export declare function diagnoseRuntimeMcpServer(name: string, server: unknown): Promise<RuntimeMcpPruneDiagnostic[]>;
+export type RuntimeMcpPreflightMode = "warn-skip" | "strict" | "off";
+export type RuntimeMcpPreflightFailureReason = "timeout" | "exit";
+export type RuntimeMcpPreflightEntryStatus = "ok" | "failed" | "skipped";
+export interface RuntimeMcpPreflightOptions {
+    timeoutMs: number;
+    concurrency: number;
+}
+export interface RuntimeMcpPreflightEntry {
+    name: string;
+    status: RuntimeMcpPreflightEntryStatus;
+    reason?: RuntimeMcpPreflightFailureReason | "not-npm-family" | "no-package-spec";
+    detail?: string;
+    packageSpec?: string;
+}
+export interface RuntimeMcpPreflightResult {
+    failed: Set<string>;
+    details: Map<string, {
+        reason: RuntimeMcpPreflightFailureReason;
+        detail: string;
+    }>;
+    entries: RuntimeMcpPreflightEntry[];
+}
+export declare function resolveRuntimeMcpPreflightMode(env?: Record<string, string | undefined>): RuntimeMcpPreflightMode;
+export declare function resolveRuntimeMcpPreflightOptions(env?: Record<string, string | undefined>): RuntimeMcpPreflightOptions & {
+    mode: RuntimeMcpPreflightMode;
+};
+export declare function preflightRuntimeMcpServers(servers: Record<string, unknown>, options: RuntimeMcpPreflightOptions): Promise<RuntimeMcpPreflightResult>;
+export declare function pruneRuntimeMcpServers(servers: Record<string, unknown>): Promise<{
+    servers: Record<string, unknown>;
+    diagnostics: RuntimeMcpPruneDiagnostic[];
+    normalizations: RuntimeMcpNormalization[];
+}>;
+export declare function writeRuntimeMcpConfig(configPaths: string[], allowlist?: readonly string[]): Promise<string | null>;
+/** 프로젝트의 .kimi/skills 디렉토리 경로 */
+export declare function getKimiSkillsDir(): string;
+/** ~/.kimi/config.toml 에서 default_model 읽기 */
+export declare function getKimiDefaultModel(): Promise<string | null>;
+/** .omk/config.toml 에서 안전한 logo_image 경로 읽기 (상대경로는 프로젝트 루트 기준) */
+export declare function getOmkLogoImagePath(): Promise<string | null>;
+/**
+ * Auto-generate a built-in omk-project MCP config so users never need to
+ * define it manually in ~/.kimi/mcp.json or .kimi/mcp.json.
+ * The config uses the currently-running omk CLI path and sets OMK_PROJECT_ROOT
+ * to the current project root.
+ */
+export declare function writeBuiltinMcpConfig(): Promise<string | null>;
+/** Kimi CLI 실행 인자에 model + MCP + Skills 주입 (전역 동기화는 별도) */
+export declare function injectKimiGlobals(args: string[], options?: {
+    mcpScope?: OmkRuntimeScope;
+    skillsScope?: OmkRuntimeScope;
+    hooksScope?: OmkRuntimeScope;
+    role?: string;
+    mcpAllowlist?: readonly string[];
+}): Promise<void>;