@numa-tech/numa 1.26.8 → 1.26.9

package/README.md

@@ -38,7 +38,15 @@ numa notion page create --grant 41 --file page.json --json
 
 ## Jev 企业决策（开发中）
 
-Jev 企业接入已开始实施：定制 Skill 指导 Agent 调用平台原生 MCP，平台统一授权并经指定代理访问 OpenRouter。终端 Agent、ChatGPT 和 K8s Agent 的接口、身份及验收边界见 [Jev 详细设计](docs/design/jev-integration.md)，源码包见 [numa-jev Skill](skills/numa-jev/SKILL.md) 和 [应用示例](examples/jev/README.md)。当前是未发布源码；ChatGPT 远程 OAuth 仍按设计待实施，Skill 安装不等于 MCP 已连接。
+`numa jev` 直接调用平台 HTTP API，复用当前平台身份。正常任务一次提交业务请求；输入、权限、可用性和结果校验由 CLI 处理，无需先查帮助、capabilities 或执行试探性推理。
+
+```sh
+numa jev decide --file request.json --json
+```
+
+输出单个 JSON，包含 `status`、`availability` 和结果或 `next_action`。输入错误返回 `needs_input`，身份/服务问题返回 `blocked`；请求中断或响应异常返回 `pending`，可能已计费，不自动重放。`--check` 与 `capabilities` 仅供主动诊断。
+
+目前是未发布源码，不能假定 npm latest 已包含该命令。用法见 [CLI 指引](skills/numa-jev/references/cli-usage.md)，三类接入边界见 [Jev 设计](docs/design/jev-integration.md) 与 [numa-jev Skill](skills/numa-jev/SKILL.md)。平台管理上游密钥和代理；ChatGPT 远程 MCP/OAuth 为独立接入路径，CLI 不回退到 MCP。
 
 ## 显式用户授权
 
@@ -615,7 +623,10 @@ numa maintenance run --force --json
 未下发默认列表时给出 profile 配置提示；不会猜测或硬编码默认客户端。
 `skillBootstrap.enabled` 只控制登录后的自动初始化，不影响用户主动执行 install。
 多客户端共用一次下载，同目录目标去重，已有文件保留并报告 `SKIPPED_EXISTING`；
-这不表示已有版本已核对。使用 `--force` 才备份替换。显式单客户端保留原有 JSON 结果结构。
+已登记且未修改的 Skill 会提示使用更新；本地自建或修改过的同名 Skill 在交互模式下询问
+是否备份覆盖，非交互需显式 `--force`。显式单客户端保留原有 JSON 成功结果结构。
+安装向导支持同时勾选多个 Skills 和 Agents；命令行也可使用
+`numa skills install numa-cli numa-notion --agent claude,codex --interactive`。
 
 | 客户端 | Skill | MCP Server |
 | --- | --- | --- |

package/dist/ai-registry/commands.js

@@ -1,17 +1,20 @@
 import { addGatewayOptions, executeGatewayCommand, registerGatewayCommands, useGatewayMode } from "../mcp-gateway/commands.js";
 import { appendEnvironment, collectEnvironment, parseEnvironment, safeMcpOutput } from "../mcp/environment.js";
-import { completeRegistryInstall } from "../interactive/registry.js";
+import { completeSkillBatchInstall, completeRegistryInstall } from "../interactive/registry.js";
 import { terminalUi, useInteractive, requireInput, confirmInstall, InstallCancelled, chooseEnvironment } from "../interactive/prompts.js";
-import { lstat, readFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import process from "node:process";
 import { loadAppConfig } from "../app-config.js";
+import { requireProfileService } from "../platform-profile.js";
+import { prepareRegistryInstanceMigration, applyRegistryInstanceMigration } from "../compatibility/index.js";
 import { loadConfig as loadPlatformConfig } from "../config.js";
 import { AiRegistryClient } from "./client.js";
 import { readMcpSpecification } from "./mcp-management.js";
 import { registerMcpRuntimeCommands } from "./mcp-runtime-commands.js";
 import { runMcpBridge } from "./bridge.js";
 import { bootstrapSkills } from "./bootstrap.js";
+import { decideSkillInstall } from "./install-conflicts.js";
 import { resolveSkillInstallTargets } from "./install-defaults.js";
 import { chooseSkillUpdates } from "./update-prompt.js";
 import { recordManagedSkill, updateSkillPreferences } from "./updates.js";
@@ -23,7 +26,7 @@ import { maintenanceIdentity } from "../maintenance/identity.js";
 import { AiRegistryError, sanitizeRegistryOutput } from "./errors.js";
 import { installMcpClientDefinition, mcpDefinitionFromNacos } from "./mcp-installer.js";
 import { resolveRegistryNamespace } from "./namespace.js";
-import { installSkillArchive, skillTargetRoot } from "./skill-installer.js";
+import { installSkillArchive, safeSkillName, skillTargetRoot } from "./skill-installer.js";
 import { assertConsumersCompatible, assertInstalledDependencies, confirmSkillDependencies, resolveSkillDependencies } from "./skill-dependencies.js";
 import { assertRouterHealth, lockRegistryWorkspace, portableInstallPath, resolveVersion, routerMcpDefinition, syncRegistryWorkspace } from "./sync.js";
 import { runRegistryTui } from "./tui.js";
@@ -275,10 +278,10 @@ export function registerAiRegistryCommands(program, dependencies = {}) {
         const result = await client.getSkill(targetNamespace.id, name);
         await output(command, { ok: true, namespace: targetNamespace, skill: result }, JSON.stringify(sanitizeRegistryOutput(result), null, 2));
     }), ["numa skills inspect release-helper --namespace team-ai --json"]);
-    addExamples(skills.command("install [name]")
+    addExamples(skills.command("install [names...]")
         .option("-n, --namespace <key>", "namespaceKey")
         .option("-i, --instance <id-or-code>", "同名 namespace 的实例消歧")
-        .option("-a, --agent <agent>", "覆盖 profile 默认客户端：chatgpt|codex|claude|cursor|workbuddy|openclaw|agents|custom")
+        .option("-a, --agent <agent>", "逗号分隔的目标客户端，覆盖 profile 默认：chatgpt|codex|claude|cursor|workbuddy|openclaw|agents|custom")
         .option("--scope <scope>", "user（所有工作空间）|project（当前项目）", "user")
         .option("--version <semver>", "精确版本")
         .option("--label <label>", "路由标签，例如 latest")
@@ -291,146 +294,191 @@ export function registerAiRegistryCommands(program, dependencies = {}) {
         .option("--adopt-dependencies", "与 --with-dependencies 配合，确认接管已核验的未登记旧依赖")
         .option("--interactive", "交互选择来源、Skill、版本、Agent 和安装范围")
         .option("--no-interactive", "不询问；依赖安装须显式 --with-dependencies")
-        .action(async (name, options, command) => {
+        .action(async (names, options, command) => {
         const json = jsonEnabled(command, (await loadAppConfig()).output), ui = dependencies.ui ?? terminalUi;
-        const interactive = useInteractive(options, !name || !options.agent || options.agent === "custom" && !options.customRoot, json, dependencies.tty);
+        const interactive = useInteractive(options, !names.length || !options.agent || Boolean(options.agent?.split(",").map(value => value.trim()).includes("custom") && !options.customRoot), json, dependencies.tty);
         if (!interactive)
-            requireInput(name, "缺少 Skill 名称");
+            requireInput(names.length, "缺少 Skill 名称");
         await dependencies.initializeProfile?.();
         const client = dependencies.clientFactory?.() ?? new AiRegistryClient(loadConfig("aiRegistry"));
-        if (interactive) {
-            const selected = await completeRegistryInstall("skill", name, { ...options, scope: command.getOptionValueSource("scope") === "default" ? undefined : options.scope }, client, ui);
-            name = selected.name;
-            options = { ...options, ...selected.options, scope: selected.options.scope ?? options.scope };
-        }
-        requireInput(name, "缺少 Skill 名称");
-        const targets = await resolveSkillInstallTargets(options);
-        if (targets.scope === "project" && options.updates === "current")
-            throw new Error("Project Skills remain locked; use registry upgrade.");
-        const context = await resolveContext(client, options, "install");
-        const detail = await client.getSkill(context.namespace.id, name);
-        const trackedLabel = options.version ? undefined : options.label ?? "latest";
-        const version = resolveVersion(detail, options.version, trackedLabel, name);
-        const download = await client.downloadSkill(context.namespace.id, name, { version });
-        const graph = await resolveSkillDependencies(client, context.namespace.id, { name, version, download, dependencies: [] });
-        const dependencyNodes = graph.filter(node => node.name !== name);
-        const source = { namespace: context.namespace.namespaceKey, instance: context.namespace.instanceCode,
-            namespaceId: context.namespace.id, instanceId: context.namespace.instanceId };
-        const identity = await maintenanceIdentity(loadConfig("aiRegistry"));
-        const dependencyPlans = new Map();
-        for (const agent of targets.agents) {
-            const target = { agent, scope: targets.scope, workspace: options.workspace, customRoot: options.customRoot, skillName: name };
-            const rootPath = resolve(skillTargetRoot(target), name);
-            await assertConsumersCompatible(name, version, rootPath);
-            if (dependencyNodes.length) {
-                const existing = await lstat(rootPath).catch((e) => { if (e.code === "ENOENT")
-                    return undefined; throw e; });
-                if (existing && !options.force && !options.plan)
-                    throw new AiRegistryError("Root Skill already exists; inspect local changes and explicitly approve --force before installing dependencies.", "ai_registry_install_exists");
-                const root = { ...source, identity: identity ?? "", name, version, agent, scope: targets.scope,
-                    path: rootPath, workspace: options.workspace, customRoot: options.customRoot, id: "", archiveSha256: download.sha256,
-                    contentDigest: "", updatedAt: 0, policy: "pinned" };
-                dependencyPlans.set(agent, { root, prepared: await prepareSkillGraph(root, dependencyNodes, client, undefined, graph.find(n => n.name === name)) });
+        const selections = interactive
+            ? await completeSkillBatchInstall(names, { ...options, scope: command.getOptionValueSource("scope") === "default" ? undefined : options.scope }, client, ui)
+            : [...new Set(names)].map(name => ({ name, options }));
+        const results = [];
+        const installOne = async (name, options) => {
+            const emit = async (_command, result, textValue) => {
+                if (selections.length === 1)
+                    await output(command, result, textValue);
+                else
+                    results.push({ name, result, text: textValue });
+            };
+            name = safeSkillName(name);
+            const targets = await resolveSkillInstallTargets(options);
+            if (targets.scope === "project" && options.updates === "current")
+                throw new Error("Project Skills remain locked; use registry upgrade.");
+            const context = await resolveContext(client, options, "install");
+            const detail = await client.getSkill(context.namespace.id, name);
+            const trackedLabel = options.version ? undefined : options.label ?? "latest";
+            const version = resolveVersion(detail, options.version, trackedLabel, name);
+            const decisions = new Map();
+            const conflictUi = !options.plan && useInteractive(options, true, json, dependencies.tty) ? ui : undefined;
+            for (const agent of targets.agents) {
+                const target = { agent, scope: targets.scope, workspace: options.workspace, skillName: name, force: options.force };
+                decisions.set(agent, options.plan ? { force: Boolean(options.force) }
+                    : await decideSkillInstall(resolve(skillTargetRoot({ ...target, customRoot: options.customRoot }), name), target, conflictUi));
             }
-        }
-        const plan = { source, scope: targets.scope, agents: targets.agents, packages: graph.map(node => ({
-                name: node.name, version: node.version, sha256: node.download.sha256, dependencies: node.dependencies,
-                targets: targets.agents.map(agent => resolve(skillTargetRoot({ agent, scope: targets.scope, workspace: options.workspace, customRoot: options.customRoot }), node.name))
-            })), dependencyTargets: [...dependencyPlans.values()].map(p => p.prepared.plan) };
-        if (options.plan) {
-            await output(command, { ok: true, plan }, JSON.stringify(plan, null, 2));
-            return;
-        }
-        const adoptsDependencies = plan.dependencyTargets.some(p => p.packages.some(d => d.adopt));
-        // Complete arguments skip discovery, but a TTY can still confirm dependencies.
-        const promptDependencies = dependencyNodes.length > 0 && (!options.withDependencies || adoptsDependencies && !options.adoptDependencies)
-            && useInteractive(options, true, json, dependencies.tty);
-        if (interactive || promptDependencies) {
-            if (dependencyNodes.length) {
-                ui.note(plan.dependencyTargets.map(formatSkillUpdatePlan).join("\n")
-                    + `\n${options.force ? "备份并替换" : "安装"} ${name}@${version} · ${targets.scope}\n${plan.packages.find(p => p.name === name).targets.join("\n")}`, "安装计划");
-                if (!(await ui.confirm(adoptsDependencies ? "确认接管上述旧依赖并安装此 Skill？" : "是否安装上述 Skill 及其依赖？")))
-                    throw new InstallCancelled();
+            const activeAgents = targets.agents.filter(agent => !decisions.get(agent)?.skip);
+            if (!activeAgents.length) {
+                const installations = targets.agents.map(agent => ({ agent, status: "SKIPPED_EXISTING", message: decisions.get(agent).skip, updateCommand: decisions.get(agent).updateCommand }));
+                await emit(command, { ok: true, installations }, installations.map(item => `${item.agent}: ${item.message}`).join("\n"));
+                return;
             }
-            else
-                await confirmInstall(ui, { ...plan, overwrite: Boolean(options.force) });
-            options.withDependencies = true;
-            options.adoptDependencies = true;
-        }
-        if (dependencyNodes.length)
-            await confirmSkillDependencies(plan, { confirmed: options.withDependencies, json: true });
-        if (adoptsDependencies && !options.adoptDependencies)
-            throw new AiRegistryError("检测到未登记的旧依赖，已核验其发布版本；先查看 --plan，确认接管后使用 --with-dependencies --adopt-dependencies。", "skills_dependency_adoption_required", undefined, undefined, { plan });
-        const choice = await chooseSkillUpdates({ choice: options.updates,
-            eligible: targets.scope === "user" && !options.version && (!options.label || options.label === "latest"),
-            json: !interactive || json });
-        if (dependencyNodes.length && !identity)
-            throw new AiRegistryError("Dependency provenance needs a verified current identity; login and retry.", "skills_dependency_identity_required");
-        if (choice && !identity)
-            throw new Error("Cannot associate update settings with the current identity; run numa login and retry.");
-        const installations = [];
-        for (const agent of targets.agents) {
-            const dependencyInstallations = [];
-            try {
+            const download = await client.downloadSkill(context.namespace.id, name, { version });
+            const graph = await resolveSkillDependencies(client, context.namespace.id, { name, version, download, dependencies: [] });
+            const dependencyNodes = graph.filter(node => node.name !== name);
+            const source = { namespace: context.namespace.namespaceKey, instance: context.namespace.instanceCode,
+                namespaceId: context.namespace.id, instanceId: context.namespace.instanceId };
+            const identity = await maintenanceIdentity(loadConfig("aiRegistry"));
+            const dependencyPlans = new Map();
+            for (const agent of activeAgents) {
                 const target = { agent, scope: targets.scope, workspace: options.workspace, customRoot: options.customRoot, skillName: name };
-                const dependencyPlan = dependencyPlans.get(agent);
-                if (dependencyPlan) {
-                    await applySkillUpdate(dependencyPlan.prepared, dependencyPlan.root, undefined, {});
-                    for (const dep of dependencyPlan.prepared.plan.packages) {
-                        dependencyInstallations.push({ name: dep.name, version: dep.version, path: dep.path, backupPath: dep.backupPath,
-                            status: dep.adopt ? dep.action === "REUSE" ? "ADOPTED" : "ADOPTED_UPDATED" : dep.action === "REUSE" ? "REUSED" : dep.action === "UPDATE" ? "UPDATED" : "INSTALLED" });
-                        await recordSkillInstallation(context, options.workspace, { name: dep.name, version: dep.version, agent,
-                            scope: targets.scope, customRoot: options.customRoot }, dep.version, dep.sha256, dep.path);
+                const rootPath = resolve(skillTargetRoot(target), name);
+                await assertConsumersCompatible(name, version, rootPath);
+                if (dependencyNodes.length) {
+                    const root = { ...source, identity: identity ?? "", name, version, agent, scope: targets.scope,
+                        path: rootPath, workspace: options.workspace, customRoot: options.customRoot, id: "", archiveSha256: download.sha256,
+                        contentDigest: "", updatedAt: 0, policy: "pinned" };
+                    dependencyPlans.set(agent, { root, prepared: await prepareSkillGraph(root, dependencyNodes, client, undefined, graph.find(n => n.name === name)) });
+                }
+            }
+            const plan = { source, scope: targets.scope, agents: activeAgents, packages: graph.map(node => ({
+                    name: node.name, version: node.version, sha256: node.download.sha256, dependencies: node.dependencies,
+                    targets: activeAgents.map(agent => resolve(skillTargetRoot({ agent, scope: targets.scope, workspace: options.workspace, customRoot: options.customRoot }), node.name))
+                })), dependencyTargets: [...dependencyPlans.values()].map(p => p.prepared.plan) };
+            if (options.plan) {
+                await emit(command, { ok: true, plan }, JSON.stringify(plan, null, 2));
+                return;
+            }
+            // Validate/migrate registration before any Skill or dependency is written.
+            await registryProjectForWrite(context, options.workspace);
+            const adoptsDependencies = plan.dependencyTargets.some(p => p.packages.some(d => d.adopt));
+            // Complete arguments skip discovery, but a TTY can still confirm dependencies.
+            const promptDependencies = dependencyNodes.length > 0 && (!options.withDependencies || adoptsDependencies && !options.adoptDependencies)
+                && useInteractive(options, true, json, dependencies.tty);
+            if (interactive || promptDependencies) {
+                if (dependencyNodes.length) {
+                    ui.note(plan.dependencyTargets.map(formatSkillUpdatePlan).join("\n")
+                        + `\n${activeAgents.some(agent => decisions.get(agent)?.force) ? "备份并替换已有目录并安装" : "安装"} ${name}@${version} · ${targets.scope}\n${plan.packages.find(p => p.name === name).targets.join("\n")}`, "安装计划");
+                    if (!(await ui.confirm(adoptsDependencies ? "确认接管上述旧依赖并安装此 Skill？" : "是否安装上述 Skill 及其依赖？")))
+                        throw new InstallCancelled();
+                }
+                else
+                    await confirmInstall(ui, { ...plan, overwriteTargets: activeAgents.filter(agent => decisions.get(agent)?.force) });
+                options.withDependencies = true;
+                options.adoptDependencies = true;
+            }
+            if (dependencyNodes.length)
+                await confirmSkillDependencies(plan, { confirmed: options.withDependencies, json: true });
+            if (adoptsDependencies && !options.adoptDependencies)
+                throw new AiRegistryError("检测到未登记的旧依赖，已核验其发布版本；先查看 --plan，确认接管后使用 --with-dependencies --adopt-dependencies。", "skills_dependency_adoption_required", undefined, undefined, { plan });
+            const choice = await chooseSkillUpdates({ choice: options.updates,
+                eligible: targets.scope === "user" && !options.version && (!options.label || options.label === "latest"),
+                json: !interactive || json });
+            if (dependencyNodes.length && !identity)
+                throw new AiRegistryError("Dependency provenance needs a verified current identity; login and retry.", "skills_dependency_identity_required");
+            if (choice && !identity)
+                throw new Error("Cannot associate update settings with the current identity; run numa login and retry.");
+            const installations = [];
+            for (const agent of targets.agents) {
+                const decision = decisions.get(agent);
+                if (decision.skip) {
+                    installations.push({ agent, status: "SKIPPED_EXISTING", message: decision.skip, updateCommand: decision.updateCommand });
+                    continue;
+                }
+                const dependencyInstallations = [];
+                try {
+                    const target = { agent, scope: targets.scope, workspace: options.workspace, customRoot: options.customRoot, skillName: name };
+                    const dependencyPlan = dependencyPlans.get(agent);
+                    if (dependencyPlan) {
+                        await applySkillUpdate(dependencyPlan.prepared, dependencyPlan.root, undefined, {});
+                        for (const dep of dependencyPlan.prepared.plan.packages) {
+                            dependencyInstallations.push({ name: dep.name, version: dep.version, path: dep.path, backupPath: dep.backupPath,
+                                status: dep.adopt ? dep.action === "REUSE" ? "ADOPTED" : "ADOPTED_UPDATED" : dep.action === "REUSE" ? "REUSED" : dep.action === "UPDATE" ? "UPDATED" : "INSTALLED" });
+                            await recordSkillInstallation(context, options.workspace, { name: dep.name, version: dep.version, agent,
+                                scope: targets.scope, customRoot: options.customRoot }, dep.version, dep.sha256, dep.path);
+                        }
+                    }
+                    await assertInstalledDependencies(download.bytes, resolve(skillTargetRoot(target), name), source);
+                    const result = await installSkillArchive(download.bytes, {
+                        dependencyPlanVerified: true,
+                        agent, scope: targets.scope, skillName: name,
+                        workspace: options.workspace, customRoot: options.customRoot, force: decision.force
+                    });
+                    const lock = await recordSkillInstallation(context, options.workspace, {
+                        name, version: options.version, label: trackedLabel, agent,
+                        scope: targets.scope, customRoot: options.customRoot
+                    }, version, download.sha256, result.installedPath);
+                    const tracking = identity ? await recordManagedSkill({ identity, name, namespace: context.namespace.namespaceKey,
+                        instance: context.namespace.instanceCode, namespaceId: context.namespace.id, instanceId: context.namespace.instanceId,
+                        agent, scope: targets.scope, path: result.installedPath, workspace: options.workspace, customRoot: options.customRoot,
+                        version, archiveSha256: download.sha256, contentDigest: result.contentDigest,
+                        preservePolicy: !choice && !options.version && (!options.label || options.label === "latest"),
+                        policy: choice === "current" ? "latest" : choice === "never" ? "off"
+                            : options.version || options.label && options.label !== "latest" ? "pinned" : "inherit" }) : undefined;
+                    if (choice === "all" || choice === "never")
+                        await updateSkillPreferences(choice);
+                    if (targets.source === "explicit" && targets.agents.length === 1) {
+                        await emit(command, { ok: true, namespace: context.namespace, resolvedVersion: version, dependencyPlan: plan, dependencyInstallations, download: { sha256: download.sha256, fileName: download.fileName }, installation: result, lock,
+                            updateTracking: tracking ? { id: tracking.id, policy: tracking.policy, choice } : { policy: "unregistered" } }, `已安装 ${name}@${version}: ${result.installedPath}${dependencyInstallations.map(d => `\n依赖 ${d.name}@${d.version}: ${{ REUSED: "复用", INSTALLED: "已安装", UPDATED: "已升级", ADOPTED: "已接管", ADOPTED_UPDATED: "已接管并升级" }[d.status]}${d.backupPath ? `（备份：${d.backupPath}）` : ""}`).join("")}${result.backupPath ? `\n原版本备份: ${result.backupPath}` : ""}\n更新策略: ${tracking?.policy ?? "未登记"}${choice ? ` (${choice})` : ""}；numa skills updates status 查看。`);
+                        return;
                     }
+                    installations.push({ agent, status: "INSTALLED", installation: result, lock, dependencyInstallations,
+                        updateTracking: tracking ? { id: tracking.id, policy: tracking.policy, choice } : { policy: "unregistered" } });
                 }
-                await assertInstalledDependencies(download.bytes, resolve(skillTargetRoot(target), name), source);
-                const result = await installSkillArchive(download.bytes, {
-                    dependencyPlanVerified: true,
-                    agent, scope: targets.scope, skillName: name,
-                    workspace: options.workspace, customRoot: options.customRoot, force: options.force
-                });
-                const lock = await recordSkillInstallation(context, options.workspace, {
-                    name, version: options.version, label: trackedLabel, agent,
-                    scope: targets.scope, customRoot: options.customRoot
-                }, version, download.sha256, result.installedPath);
-                const tracking = identity ? await recordManagedSkill({ identity, name, namespace: context.namespace.namespaceKey,
-                    instance: context.namespace.instanceCode, namespaceId: context.namespace.id, instanceId: context.namespace.instanceId,
-                    agent, scope: targets.scope, path: result.installedPath, workspace: options.workspace, customRoot: options.customRoot,
-                    version, archiveSha256: download.sha256, contentDigest: result.contentDigest,
-                    preservePolicy: !choice && !options.version && (!options.label || options.label === "latest"),
-                    policy: choice === "current" ? "latest" : choice === "never" ? "off"
-                        : options.version || options.label && options.label !== "latest" ? "pinned" : "inherit" }) : undefined;
-                if (choice === "all" || choice === "never")
-                    await updateSkillPreferences(choice);
-                if (targets.source === "explicit") {
-                    await output(command, { ok: true, namespace: context.namespace, resolvedVersion: version, dependencyPlan: plan, dependencyInstallations, download: { sha256: download.sha256, fileName: download.fileName }, installation: result, lock,
-                        updateTracking: tracking ? { id: tracking.id, policy: tracking.policy, choice } : { policy: "unregistered" } }, `已安装 ${name}@${version}: ${result.installedPath}${dependencyInstallations.map(d => `\n依赖 ${d.name}@${d.version}: ${{ REUSED: "复用", INSTALLED: "已安装", UPDATED: "已升级", ADOPTED: "已接管", ADOPTED_UPDATED: "已接管并升级" }[d.status]}${d.backupPath ? `（备份：${d.backupPath}）` : ""}`).join("")}${result.backupPath ? `\n原版本备份: ${result.backupPath}` : ""}\n更新策略: ${tracking?.policy ?? "未登记"}${choice ? ` (${choice})` : ""}；numa skills updates status 查看。`);
-                    return;
+                catch (error) {
+                    if (targets.source === "explicit" && targets.agents.length === 1) {
+                        if (!dependencyInstallations.length)
+                            throw error;
+                        throw new AiRegistryError(error instanceof AiRegistryError ? error.message : "Skill installation failed; some dependencies may already be installed.", error instanceof AiRegistryError ? error.code : "skills_install_failed", undefined, undefined, { plan, dependencyInstallations, partial: true });
+                    }
+                    const existing = error instanceof AiRegistryError && error.code === "ai_registry_install_exists";
+                    installations.push({ agent, status: existing ? "SKIPPED_EXISTING" : "FAILED", dependencyInstallations,
+                        code: error instanceof AiRegistryError ? error.code : "skills_install_failed",
+                        message: existing ? "已保留已有文件，未验证其版本；使用 --force 可备份后替换。"
+                            : error instanceof AiRegistryError ? error.message : "安装失败，请检查目标目录后重试。" });
                 }
-                installations.push({ agent, status: "INSTALLED", installation: result, lock, dependencyInstallations,
-                    updateTracking: tracking ? { id: tracking.id, policy: tracking.policy, choice } : { policy: "unregistered" } });
+            }
+            const ok = installations.every((item) => item.status !== "FAILED");
+            await emit(command, { ok, namespace: context.namespace, resolvedVersion: version, dependencyPlan: plan,
+                download: { sha256: download.sha256, fileName: download.fileName }, source: targets.source,
+                scope: targets.scope, installations }, `${name}@${version}（${targets.source === "profile" ? "profile 默认客户端" : "所选客户端"}，${targets.scope}）\n${installations.map((item) => `${item.agent}\t${item.status}\t${"installation" in item ? item.installation?.installedPath : item.message}`).join("\n")}`);
+            if (!ok)
+                process.exitCode = 1;
+        };
+        for (const selected of selections) {
+            try {
+                await installOne(selected.name, { ...options, ...selected.options, scope: selected.options.scope ?? options.scope });
             }
             catch (error) {
-                if (targets.source === "explicit") {
-                    if (!dependencyInstallations.length)
-                        throw error;
-                    throw new AiRegistryError(error instanceof AiRegistryError ? error.message : "Skill installation failed; some dependencies may already be installed.", error instanceof AiRegistryError ? error.code : "skills_install_failed", undefined, undefined, { plan, dependencyInstallations, partial: true });
+                if (selections.length === 1)
+                    throw error;
+                if (error instanceof InstallCancelled) {
+                    results.push({ name: selected.name, result: { ok: false, code: error.code, message: error.message }, text: `${selected.name}: ${error.message}` });
+                    process.exitCode = 1;
+                    break;
                 }
-                const existing = error instanceof AiRegistryError && error.code === "ai_registry_install_exists";
-                installations.push({ agent, status: existing ? "SKIPPED_EXISTING" : "FAILED", dependencyInstallations,
-                    code: error instanceof AiRegistryError ? error.code : "skills_install_failed",
-                    message: existing ? "已保留已有文件，未验证其版本；使用 --force 可备份后替换。"
-                        : error instanceof AiRegistryError ? error.message : "安装失败，请检查目标目录后重试。" });
+                const message = error instanceof AiRegistryError ? error.message : "安装失败，请检查目标目录后重试。";
+                results.push({ name: selected.name, result: { ok: false, code: error instanceof AiRegistryError ? error.code : "skills_install_failed", message }, text: `${selected.name}: ${message}` });
+                process.exitCode = 1;
             }
         }
-        const ok = installations.every((item) => item.status !== "FAILED");
-        await output(command, { ok, namespace: context.namespace, resolvedVersion: version, dependencyPlan: plan,
-            download: { sha256: download.sha256, fileName: download.fileName }, source: targets.source,
-            scope: targets.scope, installations }, `${name}@${version}（profile 默认客户端，${targets.scope}）\n${installations.map((item) => `${item.agent}\t${item.status}\t${"installation" in item ? item.installation?.installedPath : item.message}`).join("\n")}`);
-        if (!ok)
-            process.exitCode = 1;
+        if (selections.length > 1) {
+            const ok = results.every(item => item.result.ok !== false);
+            await output(command, { ok, results: results.map(({ name, result }) => ({ name, result })) }, results.map(item => item.text).join("\n\n"));
+        }
     }), [
         "numa skills install numa-cli",
+        "numa skills install numa-cli numa-notion --agent claude,codex --interactive",
         "numa skills install release-helper --namespace team-ai --agent claude",
         "numa skills install release-helper --namespace team-ai --instance cluster-b --agent cursor --scope user --label latest --json"
     ]);
@@ -635,6 +683,7 @@ export function registerAiRegistryCommands(program, dependencies = {}) {
             await output(command, safeMcpOutput({ ok: true, plan }), JSON.stringify(safeMcpOutput(plan), null, 2));
             return;
         }
+        await registryProjectForWrite(context, options.workspace);
         if (interactive)
             await confirmInstall(ui, plan);
         const result = await installMcpClientDefinition(name, definition, {
@@ -918,7 +967,21 @@ async function registryProjectForWrite(context, workspace) {
         mcpServers: []
     };
     if (manifest.namespaceKey !== context.namespace.namespaceKey || (manifest.instanceCode && manifest.instanceCode !== context.namespace.instanceCode)) {
-        throw new AiRegistryError("Existing registry manifest points to a different namespace binding.", "ai_registry_manifest_namespace_mismatch");
+        // Explicit/interactive selection bypasses project-source resolution. Still
+        // migrate a confirmed historical alias when it matches this authorized target.
+        const migration = manifest.namespaceKey === context.namespace.namespaceKey
+            ? prepareRegistryInstanceMigration({
+                baseUrl: requireProfileService("aiRegistry")?.service.baseUrl,
+                namespace: manifest.namespaceKey, instance: manifest.instanceCode,
+                source: "project", capabilities: context.capabilities
+            }) : undefined;
+        if (existing && migration && migration.to === context.namespace.instanceCode) {
+            await applyRegistryInstanceMigration(existing.files, context.namespace, migration);
+            return registryProjectForWrite(context, workspace);
+        }
+        throw new AiRegistryError(`Registry manifest ${files.manifestPath} binds namespace=${manifest.namespaceKey}, instance=${manifest.instanceCode ?? "(unspecified)"}; ` +
+            `selected namespace=${context.namespace.namespaceKey}, instance=${context.namespace.instanceCode}. ` +
+            "No verified legacy migration matches; existing configuration was preserved.", "ai_registry_manifest_namespace_mismatch");
     }
     const lock = await readRegistryLock(files, false) ?? {
         schemaVersion: 1,