open-multi-agent-kit 0.78.8 → 0.79.3

package/dist/commands/chat/native-root-loop.js

@@ -25,15 +25,18 @@ import { buildNativeChatSlashCommands } from "./slash/commands/index.js";
 import { parseSlashInput } from "./slash/parser.js";
 import { createSlashCommandRegistry } from "./slash/registry.js";
 import { emitSlashResult, okSlashResult, printSlashResult, } from "./slash/result.js";
-async function runSlashHandler(handler, parsed, ctx) {
+async function runSlashHandler(handler, parsed, ctx, options = {}) {
     const result = await handler.handler(ctx, parsed.args);
     const normalized = result ?? okSlashResult();
     if (normalized.statePatch)
         Object.assign(ctx.state, normalized.statePatch);
+    const visibleResult = options.suppressOutput
+        ? { ...normalized, text: undefined, json: undefined, events: [] }
+        : normalized;
     if (ctx.renderer)
-        emitSlashResult(normalized, ctx.renderer);
+        emitSlashResult(visibleResult, ctx.renderer);
     else
-        printSlashResult(normalized);
+        printSlashResult(visibleResult);
     return normalized;
 }
 function isModelSlashCommand(parsed) {
@@ -76,7 +79,112 @@ function explicitProviderTabFromModelLine(line, providerIds) {
 function isModelPickerLine(line, state) {
     const trimmed = line.trim();
     return /^\/(?:model|m)(?:\s|$)/.test(trimmed)
-        || (state.modelPickerOpen === true && trimmed.length === 0);
+        || (state.modelPickerOpen === true && state.thinkingPickerOpen !== true && trimmed.length === 0);
+}
+function isThinkingPickerLine(line, state) {
+    const trimmed = line.trim();
+    return (state.thinkingPickerOpen === true && trimmed.length === 0)
+        || (state.modelPickerOpen !== true && trimmed.length === 0);
+}
+function isThinkingSlashCommand(parsed) {
+    return parsed.command === "/think" || parsed.command === "/thinking" || parsed.command === ":think";
+}
+function isThinkingShowSlash(parsed) {
+    return isThinkingSlashCommand(parsed)
+        && parsed.args.positional.length === 0
+        && parsed.args.flags.json !== true;
+}
+function isThinkingFollowupSlash(parsed) {
+    return parsed.command === "/model"
+        || parsed.command === "/m"
+        || parsed.command === "/use"
+        || parsed.command === ":use";
+}
+function shouldOpenThinkingPickerAfterSlash(parsed, result) {
+    if (!result.ok || !isThinkingFollowupSlash(parsed))
+        return false;
+    if (parsed.args.positional.length === 0)
+        return false;
+    if (result.statePatch?.thinking)
+        return false;
+    return Boolean(result.statePatch?.model || result.statePatch?.provider || result.statePatch?.bootstrap);
+}
+function renderThinkingPickerText(state) {
+    const levels = thinkingLevelsFor(state.provider, state.model);
+    const current = state.thinking;
+    const levelLine = levels
+        .map((level) => {
+        const label = `${level === current ? "●" : "○"} ${level}`;
+        if (level === current)
+            return style.mintBold(label);
+        if (level === "max" || level === "xhigh")
+            return style.cyanBold(label);
+        return style.gray(label);
+    })
+        .join(style.gray("  "));
+    const active = current
+        ? `${current} (${formatThinkingModelVariant(state.model, current)})`
+        : "not selected";
+    const firstLevel = levels[0] ?? "medium";
+    return [
+        style.phosphorBold("\n  OMK Thinking Control · choose level"),
+        style.phosphorDim(`  Target: ${state.provider ?? "auto"}/${state.model ?? "auto"}`),
+        `  ${levelLine}`,
+        style.phosphorDim("  Press Tab on an empty prompt to cycle, or run /think <level>."),
+        style.phosphorDim(`  Shortcut: /model ${state.provider ?? "auto"}/${state.model ?? "auto"}:${firstLevel}`),
+        style.phosphorDim(`  Active: ${active}\n`),
+    ].join("\n");
+}
+function canUseInteractiveThinkingSelector(input, renderer) {
+    if (renderer)
+        return false;
+    if (isDisabledEnvValue(input.env.OMK_INTERACTIVE_THINKING_SELECT))
+        return false;
+    return process.stdin.isTTY === true && process.stderr.isTTY === true;
+}
+function applyThinkingLevelToNativeState(input, state, level) {
+    state.thinking = level;
+    state.thinkingPickerOpen = true;
+    state.modelPickerOpen = false;
+    state.updatedAt = new Date().toISOString();
+    input.env.OMK_THINKING = level;
+    input.env.OMK_MODEL_VARIANT = formatThinkingModelVariant(state.model, level);
+}
+async function promptThinkingSelection(input, state, renderer) {
+    if (!canUseInteractiveThinkingSelector(input, renderer))
+        return false;
+    const levels = thinkingLevelsFor(state.provider, state.model);
+    if (levels.length === 0)
+        return false;
+    try {
+        const { select } = await import("@inquirer/prompts");
+        const selected = await select({
+            message: `Select thinking level for ${state.provider ?? "auto"}/${state.model ?? "auto"}`,
+            choices: levels.map((level) => ({
+                value: level,
+                name: `${level === state.thinking ? "● " : ""}${level}`,
+                description: formatThinkingModelVariant(state.model, level),
+            })),
+            pageSize: Math.min(levels.length, 8),
+            loop: true,
+            default: state.thinking ?? input.env.OMK_THINKING ?? levels[0],
+        }, {
+            input: process.stdin,
+            output: process.stderr,
+            clearPromptOnDone: true,
+        });
+        applyThinkingLevelToNativeState(input, state, selected);
+        process.stderr.write(style.phosphorDim(`\n  Thinking variant: ${selected}\n  Active: ${input.env.OMK_MODEL_VARIANT}\n`));
+        return true;
+    }
+    catch (err) {
+        const name = err instanceof Error ? err.name : "Error";
+        if (name === "ExitPromptError") {
+            process.stderr.write(style.phosphorDim("\n  Thinking selection cancelled.\n"));
+            return true;
+        }
+        return false;
+    }
 }
 function countModelPickerRows(registry, activeProviderTab) {
     return registry
@@ -690,6 +798,7 @@ export async function runNativeOmkRootLoop(input) {
         root: input.root,
         cwd: input.activeCwd,
         rootSource: input.rootSource,
+        brandLabel: input.env.OMK_ENTRY_DISPLAY_NAME,
     });
     // opencode-style: banner handled by PlainModernRenderer session:start event
     const modelProviderRegistry = await readProviderRegistry({ env: input.env }).catch(() => []);
@@ -719,6 +828,13 @@ export async function runNativeOmkRootLoop(input) {
         else
             process.stdout.write(`${text}\n`);
     };
+    const renderThinkingPicker = () => {
+        const text = renderThinkingPickerText(state);
+        if (renderer)
+            renderer.emit({ type: "control:output", text });
+        else
+            process.stdout.write(`${text}\n`);
+    };
     // Defensive stdin re-validation before the chat readline takes ownership.
     // The first-run GitHub-star / update prompts (@inquirer/prompts) can take
     // over raw mode and leave the shared interactive stdin paused; a paused TTY
@@ -742,6 +858,7 @@ export async function runNativeOmkRootLoop(input) {
                         explicitProviderTab,
                     });
                     state.modelPickerOpen = true;
+                    state.thinkingPickerOpen = false;
                     state.activeProviderTab = modelPickerState.activeProviderTab;
                     modelPickerState.query = line;
                     renderModelPicker(explicitProviderTab ? "/model explicit" : "/model");
@@ -752,24 +869,28 @@ export async function runNativeOmkRootLoop(input) {
                     providerIds: modelProviderIds,
                 })) {
                     state.modelPickerOpen = true;
+                    state.thinkingPickerOpen = false;
                     state.activeProviderTab = modelPickerState.activeProviderTab;
                     modelPickerState.query = line;
                     renderModelPicker("\t", previousActiveProviderTab);
                 }
                 return [[], line];
             }
-            if (line.trim().length === 0 || line.trimStart().startsWith("/think")) {
+            if (/^\/(?:think|thinking)\s*$/.test(line.trim()) && state.thinkingPickerOpen !== true) {
+                state.thinkingPickerOpen = true;
+                state.modelPickerOpen = false;
+                renderThinkingPicker();
+                return [[], line];
+            }
+            if (isThinkingPickerLine(line, state)) {
                 const next = nextThinkingLevel(state.thinking ?? input.env.OMK_THINKING, state.provider, state.model);
                 state.thinking = next;
+                state.thinkingPickerOpen = true;
+                state.modelPickerOpen = false;
                 state.updatedAt = new Date().toISOString();
                 input.env.OMK_THINKING = next;
                 input.env.OMK_MODEL_VARIANT = formatThinkingModelVariant(state.model, next);
-                const levels = thinkingLevelsFor(state.provider, state.model).join(" → ");
-                const message = `\n  Thinking: ${next} (${levels}) · ${input.env.OMK_MODEL_VARIANT}\n`;
-                if (renderer)
-                    renderer.emit({ type: "control:output", text: style.phosphorDim(message) });
-                else
-                    process.stdout.write(style.phosphorDim(message));
+                renderThinkingPicker();
             }
             return [[], line];
         },
@@ -882,6 +1003,7 @@ export async function runNativeOmkRootLoop(input) {
                     });
                     modelPickerState.query = "";
                     state.modelPickerOpen = true;
+                    state.thinkingPickerOpen = false;
                     state.activeProviderTab = modelPickerState.activeProviderTab;
                     const tabs = buildProviderTabs(modelProviderIds);
                     debugModelTabs({
@@ -899,8 +1021,12 @@ export async function runNativeOmkRootLoop(input) {
                     state.activeProviderTab = ALL_PROVIDER_TAB;
                 }
                 try {
+                    let slashResult;
+                    const thinkingShow = isThinkingShowSlash(parsedSlash);
+                    const interactiveThinkingSelector = canUseInteractiveThinkingSelector(input, renderer);
                     await terminalOwner.withChildProcess(rl, async () => {
-                        const result = await runSlashHandler(handler, parsedSlash, slashContext);
+                        const result = await runSlashHandler(handler, parsedSlash, slashContext, { suppressOutput: thinkingShow && interactiveThinkingSelector });
+                        slashResult = result;
                         if (parsedSlash.command === "/paste" && result.ok) {
                             const pasteLine = result.text?.trim();
                             if (pasteLine) {
@@ -912,8 +1038,28 @@ export async function runNativeOmkRootLoop(input) {
                         if (result.exit)
                             running = false;
                     });
-                    if (!modelShow && !isModelSlashCommand(parsedSlash)) {
+                    const shouldSelectThinking = slashResult
+                        ? (thinkingShow && interactiveThinkingSelector) || shouldOpenThinkingPickerAfterSlash(parsedSlash, slashResult)
+                        : false;
+                    if (shouldSelectThinking) {
+                        state.modelPickerOpen = false;
+                        state.thinkingPickerOpen = true;
+                        state.activeProviderTab = ALL_PROVIDER_TAB;
+                        const selected = await terminalOwner.withRawSelector(rl, () => promptThinkingSelection(input, state, renderer));
+                        if (!selected)
+                            renderThinkingPicker();
+                    }
+                    else if (isThinkingSlashCommand(parsedSlash)) {
+                        state.modelPickerOpen = false;
+                        state.thinkingPickerOpen = true;
+                    }
+                    else if (!modelShow && isThinkingFollowupSlash(parsedSlash)) {
+                        state.modelPickerOpen = false;
+                        state.thinkingPickerOpen = false;
+                    }
+                    else if (!modelShow && !isModelSlashCommand(parsedSlash)) {
                         state.modelPickerOpen = false;
+                        state.thinkingPickerOpen = false;
                     }
                 }
                 catch (err) {
@@ -930,6 +1076,8 @@ export async function runNativeOmkRootLoop(input) {
                 }
                 continue;
             }
+            state.modelPickerOpen = false;
+            state.thinkingPickerOpen = false;
             const message = `Unknown command: ${parsedSlash.command}. Type /help for commands.`;
             if (renderer) {
                 renderer.emit({ type: "turn:error", message });
@@ -940,6 +1088,7 @@ export async function runNativeOmkRootLoop(input) {
             continue;
         }
         state.modelPickerOpen = false;
+        state.thinkingPickerOpen = false;
         if (shouldRunNativeParallelTurn(state.approvalPolicy)) {
             const turnStartedAt = Date.now();
             try {

package/dist/commands/chat/runtime.js

@@ -48,6 +48,8 @@ function buildBaseChatRuntimeEnv(root, sessionId) {
     const omkNames = [
         "OMK_AUTHORITY_PROVIDER",
         "OMK_CHAT_NO_BANNER",
+        "OMK_ENTRY_DISPLAY_NAME",
+        "OMK_ENTRY_SURFACE",
         "OMK_DEBUG",
         "OMK_DEFAULT_PROVIDER",
         "OMK_MCP_PREFLIGHT",
@@ -92,6 +94,13 @@ function attachSelectedProviderEnv(env, provider, source = process.env) {
         add("KIMI_MODEL");
         add("KIMI_BASE_URL");
     }
+    if (provider === "glm" || provider === "auto") {
+        add("BIGMODEL_API_KEY");
+        add("GLM_API_KEY");
+        add("GLM_MODEL");
+        add("GLM_BASE_URL");
+        add("BIGMODEL_BASE_URL");
+    }
     return next;
 }
 function formatRuntimeBootstrapFailure(bootstrap) {

package/dist/commands/chat/slash/commands/routing.js

@@ -152,7 +152,13 @@ export function buildRoutingSlashCommands() {
                         ].join("\n"),
                     });
                 }
-                const level = !requested || requested === "next" || requested === "tab"
+                if (!requested) {
+                    return okSlashResult({
+                        statePatch: { thinkingPickerOpen: true, updatedAt: new Date().toISOString() },
+                        text: renderThinkingLevelList(ctx, levels),
+                    });
+                }
+                const level = requested === "next" || requested === "tab"
                     ? nextThinkingLevel(ctx.state.thinking ?? ctx.env.OMK_THINKING, ctx.state.provider, ctx.state.model)
                     : normalizeThinkingLevel(requested);
                 if (!level || !levels.includes(level)) {
@@ -202,6 +208,30 @@ export function buildRoutingSlashCommands() {
         },
     ];
 }
+function renderThinkingLevelList(ctx, levels) {
+    const current = ctx.state.thinking ?? ctx.env.OMK_THINKING;
+    const levelLine = levels
+        .map((level) => {
+        const label = `${level === current ? "●" : "○"} ${level}`;
+        if (level === current)
+            return style.mintBold(label);
+        if (level === "max" || level === "xhigh")
+            return style.cyanBold(label);
+        return style.gray(label);
+    })
+        .join(style.gray("  "));
+    const active = current
+        ? `${current} (${formatThinkingModelVariant(ctx.state.model, current)})`
+        : "not selected";
+    return [
+        style.phosphorBold("\n  OMK Thinking Control · choose level"),
+        style.phosphorDim(`  Target: ${ctx.state.provider ?? "auto"}/${ctx.state.model ?? "auto"}`),
+        `  ${levelLine}`,
+        style.phosphorDim(`  Choose directly: /think ${levels.join(" | /think ")}`),
+        style.phosphorDim("  Cycle only when explicit: /think next"),
+        style.phosphorDim(`  Active: ${active}\n`),
+    ].join("\n");
+}
 function modelRefFromParsed(parsed, raw) {
     return `${parsed.provider ? `${parsed.provider}/` : ""}${parsed.model ?? raw}`;
 }

package/dist/commands/chat/utils.js

@@ -55,10 +55,12 @@ export function resolveLayout(requested) {
 export function defaultChatUiForBrand(brand) {
     if (brand === "green-rain" || brand === "neon-grid" || brand === "rust-forge")
         return brand;
+    if (brand === undefined || brand === "omk")
+        return "neon-grid";
     return undefined;
 }
 export function resolveChatUi(requested, env = process.env) {
-    const raw = requested ?? env.OMK_UI ?? env.OMK_CHAT_UI ?? "system24";
+    const raw = requested ?? env.OMK_UI ?? env.OMK_CHAT_UI ?? "neon-grid";
     const normalized = raw.trim().toLowerCase();
     if (normalized === "plain-modern" || normalized === "modern" || normalized === "agent-console")
         return "plain-modern";

package/dist/commands/cockpit/render.js

@@ -325,7 +325,8 @@ export async function renderCockpit(options = {}) {
     let latestRunName = options.runId ?? null;
     let stateContent = null;
     let sessionMeta = null;
-    if (await pathExists(runsDir)) {
+    const shouldLoadRunState = !quick || Boolean(latestRunName);
+    if (shouldLoadRunState && await pathExists(runsDir)) {
         if (!latestRunName) {
             const entries = await readdir(runsDir, { withFileTypes: true });
             const dirs = entries.filter((e) => e.isDirectory());

package/dist/commands/doctor/checks.js

@@ -179,7 +179,7 @@ export async function runtimeChecks(resources) {
     });
     const currentVersion = getOmkVersionSync();
     try {
-        const latest = execSync("npm view @omk/cli version", {
+        const latest = execSync("npm view open-multi-agent-kit version", {
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "ignore"],
             timeout: 5000,
@@ -188,7 +188,7 @@ export async function runtimeChecks(resources) {
             results.push({
                 name: "OMK Version",
                 status: "warn",
-                message: `${currentVersion} → ${latest} available. Run: npm i -g @omk/cli`,
+                message: `${currentVersion} → ${latest} available. Run: npm i -g open-multi-agent-kit`,
             });
         }
         else {

package/dist/commands/init/core.js

@@ -286,9 +286,9 @@ export async function initCommand(options) {
         console.log("");
         console.log(style.orange("⚠️  omk is not in PATH."));
         console.log(style.gray("   Run one of the following:"));
-        console.log(style.gray("   1) npm install -g @omk/cli"));
+        console.log(style.gray("   1) npm install -g open-multi-agent-kit"));
         console.log(style.gray("   2) npm link (for development)"));
-        console.log(style.gray("   3) alias omk='npx -p @omk/cli omk'"));
+        console.log(style.gray("   3) alias omk='npx -p open-multi-agent-kit omk'"));
     }
     else {
         await maybeInstallShellCompletion(root);

package/dist/commands/init.js

@@ -2366,9 +2366,9 @@ export async function initCommand(options) {
         console.log("");
         console.log(style.orange("⚠️  omk is not in PATH."));
         console.log(style.gray("   Run one of the following:"));
-        console.log(style.gray("   1) npm install -g @omk/cli"));
+        console.log(style.gray("   1) npm install -g open-multi-agent-kit"));
         console.log(style.gray("   2) npm link (for development)"));
-        console.log(style.gray("   3) alias omk='npx -p @omk/cli omk'"));
+        console.log(style.gray("   3) alias omk='npx -p open-multi-agent-kit omk'"));
     }
     else {
         await maybeInstallShellCompletion(root);

package/dist/commands/mcp/config.js

@@ -3,14 +3,19 @@ import { join } from "path";
 import { getProjectRoot, pathExists, getUserHome, STALE_PACKAGE_NAMES, } from "../../util/fs.js";
 import { style, header, status, label } from "../../util/theme.js";
 import { maskSensitiveText } from "../../util/secret-mask.js";
-import { formatArgsForDisplay, isHttpUrl, isSecretEnvName, loadConfig, RAILWAY_REMOTE_MCP_URL, sanitizeMcpServerForProject, sanitizeMcpUrlForDisplay, } from "./shared.js";
+import { formatArgsForDisplay, isHttpUrl, isSecretEnvName, loadConfig, normalizeMcpServerName, RAILWAY_REMOTE_MCP_URL, sanitizeMcpServerForProject, sanitizeMcpUrlForDisplay, } from "./shared.js";
 export async function mcpRemoveCommand(serverName, options = {}) {
+    const normalizedServerName = normalizeMcpServerName(serverName);
     const root = getProjectRoot();
     const localPath = join(root, ".kimi", "mcp.json");
     const omkPath = join(root, ".omk", "mcp.json");
     const globalPath = join(getUserHome(), ".kimi", "mcp.json");
     const sources = options.global
-        ? [{ path: globalPath, label: "global" }]
+        ? [
+            { path: join(getUserHome(), ".omk", "agent", "mcp.json"), label: "global-agent" },
+            { path: globalPath, label: "global" },
+            { path: join(getUserHome(), ".omk", "mcp.json"), label: "global-omk" },
+        ]
         : [
             { path: localPath, label: "project-local" },
             { path: omkPath, label: "omk-project" },
@@ -18,50 +23,67 @@ export async function mcpRemoveCommand(serverName, options = {}) {
     let removed = false;
     for (const src of sources) {
         const cfg = await loadConfig(src.path);
-        if (!cfg.parsed || !cfg.config.mcpServers || !(serverName in cfg.config.mcpServers)) {
+        if (!cfg.parsed || !cfg.config.mcpServers || !(normalizedServerName in cfg.config.mcpServers)) {
             continue;
         }
         const next = { ...cfg.config.mcpServers };
-        delete next[serverName];
+        delete next[normalizedServerName];
         await writeFile(src.path, JSON.stringify({ mcpServers: next }, null, 2) + "\n", "utf-8");
-        console.log(status.ok(`Removed "${serverName}" from ${src.label} MCP config: ${src.path}`));
+        console.log(status.ok(`Removed "${normalizedServerName}" from ${src.label} MCP config: ${src.path}`));
         removed = true;
         break;
     }
     if (!removed) {
-        console.log(status.error(`Server "${serverName}" not found in ${options.global ? "global" : "project-local"} MCP configs.`));
+        console.log(status.error(`Server "${normalizedServerName}" not found in ${options.global ? "global" : "project-local"} MCP configs.`));
         console.log(style.gray(`Checked: ${sources.map((s) => s.path).join(", ")}`));
         if (!options.global) {
-            console.log(style.gray(`To remove from global config, run \`omk mcp remove ${serverName} --global\`, or edit ~/.kimi/mcp.json manually.`));
+            console.log(style.gray(`To remove from global config, run \`omk mcp remove ${normalizedServerName} --global\`, or edit ~/.kimi/mcp.json manually.`));
         }
         else {
-            console.log(style.gray(`To remove from project-local configs, run \`omk mcp remove ${serverName}\`.`));
+            console.log(style.gray(`To remove from project-local configs, run \`omk mcp remove ${normalizedServerName}\`.`));
         }
         process.exit(1);
     }
 }
 export async function mcpAddCommand(serverName) {
+    const normalizedServerName = normalizeMcpServerName(serverName);
     const root = getProjectRoot();
-    const globalPath = join(getUserHome(), ".kimi", "mcp.json");
+    const home = getUserHome();
+    const globalPaths = [
+        join(home, ".omk", "agent", "mcp.json"),
+        join(home, ".kimi", "mcp.json"),
+        join(home, ".omk", "mcp.json"),
+    ];
     const projectMcpPath = join(root, ".kimi", "mcp.json");
-    const globalSource = await loadConfig(globalPath);
-    if (!globalSource.parsed || !globalSource.config.mcpServers || !(serverName in globalSource.config.mcpServers)) {
-        console.log(status.error(`Server "${serverName}" not found in global MCP config: ${globalPath}`));
+    let selected;
+    let selectedPath = "";
+    for (const globalPath of globalPaths) {
+        const globalSource = await loadConfig(globalPath);
+        if (globalSource.parsed && globalSource.config.mcpServers && normalizedServerName in globalSource.config.mcpServers) {
+            selected = globalSource.config.mcpServers[normalizedServerName];
+            selectedPath = globalPath;
+            break;
+        }
+    }
+    if (!selected) {
+        console.log(status.error(`Server "${normalizedServerName}" not found in trusted global MCP configs.`));
+        console.log(style.gray(`Checked: ${globalPaths.join(", ")}`));
         process.exit(1);
     }
     const projectMcpSource = await loadConfig(projectMcpPath);
     const projectMcpServers = projectMcpSource.parsed && projectMcpSource.config.mcpServers
         ? { ...projectMcpSource.config.mcpServers }
         : {};
-    if (serverName in projectMcpServers) {
-        console.log(status.error(`Server "${serverName}" already exists in ${projectMcpPath}`));
+    if (normalizedServerName in projectMcpServers) {
+        console.log(status.error(`Server "${normalizedServerName}" already exists in ${projectMcpPath}`));
         process.exit(1);
     }
-    projectMcpServers[serverName] = sanitizeMcpServerForProject(globalSource.config.mcpServers[serverName]);
+    projectMcpServers[normalizedServerName] = sanitizeMcpServerForProject(selected);
     await mkdir(join(root, ".kimi"), { recursive: true });
     await writeFile(projectMcpPath, JSON.stringify({ mcpServers: projectMcpServers }, null, 2) + "\n", "utf-8");
     console.log(header("MCP Add"));
-    console.log(status.ok(`Added "${serverName}" to ${projectMcpPath}`));
+    console.log(status.ok(`Added "${normalizedServerName}" to ${projectMcpPath}`));
+    console.log(label("Source", selectedPath));
 }
 export async function mcpInstallCommand(name, command, args, options = {}) {
     const root = getProjectRoot();

package/dist/commands/mcp/doctor.js

@@ -4,7 +4,7 @@ import { collectMcpConfigs, diagnoseRuntimeMcpServer, pathExists, getUserHome, p
 import { getOmkResourceSettings } from "../../util/resource-profile.js";
 import { style, header, status, label } from "../../util/theme.js";
 import { maskSensitiveText } from "../../util/secret-mask.js";
-import { basenameOfCommand, collectServers, isHttpUrl, isRailwayMcpServer, isSupabaseMcpServer, RAILWAY_REMOTE_MCP_URL, resolveAllConfigs, sanitizeMcpUrlForDisplay, selectEffectiveServer, serverTargetText, validateRemoteMcpUrl, } from "./shared.js";
+import { basenameOfCommand, collectServers, isHttpUrl, isRailwayMcpServer, isSupabaseMcpServer, normalizeMcpEnv, RAILWAY_REMOTE_MCP_URL, resolveAllConfigs, sanitizeMcpUrlForDisplay, selectEffectiveServer, serverTargetText, validateRemoteMcpUrl, } from "./shared.js";
 import { repairMcpDoctorIssues } from "./doctor-fix.js";
 export async function mcpDoctorCommand(options = {}) {
     const fixes = options.fix
@@ -149,13 +149,12 @@ export async function buildMcpDoctorReport() {
                     : { severity: "error", kind: "arg-path-not-found", message: `arg path not found: ${displayArg}` });
             }
         }
-        if (server.env) {
-            for (const [key, value] of Object.entries(server.env)) {
-                if (value.startsWith("${") && value.endsWith("}")) {
-                    const envName = value.slice(2, -1);
-                    if (!process.env[envName]) {
-                        checks.push({ severity: "warn", kind: "env-reference-undefined", message: `env reference undefined: ${key} → ${envName}` });
-                    }
+        const env = normalizeMcpEnv(server.env);
+        for (const [key, value] of Object.entries(env)) {
+            if (value.startsWith("${") && value.endsWith("}")) {
+                const envName = value.slice(2, -1);
+                if (!process.env[envName]) {
+                    checks.push({ severity: "warn", kind: "env-reference-undefined", message: `env reference undefined: ${key} → ${envName}` });
                 }
             }
         }

package/dist/commands/mcp/list.js

@@ -2,7 +2,7 @@ import { collectMcpConfigs } from "../../util/fs.js";
 import { getOmkResourceSettings } from "../../util/resource-profile.js";
 import { style, header, bullet } from "../../util/theme.js";
 import { maskSensitiveText } from "../../util/secret-mask.js";
-import { collectServers, formatArgsForDisplay, resolveAllConfigs, sanitizeMcpUrlForDisplay, selectEffectiveServer, } from "./shared.js";
+import { collectServers, formatArgsForDisplay, formatMcpEnvKeys, resolveAllConfigs, sanitizeMcpUrlForDisplay, selectEffectiveServer, } from "./shared.js";
 export async function mcpListCommand() {
     const sources = await resolveAllConfigs();
     const servers = collectServers(sources);
@@ -41,8 +41,9 @@ export async function mcpListCommand() {
         if (server.args && server.args.length > 0) {
             console.log(`  ${style.gray("args:")} ${formatArgsForDisplay(server.args)}`);
         }
-        if (server.env && Object.keys(server.env).length > 0) {
-            console.log(`  ${style.gray("env:")} ${Object.keys(server.env).join(", ")}`);
+        const envKeys = formatMcpEnvKeys(server.env);
+        if (envKeys.length > 0) {
+            console.log(`  ${style.gray("env:")} ${envKeys.join(", ")}`);
         }
         console.log(`  ${style.gray("from:")} ${info.sources.join(", ")}`);
         if (activeSources.length > 0) {

package/dist/commands/mcp/shared.d.ts

@@ -2,7 +2,7 @@ export interface McpServerConfig {
     url?: string;
     command?: string;
     args?: string[];
-    env?: Record<string, string>;
+    env?: Record<string, string> | string[];
     headers?: Record<string, string>;
     http_headers?: Record<string, string>;
     startup_timeout_sec?: number;
@@ -25,6 +25,7 @@ export interface CollectedMcpServer {
 }
 export declare const RAILWAY_REMOTE_MCP_URL = "https://mcp.railway.com";
 export declare function loadConfig(filePath: string): Promise<ConfigSource>;
+export declare function normalizeMcpServerName(name: string): string;
 export declare function resolveAllConfigs(): Promise<ConfigSource[]>;
 export declare function collectServers(sources: ConfigSource[]): Map<string, CollectedMcpServer>;
 export declare function selectEffectiveServer(info: CollectedMcpServer, activePathOrder: string[]): McpServerConfig;
@@ -41,6 +42,8 @@ export declare function serverTargetText(server: McpServerConfig): string;
 export declare function isRailwayMcpServer(name: string, server: McpServerConfig): boolean;
 export declare function isSupabaseMcpServer(name: string, server: McpServerConfig): boolean;
 export declare function formatArgsForDisplay(args: string[]): string;
+export declare function normalizeMcpEnv(env: McpServerConfig["env"]): Record<string, string>;
+export declare function formatMcpEnvKeys(env: McpServerConfig["env"]): string[];
 export declare function sanitizeMcpServerForProject(server: McpServerConfig): McpServerConfig;
 export declare function sanitizeMcpArgsForProject(args: string[]): string[];
 export declare function isHttpUrl(value: string): boolean;

package/dist/commands/mcp/shared.js

@@ -17,13 +17,18 @@ export async function loadConfig(filePath) {
         return { path: filePath, config: {}, exists: true, parsed: false, error: `Invalid JSON: ${message}` };
     }
 }
+export function normalizeMcpServerName(name) {
+    return name.trim().toLowerCase() === "adptorch" ? "adaptorch" : name;
+}
 export async function resolveAllConfigs() {
     const root = getProjectRoot();
+    const home = getUserHome();
     const paths = [
         join(root, ".omk", "mcp.json"),
         join(root, ".kimi", "mcp.json"),
-        join(getUserHome(), ".kimi", "mcp.json"),
-        join(getUserHome(), ".omk", "mcp.json"),
+        join(home, ".omk", "agent", "mcp.json"),
+        join(home, ".kimi", "mcp.json"),
+        join(home, ".omk", "mcp.json"),
     ];
     const results = [];
     for (const p of paths) {
@@ -116,6 +121,19 @@ export function isSupabaseMcpServer(name, server) {
 export function formatArgsForDisplay(args) {
     return sanitizeMcpArgsForProject(args).join(" ");
 }
+export function normalizeMcpEnv(env) {
+    if (!env)
+        return {};
+    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 env;
+}
+export function formatMcpEnvKeys(env) {
+    return Object.keys(normalizeMcpEnv(env));
+}
 export function sanitizeMcpServerForProject(server) {
     const cleaned = JSON.parse(JSON.stringify(server));
     if (typeof cleaned.url === "string") {
@@ -129,7 +147,7 @@ export function sanitizeMcpServerForProject(server) {
     }
     if (cleaned.env && typeof cleaned.env === "object") {
         const env = {};
-        for (const [key, value] of Object.entries(cleaned.env)) {
+        for (const [key, value] of Object.entries(normalizeMcpEnv(cleaned.env))) {
             env[key] = isSecretEnvName(key) ? `\${${key}}` : value;
         }
         cleaned.env = env;