open-multi-agent-kit 0.78.0

package/dist/orchestration/repair-policy.js

@@ -0,0 +1,221 @@
+/**
+ * RepairPolicyEngine — failure-aware repair strategy selection.
+ *
+ * Examines diagnosis results, failure history, and node context
+ * to decide the optimal repair action: retry, fallback, skip, or abort.
+ */
+import { createDecisionTraceStore } from "../evidence/decision-trace.js";
+const ESCALATE_THRESHOLD = 3;
+export function decideRepair(ctx) {
+    const { node, failureKind, totalAttempts, runId } = ctx;
+    let decision;
+    // 1. Hard abort — policy violation is never retryable
+    if (failureKind === "policy_violation") {
+        decision = {
+            action: "abort",
+            reason: `Policy violation on node ${node.id} — cannot retry`,
+        };
+    }
+    else if (totalAttempts >= ESCALATE_THRESHOLD) {
+        decision = escalateDecision(ctx);
+    }
+    else {
+        switch (failureKind) {
+            case "type_error":
+                decision = handleTypeError(ctx);
+                break;
+            case "test_failure":
+                decision = handleTestFailure(ctx);
+                break;
+            case "build_error":
+                decision = handleBuildError(ctx);
+                break;
+            case "lint_failure":
+                decision = handleLintFailure(ctx);
+                break;
+            case "missing_file":
+                decision = handleMissingFile(ctx);
+                break;
+            case "no_diff":
+            case "wrong_output":
+                decision = handleOutputFailure(ctx);
+                break;
+            default:
+                decision = handleAmbiguous(ctx);
+                break;
+        }
+    }
+    // Record repair-policy decision trace
+    if (runId) {
+        const attemptId = ctx.attempt.attemptId;
+        const traceStore = createDecisionTraceStore();
+        traceStore.record(runId, {
+            component: "repair-policy",
+            inputSummary: `node=${node.id} failureKind=${failureKind ?? "unknown"} totalAttempts=${totalAttempts}`,
+            outputDecision: `action=${decision.action}`,
+            reason: decision.reason,
+            scores: { totalAttempts, escalateThreshold: ESCALATE_THRESHOLD },
+            nodeId: node.id,
+            attemptId,
+        });
+    }
+    return decision;
+}
+function handleTypeError(ctx) {
+    const { node, diagnosis, availableProviders, previousProviders } = ctx;
+    const adjustment = diagnosis.suggestedContextAdjustment;
+    // First try: add error context
+    if (ctx.totalAttempts === 1) {
+        return {
+            action: "retry-with-context",
+            reason: `Type error on ${node.id} — retrying with error context`,
+            adjustment: adjustment ?? buildTypeErrorAdjustment(ctx.attempt),
+        };
+    }
+    // Second try: fallback provider
+    const fallback = selectFallbackProvider(availableProviders, previousProviders);
+    if (fallback) {
+        return {
+            action: "fallback-provider",
+            reason: `Type error persists on ${node.id} — trying ${fallback}`,
+            fallbackProvider: fallback,
+        };
+    }
+    // Last resort: skip if possible
+    return skipOrAbort(node, `Type error on ${node.id} after ${ctx.totalAttempts} attempts`);
+}
+function handleTestFailure(ctx) {
+    const { node, diagnosis, availableProviders, previousProviders } = ctx;
+    const adjustment = diagnosis.suggestedContextAdjustment;
+    if (ctx.totalAttempts === 1) {
+        return {
+            action: "retry-with-context",
+            reason: `Test failure on ${node.id} — retrying with test output`,
+            adjustment: adjustment ?? buildTestFailureAdjustment(ctx.attempt),
+        };
+    }
+    const fallback = selectFallbackProvider(availableProviders, previousProviders);
+    if (fallback) {
+        return {
+            action: "fallback-provider",
+            reason: `Test failure persists on ${node.id} — trying ${fallback}`,
+            fallbackProvider: fallback,
+        };
+    }
+    return skipOrAbort(node, `Test failure on ${node.id} after ${ctx.totalAttempts} attempts`);
+}
+function handleBuildError(ctx) {
+    const { node, diagnosis } = ctx;
+    if (ctx.totalAttempts === 1) {
+        return {
+            action: "retry-with-context",
+            reason: `Build error on ${node.id} — retrying with error output`,
+            adjustment: diagnosis.suggestedContextAdjustment ?? buildBuildErrorAdjustment(ctx.attempt),
+        };
+    }
+    return skipOrAbort(node, `Build error on ${node.id} after ${ctx.totalAttempts} attempts`);
+}
+function handleLintFailure(ctx) {
+    // Lint failures are usually simple — retry same with fix hints
+    if (ctx.totalAttempts <= 2) {
+        return {
+            action: "retry-same",
+            reason: `Lint failure on ${ctx.node.id} — retrying with lint output as context`,
+        };
+    }
+    return skipOrAbort(ctx.node, `Lint failure on ${ctx.node.id} after ${ctx.totalAttempts} attempts`);
+}
+function handleMissingFile(ctx) {
+    const { node, diagnosis } = ctx;
+    if (ctx.totalAttempts === 1) {
+        return {
+            action: "retry-with-context",
+            reason: `Missing file on ${node.id} — retrying with file requirement context`,
+            adjustment: diagnosis.suggestedContextAdjustment,
+        };
+    }
+    return skipOrAbort(node, `Missing file on ${node.id} after ${ctx.totalAttempts} attempts`);
+}
+function handleOutputFailure(ctx) {
+    const { node, availableProviders, previousProviders } = ctx;
+    if (ctx.totalAttempts === 1) {
+        return {
+            action: "retry-with-context",
+            reason: `Output failure on ${node.id} — retrying with expected output spec`,
+        };
+    }
+    const fallback = selectFallbackProvider(availableProviders, previousProviders);
+    if (fallback) {
+        return {
+            action: "fallback-provider",
+            reason: `Output failure persists on ${node.id} — trying ${fallback}`,
+            fallbackProvider: fallback,
+        };
+    }
+    return skipOrAbort(node, `Output failure on ${node.id} after ${ctx.totalAttempts} attempts`);
+}
+function handleAmbiguous(ctx) {
+    if (ctx.totalAttempts === 1) {
+        return {
+            action: "retry-same",
+            reason: `Ambiguous failure on ${ctx.node.id} — retrying same`,
+        };
+    }
+    return skipOrAbort(ctx.node, `Ambiguous failure on ${ctx.node.id} after ${ctx.totalAttempts} attempts`);
+}
+function escalateDecision(ctx) {
+    const { node, availableProviders, previousProviders } = ctx;
+    // Try fallback provider first
+    const fallback = selectFallbackProvider(availableProviders, previousProviders);
+    if (fallback) {
+        return {
+            action: "fallback-provider",
+            reason: `${ctx.totalAttempts} failures on ${node.id} — escalating to ${fallback}`,
+            fallbackProvider: fallback,
+        };
+    }
+    // If all providers exhausted, try split-node for complex tasks
+    if (node.cost && node.cost >= 2) {
+        return {
+            action: "split-node",
+            reason: `${ctx.totalAttempts} failures on ${node.id} — splitting into smaller tasks`,
+            splitParts: 2,
+        };
+    }
+    return skipOrAbort(node, `${ctx.totalAttempts} failures on ${node.id} — all strategies exhausted`);
+}
+// --- Helpers ---
+function skipOrAbort(node, reason) {
+    const canSkip = node.failurePolicy?.skipOnFailure === true ||
+        node.outputs?.every((o) => o.required === false);
+    return {
+        action: canSkip ? "skip" : "abort",
+        reason,
+    };
+}
+function selectFallbackProvider(available, previous) {
+    for (const provider of available) {
+        if (!previous.includes(provider)) {
+            return provider;
+        }
+    }
+    return undefined;
+}
+function buildTypeErrorAdjustment(attempt) {
+    const errorLines = attempt.error?.split("\n").slice(0, 10).join("\n") ?? "";
+    return {
+        promptPatch: `Previous attempt failed with type errors:\n${errorLines}\n\nFix these type errors specifically.`,
+    };
+}
+function buildTestFailureAdjustment(attempt) {
+    const errorLines = attempt.error?.split("\n").slice(0, 10).join("\n") ?? "";
+    return {
+        promptPatch: `Previous attempt failed tests:\n${errorLines}\n\nFix the failing tests specifically.`,
+    };
+}
+function buildBuildErrorAdjustment(attempt) {
+    const errorLines = attempt.error?.split("\n").slice(0, 10).join("\n") ?? "";
+    return {
+        promptPatch: `Previous attempt failed to build:\n${errorLines}\n\nFix the build errors specifically.`,
+    };
+}

package/dist/orchestration/routing/inventory.d.ts

@@ -0,0 +1,9 @@
+/**
+ * OMK Routing — Inventory discovery & caching
+ * Extracted from routing.ts to break God Module coupling
+ */
+import type { RouteCandidate, RoutingInventory } from "./types.js";
+export declare function resetRoutingInventoryCache(): void;
+export declare function getRoutingProjectRoot(): string;
+export declare function discoverRoutingInventory(projectRoot?: string): RoutingInventory;
+export declare function routeCandidates(inventory: RoutingInventory, staticCandidates: RouteCandidate[]): RouteCandidate[];

package/dist/orchestration/routing/inventory.js

@@ -0,0 +1,273 @@
+/**
+ * OMK Routing — Inventory discovery & caching
+ * Extracted from routing.ts to break God Module coupling
+ */
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { normalizeUserHomePath } from "../../util/fs.js";
+import { loadMergedMcpConfigSync } from "./mcp-config.js";
+let inventoryCache;
+let routeCandidatesCache;
+const OMK_PROJECT_TOOLS = [
+    "omk_search_memory", "omk_read_memory", "omk_memory_mindmap",
+    "omk_graph_query", "omk_list_agents", "omk_read_agent",
+    "omk_list_runs", "omk_read_run", "omk_run_quality_gate",
+    "omk_save_checkpoint", "omk_list_checkpoints",
+    "omk_search_snippets", "omk_get_snippet",
+];
+export function resetRoutingInventoryCache() {
+    inventoryCache = undefined;
+    routeCandidatesCache = undefined;
+}
+export function getRoutingProjectRoot() {
+    return process.env.OMK_PROJECT_ROOT ? resolve(process.env.OMK_PROJECT_ROOT) : process.cwd();
+}
+function getRoutingUserHome() {
+    return (normalizeUserHomePath(process.env.OMK_ORIGINAL_HOME)
+        ?? normalizeUserHomePath(process.env.HOME)
+        ?? normalizeUserHomePath(homedir())
+        ?? homedir());
+}
+function normalizeScope(value, fallback) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "none" || normalized === "off" || normalized === "disabled")
+        return "none";
+    if (normalized === "all" || normalized === "global" || normalized === "local-user" || normalized === "local_user" || normalized === "personal" || normalized === "user")
+        return "all";
+    if (normalized === "project" || normalized === "local")
+        return "project";
+    return fallback;
+}
+function readFlatConfig(root) {
+    try {
+        return parseSimpleToml(readFileSync(join(root, ".omk", "config.toml"), "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function parseSimpleToml(content) {
+    const result = {};
+    let section = "";
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = stripComment(rawLine).trim();
+        if (!line)
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1].trim();
+            continue;
+        }
+        const kv = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/);
+        if (!kv)
+            continue;
+        const key = section ? `${section}.${kv[1].trim()}` : kv[1].trim();
+        result[key] = normalizeConfigValue(kv[2].trim());
+    }
+    return result;
+}
+function stripComment(line) {
+    let inString = false;
+    let quote = "";
+    for (let i = 0; i < line.length; i += 1) {
+        const char = line[i];
+        if ((char === "\"" || char === "'") && line[i - 1] !== "\\") {
+            if (!inString) {
+                inString = true;
+                quote = char;
+            }
+            else if (quote === char) {
+                inString = false;
+            }
+        }
+        if (char === "#" && !inString)
+            return line.slice(0, i);
+    }
+    return line;
+}
+function normalizeConfigValue(value) {
+    if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function skillDirs(root, scope) {
+    if (scope === "none")
+        return [];
+    const dirs = [
+        { path: join(root, ".agents", "skills"), source: "project" },
+        { path: join(root, ".kimi", "skills"), source: "project" },
+        { path: join(root, ".omk", "skills"), source: "project" },
+    ];
+    if (scope === "all") {
+        const userHome = getRoutingUserHome();
+        dirs.push({ path: join(userHome, ".codex", "skills"), source: "global" }, { path: join(userHome, ".agents", "skills"), source: "global" }, { path: join(userHome, ".kimi", "skills"), source: "global" });
+    }
+    return dirs;
+}
+function readSkillNames(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && existsSync(join(dir, entry.name, "SKILL.md")))
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+function readMcpServerNames(config) {
+    return Object.keys(config.mcpServers ?? {});
+}
+function readActiveHookNames(root, scope) {
+    if (scope === "none")
+        return [];
+    const files = [
+        { path: join(root, ".omk", "kimi.config.toml"), source: "project" },
+        { path: join(root, ".kimi", "kimi.config.toml"), source: "project" },
+    ];
+    if (scope === "all") {
+        const userHome = getRoutingUserHome();
+        files.unshift({ path: join(userHome, ".kimi", "kimi.config.toml"), source: "global" }, { path: join(userHome, ".codex", "kimi.config.toml"), source: "global" });
+    }
+    const result = [];
+    for (const file of files) {
+        try {
+            const content = readFileSync(file.path, "utf-8");
+            for (const match of content.matchAll(/^\s*command\s*=\s*["']([^"']*hooks\/([^/"']+))["']/gm)) {
+                const name = match[2]?.trim();
+                if (name)
+                    result.push({ name, source: file.source });
+            }
+        }
+        catch {
+            // ignore missing or invalid hook config
+        }
+    }
+    return result;
+}
+export function discoverRoutingInventory(projectRoot = getRoutingProjectRoot()) {
+    const root = resolve(projectRoot);
+    const config = readFlatConfig(root);
+    const skillsScope = normalizeScope(config["runtime.skills_scope"] ?? process.env.OMK_SKILLS_SCOPE, "project");
+    const mcpScope = normalizeScope(config["runtime.mcp_scope"] ?? process.env.OMK_MCP_SCOPE, "project");
+    const hooksScope = normalizeScope(config["runtime.hooks_scope"] ?? process.env.OMK_HOOKS_SCOPE, "project");
+    const key = [root, skillsScope, mcpScope, hooksScope].join("|");
+    if (inventoryCache?.key === key)
+        return inventoryCache.value;
+    const skills = new Map();
+    for (const dir of skillDirs(root, skillsScope)) {
+        for (const skill of readSkillNames(dir.path)) {
+            if (!skills.has(skill))
+                skills.set(skill, dir.source);
+        }
+    }
+    const mcpServers = new Map();
+    const mergedMcp = loadMergedMcpConfigSync(root, mcpScope);
+    for (const server of readMcpServerNames({ mcpServers: mergedMcp.servers })) {
+        const source = mergedMcp.sources.get(server) ?? "project";
+        if (!mcpServers.has(server))
+            mcpServers.set(server, source);
+    }
+    const tools = new Set(["SearchWeb", "FetchURL"]);
+    if (mcpServers.has("omk-project")) {
+        for (const tool of OMK_PROJECT_TOOLS)
+            tools.add(tool);
+    }
+    const hooks = new Map();
+    for (const hook of readActiveHookNames(root, hooksScope)) {
+        if (!hooks.has(hook.name))
+            hooks.set(hook.name, hook.source);
+    }
+    const value = { skills, mcpServers, hooks, tools, diagnostics: mergedMcp.diagnostics, skillsScope, mcpScope, hooksScope };
+    inventoryCache = { key, value };
+    return value;
+}
+function keywordsFromId(id) {
+    return unique(id.replace(/^omk-/, "").split(/[-_]/).filter((keyword) => keyword.length >= 2));
+}
+function rolesFromKeywords(keywords) {
+    if (keywords.some((keyword) => ["review", "security", "quality"].includes(keyword)))
+        return ["reviewer", "qa"];
+    if (keywords.some((keyword) => ["test", "debug", "fix"].includes(keyword)))
+        return ["debugger", "tester", "coder"];
+    if (keywords.some((keyword) => ["frontend", "implementation", "typescript", "python"].includes(keyword)))
+        return ["coder"];
+    if (keywords.some((keyword) => ["repo", "research", "docs"].includes(keyword)))
+        return ["researcher", "explorer"];
+    if (keywords.some((keyword) => ["plan", "flow", "dag", "context", "router"].includes(keyword)))
+        return ["planner", "router"];
+    return ["planner", "router", "reviewer"];
+}
+function dynamicSkillCandidate(id, source) {
+    const keywords = keywordsFromId(id);
+    const readOnly = !keywords.some((keyword) => ["write", "delete", "commit", "git", "fix", "implementation"].includes(keyword));
+    return {
+        kind: "skill",
+        id,
+        source,
+        roles: rolesFromKeywords(keywords),
+        keywords,
+        readOnly,
+        writeRisk: readOnly ? "none" : "low",
+        contextCost: id.includes("flow") ? 2 : 1,
+        capabilities: keywords,
+    };
+}
+function dynamicMcpCandidate(id, source) {
+    const keywords = keywordsFromId(id);
+    return {
+        kind: "mcp",
+        id,
+        source,
+        roles: rolesFromKeywords(keywords),
+        keywords,
+        readOnly: true,
+        writeRisk: "none",
+        contextCost: 1,
+        capabilities: keywords,
+    };
+}
+function dynamicHookCandidate(id, source) {
+    const keywords = keywordsFromId(id.replace(/\.(sh|js|mjs|ts)$/i, ""));
+    return {
+        kind: "hook",
+        id,
+        source,
+        roles: rolesFromKeywords(keywords),
+        keywords: [...keywords, "hook"],
+        readOnly: !keywords.some((keyword) => ["write", "format", "shell", "guard", "secret"].includes(keyword)),
+        writeRisk: keywords.some((keyword) => ["write", "format", "shell", "guard", "secret"].includes(keyword)) ? "low" : "none",
+        contextCost: 1,
+        capabilities: keywords,
+    };
+}
+export function routeCandidates(inventory, staticCandidates) {
+    const cacheKey = [
+        inventory.skillsScope,
+        inventory.mcpScope,
+        inventory.hooksScope,
+        [...inventory.skills.keys()].join(","),
+        [...inventory.mcpServers.keys()].join(","),
+        [...inventory.hooks.keys()].join(","),
+        staticCandidates.map((c) => c.id).join(","),
+    ].join("|");
+    if (routeCandidatesCache?.key === cacheKey)
+        return routeCandidatesCache.candidates;
+    const staticIds = new Set(staticCandidates.map((candidate) => `${candidate.kind}:${candidate.id}`));
+    const dynamicSkills = [...inventory.skills.entries()]
+        .filter(([id]) => !staticIds.has(`skill:${id}`))
+        .map(([id, source]) => dynamicSkillCandidate(id, source));
+    const dynamicMcps = [...inventory.mcpServers.entries()]
+        .filter(([id]) => !staticIds.has(`mcp:${id}`))
+        .map(([id, source]) => dynamicMcpCandidate(id, source));
+    const dynamicHooks = [...inventory.hooks.entries()]
+        .filter(([id]) => !staticIds.has(`hook:${id}`))
+        .map(([id, source]) => dynamicHookCandidate(id, source));
+    const result = [...staticCandidates, ...dynamicSkills, ...dynamicMcps, ...dynamicHooks];
+    routeCandidatesCache = { key: cacheKey, candidates: result };
+    return result;
+}
+function unique(values) {
+    return [...new Set(values.filter((value) => value.trim().length > 0))];
+}

package/dist/orchestration/routing/mcp-config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * OMK Routing — MCP configuration loading & redaction
+ * Extracted from routing.ts to break God Module coupling
+ */
+import type { RouteSource } from "./types.js";
+import type { RoutingDiagnostic } from "./types.js";
+export declare function redactMcpConfig(cfg: unknown): unknown;
+export declare function loadMergedMcpConfigSync(projectRoot: string, scope: "project" | "all" | "none"): {
+    servers: Record<string, unknown>;
+    sources: Map<string, RouteSource>;
+    diagnostics: RoutingDiagnostic[];
+};
+export declare function loadMergedMcpConfig(projectRoot: string, scope: "project" | "all" | "none"): Promise<{
+    servers: Record<string, unknown>;
+    sources: Map<string, RouteSource>;
+    diagnostics: RoutingDiagnostic[];
+}>;

package/dist/orchestration/routing/mcp-config.js

@@ -0,0 +1,154 @@
+/**
+ * OMK Routing — MCP configuration loading & redaction
+ * Extracted from routing.ts to break God Module coupling
+ */
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+import { normalizeUserHomePath } from "../../util/fs.js";
+const SECRET_PATTERNS = ["apikey", "token", "password", "secret", "authorization"];
+function isSecretKey(key) {
+    const normalized = key.toLowerCase().replace(/[_-]/g, "");
+    return SECRET_PATTERNS.some((pattern) => normalized === pattern || normalized.endsWith(pattern));
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const sVal = source[key];
+        const tVal = result[key];
+        if (isPlainObject(sVal) && isPlainObject(tVal)) {
+            result[key] = deepMerge(tVal, sVal);
+        }
+        else {
+            result[key] = sVal;
+        }
+    }
+    return result;
+}
+export function redactMcpConfig(cfg) {
+    if (isPlainObject(cfg)) {
+        const result = {};
+        for (const [key, value] of Object.entries(cfg)) {
+            if (isSecretKey(key)) {
+                result[key] = "***";
+            }
+            else if (isPlainObject(value)) {
+                result[key] = redactMcpConfig(value);
+            }
+            else if (Array.isArray(value)) {
+                result[key] = value.map((item) => redactMcpConfig(item));
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    if (Array.isArray(cfg)) {
+        return cfg.map((item) => redactMcpConfig(item));
+    }
+    return cfg;
+}
+function getRoutingUserHome() {
+    return (normalizeUserHomePath(process.env.OMK_ORIGINAL_HOME)
+        ?? normalizeUserHomePath(process.env.HOME)
+        ?? normalizeUserHomePath(homedir())
+        ?? homedir());
+}
+function formatRoutingPath(root, path) {
+    const resolvedPath = resolve(path);
+    const resolvedRoot = resolve(root);
+    const rootRelative = relative(resolvedRoot, resolvedPath);
+    if (rootRelative === "")
+        return ".";
+    if (isRelativeChildPath(rootRelative))
+        return rootRelative;
+    const home = resolve(getRoutingUserHome());
+    const homeRelative = relative(home, resolvedPath);
+    if (homeRelative === "")
+        return "~";
+    if (isRelativeChildPath(homeRelative))
+        return `~/${homeRelative.split(sep).join("/")}`;
+    return resolvedPath;
+}
+function isRelativeChildPath(path) {
+    return path !== "" && path !== ".." && !path.startsWith(`..${sep}`) && !path.startsWith("../") && !isAbsolute(path);
+}
+function mcpConfigErrorMessage(err) {
+    if (err instanceof SyntaxError)
+        return "invalid JSON";
+    if (err && typeof err === "object" && "code" in err && typeof err.code === "string") {
+        return `unreadable MCP config (${err.code})`;
+    }
+    return "invalid MCP config";
+}
+function createMcpConfigDiagnostic(root, source, path, err) {
+    return {
+        kind: "mcp-config",
+        source,
+        path: formatRoutingPath(root, path),
+        message: mcpConfigErrorMessage(err),
+    };
+}
+export function loadMergedMcpConfigSync(projectRoot, scope) {
+    const root = resolve(projectRoot);
+    const servers = {};
+    const sources = new Map();
+    const diagnostics = [];
+    if (scope === "none") {
+        return { servers, sources, diagnostics };
+    }
+    const globalFiles = scope === "all" ? [join(getRoutingUserHome(), ".kimi", "mcp.json"), join(getRoutingUserHome(), ".omk", "mcp.json")] : [];
+    for (const path of globalFiles) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const parsed = JSON.parse(readFileSync(path, "utf-8"));
+            for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
+                if (!sources.has(name)) {
+                    servers[name] = cfg;
+                    sources.set(name, "global");
+                }
+            }
+        }
+        catch (err) {
+            diagnostics.push(createMcpConfigDiagnostic(root, "global", path, err));
+        }
+    }
+    const projectFiles = [
+        join(root, ".omk", "mcp.json"),
+        join(root, ".kimi", "mcp.json"),
+    ];
+    for (const path of projectFiles) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const parsed = JSON.parse(readFileSync(path, "utf-8"));
+            for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
+                if (!sources.has(name) || sources.get(name) === "global") {
+                    if (sources.has(name) && isPlainObject(servers[name]) && isPlainObject(cfg)) {
+                        servers[name] = deepMerge(servers[name], cfg);
+                    }
+                    else {
+                        servers[name] = cfg;
+                    }
+                    sources.set(name, "project");
+                }
+            }
+        }
+        catch (err) {
+            diagnostics.push(createMcpConfigDiagnostic(root, "project", path, err));
+        }
+    }
+    if (!sources.has("omk-project")) {
+        servers["omk-project"] = { type: "builtin", command: "omk", args: ["mcp", "serve", "omk-project"] };
+        sources.set("omk-project", "builtin");
+    }
+    return { servers, sources, diagnostics };
+}
+export function loadMergedMcpConfig(projectRoot, scope) {
+    return Promise.resolve(loadMergedMcpConfigSync(projectRoot, scope));
+}