@actiondock/cli 2.14.0 → 2.15.0

package/dist/commands/info.js

@@ -1,10 +1,11 @@
-import { fetchRemoteInfo, } from "@actiondock/core/profile";
+import { isExplicitPath, } from "@actiondock/core";
 import { filterWithFallbackInfo, } from "@actiondock/core/project";
+import { fetchRemoteInfo, } from "@actiondock/core/profile";
 import { getRegistryStatus, resolvePackageRoot, } from "@actiondock/core/registry";
-import { ExecutionError, NO_PROJECT_NO_LINKED_MESSAGE, packageNotFoundError } from "../errors.js";
-import { projectDetailToJson, renderAggregatedPackages, renderProjectDetail, renderRegistryTree, renderResult, } from "../renderer.js";
-import { getProjectDetailInfo, scanLocalAggregatedPackages } from "../services/index.js";
-import { applyTargetOptions, getEffectiveOptions, resolveFallbackStrategy, resolveIntent, resolveTargetFromOptions, } from "../utils/index.js";
+import { ArgumentError, ExecutionError, NO_PROJECT_NO_LINKED_MESSAGE, packageNotFoundError } from "../errors.js";
+import { projectDetailToJson, renderAggregatedPackages, renderCompositeSkillDetail, renderProjectDetail, renderRegistryTree, renderResult, } from "../renderer.js";
+import { buildCompositeDetails, filterProjectDetails, getProjectDetailInfo, scanLocalAggregatedPackages, } from "../services/index.js";
+import { applyTargetOptions, getEffectiveOptions, resolveCommandTarget, resolveFallbackStrategy, resolveIntent, } from "../utils/index.js";
 /**
  * 将远端信息响应归一为本地工程详情视图。
  */
@@ -51,9 +52,49 @@ function remoteInfoToDetail(remoteInfo) {
  * 渲染工程详情输出（机器模式输出视图转换结果，人类模式渲染详情）。
  */
 function renderProjectDetailOutput(detail, options) {
-    renderResult(projectDetailToJson(detail), {
+    const { matchedCount, isFallback } = filterProjectDetails([detail], options.effectiveIntent, Boolean(options.shouldFallback));
+    if (matchedCount === 0 && !isFallback) {
+        if (options.isMachine) {
+            renderResult({ root: detail.projectRoot, packages: [], matchedCount: 0, isFallback: false }, options);
+            return;
+        }
+        throw new ExecutionError(`No packages matched intent '${options.effectiveIntent}'`);
+    }
+    renderResult({
+        ...projectDetailToJson(detail),
+        ...(options.effectiveIntent ? { matchedCount, isFallback } : {}),
+    }, {
+        json: options.json,
+        humanFormatter: () => (isFallback ? `(No packages matched intent '${options.effectiveIntent}', showing selected package)\n\n` : "") +
+            renderProjectDetail(detail),
+        context: options.context,
+    });
+}
+/**
+ * 渲染复合技能整体输出（机器模式输出聚合结构，人类模式渲染各子包卡片）。
+ */
+function renderCompositeSkillOutput(root, details, options) {
+    const outOpts = { json: options.json, context: options.context };
+    const { items: filteredDetails, isFallback, matchedCount } = filterProjectDetails(details, options.effectiveIntent, Boolean(options.shouldFallback));
+    if (options.effectiveIntent && matchedCount === 0 && !isFallback) {
+        if (options.isMachine) {
+            renderResult({ root, packages: [], matchedCount: 0, isFallback: false }, outOpts);
+            return;
+        }
+        throw new ExecutionError(`No packages matched intent '${options.effectiveIntent}' in skill directory`);
+    }
+    if (options.isMachine) {
+        const machineResult = {
+            root,
+            packages: filteredDetails.map(projectDetailToJson),
+            ...(options.effectiveIntent ? { matchedCount, isFallback } : {}),
+        };
+        renderResult(machineResult, outOpts);
+        return;
+    }
+    renderResult(filteredDetails, {
         json: options.json,
-        humanFormatter: () => renderProjectDetail(detail),
+        humanFormatter: () => renderCompositeSkillDetail(root, filteredDetails, isFallback, options.effectiveIntent),
         context: options.context,
     });
 }
@@ -77,18 +118,25 @@ export function registerInfoCommand(program, context) {
         .option("--data-dir <path>", "Custom database storage directory")
         .action(async (patterns = [], rawOptions, cmd) => {
         const options = getEffectiveOptions(rawOptions, cmd);
+        // 唯一显式路径位置参数属于寻址目标，必须先于远端与树状图分支裁决。
+        if (!options.package && !options.intent && patterns.length === 1 && isExplicitPath(patterns[0])) {
+            options.package = patterns[0];
+            patterns = [];
+        }
         const effectiveIntent = resolveIntent(options.intent, patterns);
         const { isMachine, shouldFallback } = resolveFallbackStrategy(options);
         const outOpts = { json: options.json, context };
+        const detailOpts = { ...outOpts, effectiveIntent, shouldFallback, isMachine };
+        // info 仅查询单包清单，复合目录仍保留封闭集合校验。
+        const target = resolveCommandTarget(options, context, { metadataOnly: true });
         // 远端服务目标分支
-        const target = resolveTargetFromOptions(options, context);
-        if (target.type === "remote") {
-            const remoteInfo = await fetchRemoteInfo(target.serverUrl, target.token, {
+        if (target.isRemote) {
+            const remoteInfo = await fetchRemoteInfo(target.resolved.serverUrl, target.resolved.token, {
                 intent: effectiveIntent,
                 package: options.package,
                 tree: Boolean(options.tree),
                 allowInsecureHttp: Boolean(options.allowInsecureHttp),
-                insecure: target.insecure,
+                insecure: target.resolved.insecure,
             });
             if (isMachine) {
                 renderResult(remoteInfo, outOpts);
@@ -116,8 +164,11 @@ export function registerInfoCommand(program, context) {
             });
             return;
         }
-        // 本地注册表树状图分支
+        // 本地注册表树状图分支（若与显式技能或包组合，给出明确 ArgumentError）
         if (options.tree) {
+            if (options.package || target.localSkill) {
+                throw new ArgumentError("Tree view (--tree) is not supported with explicit skill directories or packages; use 'ad info -P <path>' without --tree.");
+            }
             const status = getRegistryStatus(context?.customHome);
             renderResult(status, {
                 json: options.json,
@@ -126,12 +177,30 @@ export function registerInfoCommand(program, context) {
             });
             return;
         }
-        // 显式指定 Package 参数分支
+        // 显式复合技能分支
+        if (target.localSkill?.type === "composite") {
+            const details = await buildCompositeDetails(target.localSkill);
+            renderCompositeSkillOutput(target.localSkill.root, details, {
+                json: options.json,
+                context,
+                effectiveIntent,
+                shouldFallback,
+                isMachine,
+            });
+            return;
+        }
+        // 显式单包技能分支
+        if (target.localSkill?.type === "single") {
+            const pkg = target.localSkill.packages[0];
+            const detail = await getProjectDetailInfo(pkg.packageRoot);
+            renderProjectDetailOutput(detail, detailOpts);
+            return;
+        }
+        // 显式指定 Package 参数分支（普通包 ID 或路径）
         if (options.package) {
-            const directRoot = resolvePackageRoot(options.package);
-            if (directRoot) {
-                const detail = await getProjectDetailInfo(directRoot);
-                renderProjectDetailOutput(detail, outOpts);
+            if (target.targetPackageRoot) {
+                const detail = await getProjectDetailInfo(target.targetPackageRoot);
+                renderProjectDetailOutput(detail, detailOpts);
                 return;
             }
             throw packageNotFoundError(options.package);
@@ -163,8 +232,18 @@ export function registerInfoCommand(program, context) {
         }
         // 有关键字过滤场景：单一位置参数且非显式 --intent 时优先尝试包寻址
         if (patterns.length === 1 && !options.intent) {
-            const directRoot = resolvePackageRoot(patterns[0]);
+            const directRoot = resolvePackageRoot(patterns[0], undefined, context?.customHome);
             if (directRoot) {
+                const directTarget = resolveCommandTarget({ ...options, package: directRoot }, context, { metadataOnly: true });
+                if (directTarget.localSkill?.type === "composite") {
+                    const details = await buildCompositeDetails(directTarget.localSkill);
+                    renderCompositeSkillOutput(directTarget.localSkill.root, details, {
+                        ...outOpts,
+                        shouldFallback,
+                        isMachine,
+                    });
+                    return;
+                }
                 const detail = await getProjectDetailInfo(directRoot);
                 renderProjectDetailOutput(detail, outOpts);
                 return;

package/dist/commands/playbook.js

@@ -1,13 +1,13 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
-import { assertPathWithinRoot, loadActions, loadManifest, loadPlaybooks, saveManifest, filterWithFallbackInfo, } from "@actiondock/core/project";
-import { DefaultActionCatalog, PackageGraphBuilder, resolveAction, resolvePlaybook, } from "@actiondock/core/graph";
+import { assertPathWithinRoot, loadManifest, loadPlaybooks, saveManifest, filterWithFallbackInfo, } from "@actiondock/core/project";
+import { DefaultActionCatalog, resolveAction, resolvePlaybook, } from "@actiondock/core/graph";
 import { fetchRemotePlaybooks, fetchRemotePlaybookShow, } from "@actiondock/core/profile";
 import { loadProjectConfig, } from "@actiondock/core";
 import { listLinkedPackages, } from "@actiondock/core/registry";
 import { ArgumentError, CliError, ExecutionError, NO_PROJECT_NO_LINKED_MESSAGE, wrapAsExecutionError, } from "../errors.js";
-import { renderPlaybookDetail, renderPlaybookList, renderResult, writeStdout, } from "../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, remoteTargetSuffix, requirePackageRoot, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, resolveTargetFromOptions, } from "../utils/index.js";
+import { renderPlaybookDetail, renderPlaybookList, renderResult, writeStderr, writeStdout, } from "../renderer.js";
+import { applyTargetOptions, buildScopedPackageGraph, getEffectiveOptions, remoteTargetSuffix, requirePackageRoot, resolveCommandTarget, resolveFallbackStrategy, resolveIntent, } from "../utils/index.js";
 /**
  * 注册 Playbook 命令集合（list, show, validate, create）。
  *
@@ -34,14 +34,15 @@ export function registerPlaybookCommands(program, context) {
         const hints = [
             "Tip: Run 'ad playbook show <id>' to inspect procedure steps before execution.",
         ];
-        // 1. 远端服务分支
-        const target = resolveTargetFromOptions(options, context);
-        if (target.type === "remote") {
-            const remotePbs = await fetchRemotePlaybooks(target.serverUrl, target.token, {
+        // 1. 目标拓扑统一解析
+        const target = resolveCommandTarget(options, context);
+        // 2. 远端服务分支
+        if (target.isRemote) {
+            const remotePbs = await fetchRemotePlaybooks(target.resolved.serverUrl, target.resolved.token, {
                 intent: effectiveIntent,
                 package: options.package,
                 allowInsecureHttp: Boolean(options.allowInsecureHttp),
-                insecure: target.insecure,
+                insecure: target.resolved.insecure,
             });
             if (isMachine) {
                 renderResult({ items: remotePbs, hints }, { json: options.json, context });
@@ -49,24 +50,44 @@ export function registerPlaybookCommands(program, context) {
             }
             renderResult(remotePbs, {
                 json: options.json,
-                humanFormatter: () => renderPlaybookList(remotePbs, `Playbooks ${remoteTargetSuffix(target)}`, false, effectiveIntent),
+                humanFormatter: () => renderPlaybookList(remotePbs, `Playbooks ${remoteTargetSuffix(target.resolved)}`, false, effectiveIntent),
                 context,
             });
             return;
         }
-        // 2. 本地工程模式
-        const targetRoot = options.package
-            ? requirePackageRoot(options.package).root
-            : resolveLocalPackageRoot();
-        if (targetRoot) {
-            const config = loadProjectConfig(targetRoot);
-            const playbooks = loadPlaybooks(targetRoot, config.playbooksDir);
-            const rawList = Array.from(playbooks.values()).map((pb) => ({
-                id: pb.id,
-                description: pb.description,
-                packageId: config.id,
-            }));
-            const filterRes = filterWithFallbackInfo(rawList, effectiveIntent, [(p) => p.id, (p) => p.description], shouldFallback);
+        // 3. 本地模式（单包技能、复合技能或本地工程）
+        if (target.localSkill || target.targetPackageRoot) {
+            const rawList = [];
+            let title;
+            if (target.localSkill) {
+                const isComposite = target.localSkill.type === "composite";
+                for (const pkg of target.localSkill.packages) {
+                    const playbooks = loadPlaybooks(pkg.packageRoot, pkg.projectConfig.playbooksDir, pkg.projectConfig);
+                    for (const pb of playbooks.values()) {
+                        rawList.push({
+                            id: isComposite ? `${pkg.packageId}/${pb.id}` : pb.id,
+                            description: pb.description,
+                            packageId: pkg.packageId,
+                        });
+                    }
+                }
+                title = isComposite
+                    ? `Playbooks in ${options.package || target.localSkill.root}`
+                    : `Playbooks in ${target.localSkill.packages[0].packageId} (${target.localSkill.packages[0].packageRoot})`;
+            }
+            else {
+                const config = loadProjectConfig(target.targetPackageRoot);
+                const playbooks = loadPlaybooks(target.targetPackageRoot, config.playbooksDir, config);
+                for (const pb of playbooks.values()) {
+                    rawList.push({
+                        id: pb.id,
+                        description: pb.description,
+                        packageId: config.id,
+                    });
+                }
+                title = `Playbooks in ${config.id} (${target.targetPackageRoot})`;
+            }
+            const filterRes = filterWithFallbackInfo(rawList, effectiveIntent, [(p) => p.id, (p) => p.description || ""], shouldFallback);
             if (isMachine) {
                 if (filterRes.isFallback) {
                     renderResult({ items: filterRes.items, isFallback: true, matchedCount: 0, hints }, { json: options.json, context });
@@ -81,7 +102,7 @@ export function registerPlaybookCommands(program, context) {
             }
             renderResult(filterRes.items, {
                 json: options.json,
-                humanFormatter: () => renderPlaybookList(filterRes.items, `Playbooks in ${config.id} (${targetRoot})`, filterRes.isFallback, effectiveIntent),
+                humanFormatter: () => renderPlaybookList(filterRes.items, title, filterRes.isFallback, effectiveIntent),
                 context,
             });
             return;
@@ -102,25 +123,22 @@ export function registerPlaybookCommands(program, context) {
         }
         const aggregated = [];
         for (const pkg of linkedList) {
-            if (!existsSync(pkg.path))
+            if (!existsSync(pkg.path)) {
+                writeStderr(`Skipping inaccessible linked package '${pkg.id}' at '${pkg.path}'`, context);
                 continue;
-            try {
-                const config = loadProjectConfig(pkg.path);
-                const pbs = loadPlaybooks(pkg.path, config.playbooksDir);
-                const list = Array.from(pbs.values()).map((p) => ({
-                    id: p.id,
-                    description: p.description,
-                }));
-                aggregated.push({
-                    packageId: pkg.id,
-                    packageName: pkg.name,
-                    path: pkg.path,
-                    playbooks: list,
-                });
-            }
-            catch {
-                // 单个链接包清单损坏或 Playbook 加载失败时跳过，继续聚合其余包
             }
+            const config = loadProjectConfig(pkg.path);
+            const pbs = loadPlaybooks(pkg.path, config.playbooksDir, config);
+            const list = Array.from(pbs.values()).map((p) => ({
+                id: p.id,
+                description: p.description,
+            }));
+            aggregated.push({
+                packageId: pkg.id,
+                packageName: pkg.name,
+                path: pkg.path,
+                playbooks: list,
+            });
         }
         let filteredPackages = [];
         let isFallback = false;
@@ -183,13 +201,14 @@ export function registerPlaybookCommands(program, context) {
         if (!id) {
             throw new ArgumentError("Playbook ID is required for show");
         }
-        // 1. 远端服务分支
-        const target = resolveTargetFromOptions(options, context);
-        if (target.type === "remote") {
+        // 1. 目标拓扑统一解析
+        const target = resolveCommandTarget(options, context);
+        // 2. 远端服务分支
+        if (target.isRemote) {
             try {
-                const detail = await fetchRemotePlaybookShow(target.serverUrl, id, target.token, {
+                const detail = await fetchRemotePlaybookShow(target.resolved.serverUrl, target.resolvePlaybookRef(id), target.resolved.token, {
                     allowInsecureHttp: Boolean(options.allowInsecureHttp),
-                    insecure: target.insecure,
+                    insecure: target.resolved.insecure,
                 });
                 renderResult(detail, {
                     json: options.json,
@@ -203,20 +222,15 @@ export function registerPlaybookCommands(program, context) {
                 throw new ArgumentError(`${err.message}\n${hint}`, err?.details, err?.code, hint);
             }
         }
-        // 2. 本地项目模式
-        let showTarget = id;
-        if (options.package && !id.includes("/")) {
-            requirePackageRoot(options.package);
-            showTarget = `${options.package}/${id}`;
-        }
+        // 3. 本地分支（单包技能、复合技能、本地工程或已链接包）
+        const showTarget = target.resolvePlaybookRef(id);
         let resolved;
         try {
-            const graph = new PackageGraphBuilder({
-                root: resolveLocalPackageRoot() || undefined,
-                customHome: context?.customHome,
-                allowDevLinks: true,
-            }).buildSync();
-            resolved = resolvePlaybook(showTarget, { graph });
+            const graph = buildScopedPackageGraph(target, context);
+            const caller = target.localSkill
+                ? (target.localSkill.type === "single" ? target.localSkill.packages[0].packageId : undefined)
+                : (target.targetPackageRoot ? loadProjectConfig(target.targetPackageRoot).id : undefined);
+            resolved = resolvePlaybook(showTarget, { graph, caller });
         }
         catch (err) {
             const hint = "Tip: Run 'ad playbook list' to discover available playbooks.";
@@ -249,36 +263,73 @@ export function registerPlaybookCommands(program, context) {
         .option("--json", "Output as JSON")
         .action(async (id, rawOptions, cmd) => {
         const options = getEffectiveOptions(rawOptions, cmd);
-        const root = options.package
-            ? requirePackageRoot(options.package).root
-            : resolveLocalPackageRoot();
+        // 保持本地校验定位，profile 始终为 local
+        const target = resolveCommandTarget({ ...options, profile: "local" }, context);
+        const graph = buildScopedPackageGraph(target, context);
+        const catalog = new DefaultActionCatalog(graph);
         const targets = [];
-        if (root) {
+        if (target.localSkill) {
+            if (id) {
+                const showTarget = target.resolvePlaybookRef(id);
+                const caller = target.localSkill.type === "single" ? target.localSkill.packages[0].packageId : undefined;
+                let resolved;
+                try {
+                    resolved = resolvePlaybook(showTarget, { graph, caller });
+                }
+                catch (err) {
+                    throw new ArgumentError(err.message, err?.details, err?.code);
+                }
+                targets.push({
+                    root: resolved.projectRoot,
+                    packageId: resolved.packageId,
+                    playbooks: [resolved.playbook],
+                });
+            }
+            else {
+                for (const pkg of target.localSkill.packages) {
+                    const playbooks = loadPlaybooks(pkg.packageRoot, pkg.projectConfig.playbooksDir);
+                    targets.push({
+                        root: pkg.packageRoot,
+                        packageId: pkg.packageId,
+                        playbooks: Array.from(playbooks.values()),
+                    });
+                }
+            }
+        }
+        else if (target.targetPackageRoot) {
+            const root = target.targetPackageRoot;
             const config = loadProjectConfig(root);
-            const playbooks = loadPlaybooks(root, config.playbooksDir);
             if (id) {
-                const pb = playbooks.get(id);
-                if (!pb) {
-                    throw new ArgumentError(`Playbook '${id}' not found in package '${config.id}'`);
+                const showTarget = target.resolvePlaybookRef(id);
+                let resolved;
+                try {
+                    resolved = resolvePlaybook(showTarget, { graph, caller: config.id });
                 }
-                targets.push({ root, packageId: config.id, playbooks: [pb] });
+                catch (err) {
+                    throw new ArgumentError(err.message, err?.details, err?.code);
+                }
+                targets.push({
+                    root: resolved.projectRoot,
+                    packageId: resolved.packageId,
+                    playbooks: [resolved.playbook],
+                });
             }
             else {
-                targets.push({ root, packageId: config.id, playbooks: Array.from(playbooks.values()) });
+                const playbooks = loadPlaybooks(root, config.playbooksDir);
+                targets.push({
+                    root,
+                    packageId: config.id,
+                    playbooks: Array.from(playbooks.values()),
+                });
             }
         }
         else if (id) {
             let resolved;
             try {
-                const graph = new PackageGraphBuilder({
-                    root: resolveLocalPackageRoot() || undefined,
-                    customHome: context?.customHome,
-                    allowDevLinks: true,
-                }).buildSync();
                 resolved = resolvePlaybook(id, { graph });
             }
             catch (err) {
-                throw new ArgumentError(err.message);
+                throw new ArgumentError(err.message, err?.details, err?.code);
             }
             targets.push({
                 root: resolved.projectRoot,
@@ -292,34 +343,22 @@ export function registerPlaybookCommands(program, context) {
                 throw new ArgumentError(`${NO_PROJECT_NO_LINKED_MESSAGE} Please run 'ad link' inside a package first.`);
             }
             for (const pkg of linkedList) {
-                if (!existsSync(pkg.path))
+                if (!existsSync(pkg.path)) {
+                    writeStderr(`Skipping inaccessible linked package '${pkg.id}' at '${pkg.path}'`, context);
                     continue;
-                try {
-                    const config = loadProjectConfig(pkg.path);
-                    const playbooks = loadPlaybooks(pkg.path, config.playbooksDir);
-                    targets.push({
-                        root: pkg.path,
-                        packageId: pkg.id,
-                        playbooks: Array.from(playbooks.values()),
-                    });
-                }
-                catch {
-                    // 单个链接包清单损坏或 Playbook 加载失败时跳过，不阻断整体校验
                 }
+                const config = loadProjectConfig(pkg.path);
+                const playbooks = loadPlaybooks(pkg.path, config.playbooksDir, config);
+                targets.push({
+                    root: pkg.path,
+                    packageId: pkg.id,
+                    playbooks: Array.from(playbooks.values()),
+                });
             }
         }
         const results = [];
-        const graph = new PackageGraphBuilder({
-            root: resolveLocalPackageRoot() || undefined,
-            customHome: context?.customHome,
-            allowDevLinks: true,
-        }).buildSync();
-        const catalog = new DefaultActionCatalog(graph);
-        for (const target of targets) {
-            const config = loadProjectConfig(target.root);
-            const manifest = loadManifest(target.root);
-            const actions = await loadActions(target.root, config.actionsDir);
-            for (const pb of target.playbooks) {
+        for (const targetItem of targets) {
+            for (const pb of targetItem.playbooks) {
                 const warnings = [];
                 const errors = [];
                 if (!pb.id) {
@@ -330,26 +369,30 @@ export function registerPlaybookCommands(program, context) {
                 }
                 if (pb.actions && Array.isArray(pb.actions)) {
                     for (const actRef of pb.actions) {
-                        if (actRef.includes("/")) {
+                        if (typeof actRef !== "string" || !actRef.trim()) {
+                            errors.push(`Referenced action must be a non-empty string, received ${JSON.stringify(actRef)}`);
+                            continue;
+                        }
+                        const trimmed = actRef.trim();
+                        if (trimmed.includes("/")) {
                             try {
-                                resolveAction(actRef, { graph, catalog, caller: target.packageId });
+                                resolveAction(trimmed, { graph, catalog, caller: targetItem.packageId });
                             }
                             catch (e) {
-                                errors.push(`Referenced cross-package action '${actRef}' not resolvable: ${e.message}. Hint: Action '${actRef}' not found. Run 'ad action create ${actRef}' to create local action, or 'ad add <pkg>' to install external dependency.`);
+                                errors.push(`Referenced cross-package action '${trimmed}' not resolvable: ${e.message}. Hint: Action '${trimmed}' not found. Run 'ad action create ${trimmed}' to create local action, or 'ad add <pkg>' to install external dependency.`);
                             }
                         }
                         else {
-                            const foundInActions = actions.has(actRef);
-                            const foundInManifest = Boolean(manifest?.actions?.[actRef]);
-                            if (!foundInActions && !foundInManifest) {
-                                errors.push(`Referenced action '${actRef}' not found in project actions. Hint: Action '${actRef}' not found. Run 'ad action create ${actRef}' to create local action, or 'ad add <pkg>' to install external dependency.`);
+                            // 短引用只接受所属包清单登记的 Action，不能由源码文件或其他包补位。
+                            if (!catalog.get(targetItem.packageId, trimmed)) {
+                                errors.push(`Referenced action '${trimmed}' not found in project actions. Hint: Action '${trimmed}' not found. Run 'ad action create ${trimmed}' to create local action, or 'ad add <pkg>' to install external dependency.`);
                             }
                         }
                     }
                 }
                 results.push({
                     id: pb.id,
-                    packageId: target.packageId,
+                    packageId: targetItem.packageId,
                     valid: errors.length === 0,
                     warnings,
                     errors,

package/dist/renderers/project.d.ts

@@ -43,3 +43,7 @@ export type RegistryTreeView = RegistryStatusReport | (Record<string, unknown> &
  * 格式化渲染注册表层级树结构。
  */
 export declare function renderRegistryTree(status: RegistryTreeView): string;
+/**
+ * 格式化渲染复合技能各子包的自省卡片列表。
+ */
+export declare function renderCompositeSkillDetail(root: string, filteredDetails: ProjectDetailInfo[], isFallback?: boolean, effectiveIntent?: string): string;

package/dist/renderers/project.js

@@ -194,3 +194,19 @@ export function renderRegistryTree(status) {
     }
     return lines.join("\n");
 }
+/**
+ * 格式化渲染复合技能各子包的自省卡片列表。
+ */
+export function renderCompositeSkillDetail(root, filteredDetails, isFallback, effectiveIntent) {
+    const lines = [];
+    if (isFallback) {
+        lines.push(`(No packages in skill matched intent '${effectiveIntent}', showing all packages)\n`);
+    }
+    lines.push(`ActionDock Composite Skill: ${root}`);
+    lines.push(`Packages (${filteredDetails.length}):\n`);
+    for (const d of filteredDetails) {
+        lines.push(renderProjectDetail(d));
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+}

package/dist/services/inspect.d.ts

@@ -1,3 +1,4 @@
+import { type LocalSkillDirectory } from "@actiondock/core/project";
 import type { AggregatedPackage, CliContext, ProjectDetailInfo } from "../types.js";
 /**
  * 装配单个工程的详情自省信息（清单、动作映射与 Playbook 映射）。
@@ -5,6 +6,18 @@ import type { AggregatedPackage, CliContext, ProjectDetailInfo } from "../types.
  * @param root 工程根目录
  */
 export declare function getProjectDetailInfo(root: string): Promise<ProjectDetailInfo>;
+/**
+ * 装配复合技能各子包的自省详情，将 Action 与 Playbook 的调用索引提升为完全限定 ID。
+ */
+export declare function buildCompositeDetails(localSkill: LocalSkillDirectory): Promise<ProjectDetailInfo[]>;
+/**
+ * 单包与复合技能共享相同的详情过滤规则（单一事实源）。
+ */
+export declare function filterProjectDetails(details: ProjectDetailInfo[], effectiveIntent?: string, shouldFallback?: boolean): {
+    items: ProjectDetailInfo[];
+    matchedCount: number;
+    isFallback: boolean;
+};
 /**
  * 装配单个包的摘要聚合信息（不含动作与 Playbook 明细映射）。
  *
@@ -13,7 +26,7 @@ export declare function getProjectDetailInfo(root: string): Promise<ProjectDetai
 export declare function getPackageSummary(root: string): AggregatedPackage;
 /**
  * 扫描本地候选包集合（当前工程根目录优先，叠加全局已链接包，按物理路径去重）。
- * 清单损坏或磁盘失效的候选项跳过，不影响其余条目聚合。
+ * 失效或损坏链接给出明确诊断记录，不静默吞没也不中断其余条目聚合。
  *
  * @param context CLI 上下文（提供 customHome 定位全局注册表）
  */

package/dist/services/inspect.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { findProjectRoot, loadProjectConfig, } from "@actiondock/core";
 import { listLinkedPackages, } from "@actiondock/core/registry";
-import { loadManifest, loadPlaybooks, } from "@actiondock/core/project";
+import { filterWithFallbackInfo, loadManifest, loadPlaybooks, } from "@actiondock/core/project";
 /**
  * 装配单个工程的详情自省信息（清单、动作映射与 Playbook 映射）。
  *
@@ -38,6 +38,51 @@ export async function getProjectDetailInfo(root) {
         playbooksMap: playbooks,
     };
 }
+/**
+ * 装配复合技能各子包的自省详情，将 Action 与 Playbook 的调用索引提升为完全限定 ID。
+ */
+export async function buildCompositeDetails(localSkill) {
+    const details = [];
+    for (const pkg of localSkill.packages) {
+        const detail = await getProjectDetailInfo(pkg.packageRoot);
+        const qualifiedActionsMap = new Map();
+        if (detail.actionsMap) {
+            for (const [actId, act] of detail.actionsMap.entries()) {
+                const fullId = `${pkg.packageId}/${actId}`;
+                qualifiedActionsMap.set(fullId, { id: fullId, description: act.description });
+            }
+        }
+        const qualifiedPlaybooksMap = new Map();
+        if (detail.playbooksMap) {
+            for (const [pbId, pb] of detail.playbooksMap.entries()) {
+                const fullId = `${pkg.packageId}/${pbId}`;
+                qualifiedPlaybooksMap.set(fullId, { ...pb, id: fullId });
+            }
+        }
+        detail.actionsMap = qualifiedActionsMap;
+        detail.actions = Array.from(qualifiedActionsMap.keys());
+        detail.playbooksMap = qualifiedPlaybooksMap;
+        detail.playbooks = Array.from(qualifiedPlaybooksMap.keys());
+        details.push(detail);
+    }
+    return details;
+}
+/**
+ * 单包与复合技能共享相同的详情过滤规则（单一事实源）。
+ */
+export function filterProjectDetails(details, effectiveIntent, shouldFallback = false) {
+    if (!effectiveIntent) {
+        return { items: details, matchedCount: details.length, isFallback: false };
+    }
+    return filterWithFallbackInfo(details, effectiveIntent, [
+        (d) => d.id,
+        (d) => d.name,
+        (d) => d.description || "",
+        (d) => d.projectRoot,
+        (d) => d.actions.join(" "),
+        (d) => d.playbooks.join(" "),
+    ], Boolean(shouldFallback));
+}
 /**
  * 装配单个包的摘要聚合信息（不含动作与 Playbook 明细映射）。
  *
@@ -63,7 +108,7 @@ export function getPackageSummary(root) {
 }
 /**
  * 扫描本地候选包集合（当前工程根目录优先，叠加全局已链接包，按物理路径去重）。
- * 清单损坏或磁盘失效的候选项跳过，不影响其余条目聚合。
+ * 失效或损坏链接给出明确诊断记录，不静默吞没也不中断其余条目聚合。
  *
  * @param context CLI 上下文（提供 customHome 定位全局注册表）
  */
@@ -73,25 +118,22 @@ export function scanLocalAggregatedPackages(context) {
     const aggregated = [];
     const seenPaths = new Set();
     if (currentRoot) {
-        try {
-            aggregated.push(getPackageSummary(currentRoot));
-            seenPaths.add(currentRoot);
-        }
-        catch {
-            // 忽略异常工程根目录（清单损坏）
-        }
+        aggregated.push(getPackageSummary(currentRoot));
+        seenPaths.add(currentRoot);
     }
     for (const pkg of linkedList) {
-        if (!existsSync(pkg.path))
+        if (!existsSync(pkg.path)) {
+            process.stderr.write(`[actiondock] Diagnostic: Skipping inaccessible linked package '${pkg.id}' at '${pkg.path}'\n`);
             continue;
+        }
         if (seenPaths.has(pkg.path))
             continue;
         try {
             aggregated.push(getPackageSummary(pkg.path));
             seenPaths.add(pkg.path);
         }
-        catch {
-            // 忽略失效链接（清单损坏或磁盘异常）
+        catch (err) {
+            process.stderr.write(`[actiondock] Diagnostic: Skipping invalid linked package '${pkg.id}' at '${pkg.path}': ${err?.message || String(err)}\n`);
         }
     }
     return { currentRoot, aggregated };

package/dist/utils/target.d.ts

@@ -1,5 +1,6 @@
 import { loadProjectConfig, type ActionDockService, type LocalSkillDirectory } from "@actiondock/core";
 import { type ResolvedTarget } from "@actiondock/core/profile";
+import { type PackageGraph } from "@actiondock/core/graph";
 import type { Command } from "commander";
 import type { CliContext } from "../types.js";
 /**
@@ -30,6 +31,10 @@ export interface TargetResolutionOptions {
     /** 是否允许向非回环地址发送明文 HTTP 请求（对应 --allow-insecure-http） */
     allowInsecureHttp?: boolean;
 }
+/** 仅供清单查询使用的内部解析策略；执行命令默认保持封闭校验。 */
+export interface TargetResolutionStrategy {
+    readonly metadataOnly?: boolean;
+}
 /**
  * 目标拓扑解析单一入口：从命令选项视图解析远端/本地目标拓扑信息。
  *
@@ -44,9 +49,37 @@ export interface TargetResolutionOptions {
  *
  * @param options 命令选项视图（支持直接传入 Commander 解析后的 options 对象）
  * @param context CLI 上下文
+ * @param strategy 内部解析策略；仅清单查询可跳过单包闭包校验
  * @returns 解析后的目标拓扑信息（仅信息解析，不创建 Service 实例）
  */
-export declare function resolveTargetFromOptions(options: TargetResolutionOptions, context?: CliContext): ResolvedTarget;
+export declare function resolveTargetFromOptions(options: TargetResolutionOptions, context?: CliContext, strategy?: TargetResolutionStrategy): ResolvedTarget;
+/**
+ * 统一计算目标资源引用（Action 或 Playbook）的辅助函数（单一事实源）。
+ *
+ * 规则：
+ * - 远端分支：options.package 存在且资源标识未限定时，前缀拼接 options.package；
+ * - 本地单包技能：资源标识未限定时，前缀拼接真实 packageId（而非路径目录名）；
+ * - 本地复合技能：保持短名，供后续图解析裁决唯一匹配或多包歧义；完全限定名直接透传；
+ * - 普通工程包：非技能且 options.package 存在时，未限定则拼接 options.package。
+ *
+ * @param resourceId 资源标识符（动作名或规程名）
+ * @param options 命令选项视图
+ * @param localSkill 本地技能目录视图
+ */
+export declare function resolveResourceRef(resourceId: string, options: TargetResolutionOptions, localSkill?: LocalSkillDirectory | null): string;
+/**
+ * 统一计算目标 Playbook 引用的辅助函数。
+ */
+export declare function resolvePlaybookRef(playbookId: string, options: TargetResolutionOptions, localSkill?: LocalSkillDirectory | null): string;
+/**
+ * 构造与目标作用域严格对应的 PackageGraph（单一事实源）。
+ *
+ * 封闭保证：
+ * - 当目标为 LocalSkillDirectory 时，仅以 localSkill.packages 显式包集合构建封闭图；
+ *   绝不扫描 cwd 也不扫描全局 Registry/开发软链，防止外部同名包或污染泄漏；
+ * - 当目标为普通本地工程或包 ID 时，维持原有的基于项目根与全局链接表的拓扑图构建模式。
+ */
+export declare function buildScopedPackageGraph(target: CommandTargetResolution, context?: CliContext): PackageGraph;
 /**
  * 命令目标与动作引用解析结果。
  */
@@ -55,12 +88,14 @@ export interface CommandTargetResolution {
     resolved: ResolvedTarget;
     /** 是否为远端目标 */
     isRemote: boolean;
-    /** 本地封闭技能目录视图（非本地技能目录时为 null） */
+    /** 本地技能目录或单包元数据作用域（未寻址本地包时为 null） */
     localSkill: LocalSkillDirectory | null;
     /** 本地包根目录路径（远端分支为 undefined，未找到为 undefined） */
     targetPackageRoot?: string;
     /** 统一计算目标 Action 引用的辅助函数 */
     resolveActionRef: (actionId: string) => string;
+    /** 统一计算目标 Playbook 引用的辅助函数 */
+    resolvePlaybookRef: (playbookId: string) => string;
 }
 /**
  * 统一解析 CLI 命令的目标拓扑与包作用域（run, describe, list 等命令的单一事实源）。
@@ -68,10 +103,11 @@ export interface CommandTargetResolution {
  * 保证：
  * - 优先判定目标拓扑；
  * - 远端目标（remote）完全隔离：不执行任何本地目录探测、清单加载或包根寻址；
- * - 远端目标动作引用保持原始词法包 ID 拼接（${options.package}/${actionId}），绝不被本地同名目录或清单 ID 篡改；
- * - 本地目标按本地封闭技能目录或工程包严格解析，不存在时透明抛出 packageNotFoundError。
+ * - 远端目标动作与规程引用保持原始词法包 ID 拼接（${options.package}/${id}），绝不被本地同名目录或清单 ID 篡改；
+ * - 本地目标默认按封闭技能目录或工程包严格解析；元数据策略仅跳过单包闭包校验；
+ * - 显式目标不存在时透明抛出 packageNotFoundError。
  */
-export declare function resolveCommandTarget(options: TargetResolutionOptions, context?: CliContext): CommandTargetResolution;
+export declare function resolveCommandTarget(options: TargetResolutionOptions, context?: CliContext, strategy?: TargetResolutionStrategy): CommandTargetResolution;
 /**
  * 配置与状态管理目标作用域。
  */

package/dist/utils/target.js

@@ -1,6 +1,7 @@
-import { connectActionDock, createActionDock, createNodePlatform, findProjectRoot, inspectLocalPackageDirectory, isExplicitPath, loadProjectConfig, } from "@actiondock/core";
+import { connectActionDock, createActionDock, createNodePlatform, findProjectRoot, inspectLocalPackageDirectory, isExplicitPath, loadProjectConfig, queryLocalPackageDirectory, } from "@actiondock/core";
 import { resolvePackageRoot, } from "@actiondock/core/registry";
 import { resolveTarget, } from "@actiondock/core/profile";
+import { PackageGraphBuilder, } from "@actiondock/core/graph";
 import { ArgumentError, packageNotFoundError } from "../errors.js";
 /**
  * 统一为 Commander 命令节点挂载目标环境解析相关选项（单一事实源）。
@@ -17,23 +18,20 @@ export function applyTargetOptions(command) {
         .option("-k, --insecure", "Allow insecure server connections (skip TLS certificate validation)")
         .option("--allow-insecure-http", "Allow sending auth token over unencrypted HTTP to non-loopback hosts");
 }
+/** 本地寻址策略只有一个实现入口，查询与严格闭包均委托核心目录能力。 */
+function inspectCommandDirectory(packageOption, context, strategy) {
+    if (!strategy?.metadataOnly)
+        return inspectLocalPackageDirectory(packageOption);
+    const directory = queryLocalPackageDirectory(packageOption);
+    if (directory)
+        return directory;
+    const root = resolvePackageRoot(packageOption, undefined, context?.customHome);
+    return root ? queryLocalPackageDirectory(root) : null;
+}
 /**
- * 目标拓扑解析单一入口：从命令选项视图解析远端/本地目标拓扑信息。
- *
- * 显式路径与包标识符分类规则：
- * - 显式路径形态（以 .、/、~ 开头或包含非 scoped 分隔符）：
- *   严格作为本地技能或包目录解析；禁止与显式远端选项（--server 或非 local 的 --profile）组合，违规抛出 ArgumentError；
- *   不受隐式 Profile 或 ACTIONDOCK_SERVER_URL 环境变量改变目标，本地执行优先；
- *   若本地目录不存在或不合法，抛出 packageNotFoundError；
- * - 纯词法包标识符（如 pkg.a、@scope/pkg）：
- *   若存在远端目标（显式 --server、非 local profile 或默认远端环境），严格作为远端包标识解析，绝不因本地 cwd 存在同名目录而劫持为本地执行；
- *   若无远端目标，正常按本地目标解析。
- *
- * @param options 命令选项视图（支持直接传入 Commander 解析后的 options 对象）
- * @param context CLI 上下文
- * @returns 解析后的目标拓扑信息（仅信息解析，不创建 Service 实例）
+ * 内部统一解析目标拓扑与包作用域，单次调用闭包完成全部发现，无跨调用缓存。
  */
-export function resolveTargetFromOptions(options, context) {
+function resolveCommandTargetInternal(options, context, strategy) {
     const isExplicit = options.package ? isExplicitPath(options.package) : false;
     if (isExplicit) {
         const hasExplicitServer = Boolean(options.server && options.server.trim());
@@ -41,22 +39,138 @@ export function resolveTargetFromOptions(options, context) {
         if (hasExplicitServer || hasExplicitProfile) {
             throw new ArgumentError("Cannot combine local package/skill directory with remote target options (--server or --profile). Specify a package ID for remote targets, or remove remote target options for local directory execution.");
         }
-        const localSkill = inspectLocalPackageDirectory(options.package);
+        const localSkill = inspectCommandDirectory(options.package, context, strategy);
         if (!localSkill) {
             throw packageNotFoundError(options.package);
         }
         return {
-            type: "local",
-            profileName: "local",
+            resolved: {
+                type: "local",
+                profileName: "local",
+            },
+            localSkill,
+            targetPackageRoot: localSkill.root,
         };
     }
-    return resolveTarget({
+    const resolved = resolveTarget({
         profile: options.profile,
         server: options.server,
         token: options.token,
         insecure: options.insecure,
         allowInsecureHttp: options.allowInsecureHttp,
     }, context?.customHome);
+    if (resolved.type === "remote") {
+        return {
+            resolved,
+            localSkill: null,
+            targetPackageRoot: undefined,
+        };
+    }
+    // 本地分支（options.package 为短名或未传）
+    if (options.package) {
+        const localSkill = inspectCommandDirectory(options.package, context, strategy);
+        const targetPackageRoot = localSkill
+            ? localSkill.root
+            : strategy?.metadataOnly
+                ? resolvePackageRoot(options.package, undefined, context?.customHome)
+                : resolveLocalPackageRoot(options.package);
+        if (!targetPackageRoot) {
+            throw packageNotFoundError(options.package);
+        }
+        return {
+            resolved,
+            localSkill,
+            targetPackageRoot,
+        };
+    }
+    const projectRoot = findProjectRoot();
+    return {
+        resolved,
+        localSkill: null,
+        targetPackageRoot: projectRoot || undefined,
+    };
+}
+/**
+ * 目标拓扑解析单一入口：从命令选项视图解析远端/本地目标拓扑信息。
+ *
+ * 显式路径与包标识符分类规则：
+ * - 显式路径形态（以 .、/、~ 开头或包含非 scoped 分隔符）：
+ *   严格作为本地技能或包目录解析；禁止与显式远端选项（--server 或非 local 的 --profile）组合，违规抛出 ArgumentError；
+ *   不受隐式 Profile 或 ACTIONDOCK_SERVER_URL 环境变量改变目标，本地执行优先；
+ *   若本地目录不存在或不合法，抛出 packageNotFoundError；
+ * - 纯词法包标识符（如 pkg.a、@scope/pkg）：
+ *   若存在远端目标（显式 --server、非 local profile 或默认远端环境），严格作为远端包标识解析，绝不因本地 cwd 存在同名目录而劫持为本地执行；
+ *   若无远端目标，正常按本地目标解析。
+ *
+ * @param options 命令选项视图（支持直接传入 Commander 解析后的 options 对象）
+ * @param context CLI 上下文
+ * @param strategy 内部解析策略；仅清单查询可跳过单包闭包校验
+ * @returns 解析后的目标拓扑信息（仅信息解析，不创建 Service 实例）
+ */
+export function resolveTargetFromOptions(options, context, strategy) {
+    return resolveCommandTargetInternal(options, context, strategy).resolved;
+}
+/**
+ * 统一计算目标资源引用（Action 或 Playbook）的辅助函数（单一事实源）。
+ *
+ * 规则：
+ * - 远端分支：options.package 存在且资源标识未限定时，前缀拼接 options.package；
+ * - 本地单包技能：资源标识未限定时，前缀拼接真实 packageId（而非路径目录名）；
+ * - 本地复合技能：保持短名，供后续图解析裁决唯一匹配或多包歧义；完全限定名直接透传；
+ * - 普通工程包：非技能且 options.package 存在时，未限定则拼接 options.package。
+ *
+ * @param resourceId 资源标识符（动作名或规程名）
+ * @param options 命令选项视图
+ * @param localSkill 本地技能目录视图
+ */
+export function resolveResourceRef(resourceId, options, localSkill) {
+    if (!options.package)
+        return resourceId;
+    if (localSkill) {
+        if (localSkill.type === "single" && !resourceId.includes("/")) {
+            return `${localSkill.packages[0].packageId}/${resourceId}`;
+        }
+        // 复合技能短名不拼目录名，保持 resourceId 供后续裁决唯一匹配或多包歧义
+        return resourceId;
+    }
+    if (!resourceId.includes("/")) {
+        return `${options.package}/${resourceId}`;
+    }
+    return resourceId;
+}
+/**
+ * 统一计算目标 Playbook 引用的辅助函数。
+ */
+export function resolvePlaybookRef(playbookId, options, localSkill) {
+    return resolveResourceRef(playbookId, options, localSkill);
+}
+/**
+ * 构造与目标作用域严格对应的 PackageGraph（单一事实源）。
+ *
+ * 封闭保证：
+ * - 当目标为 LocalSkillDirectory 时，仅以 localSkill.packages 显式包集合构建封闭图；
+ *   绝不扫描 cwd 也不扫描全局 Registry/开发软链，防止外部同名包或污染泄漏；
+ * - 当目标为普通本地工程或包 ID 时，维持原有的基于项目根与全局链接表的拓扑图构建模式。
+ */
+export function buildScopedPackageGraph(target, context) {
+    if (target.localSkill) {
+        const isSingle = target.localSkill.type === "single";
+        const discovered = target.localSkill.packages.map((pkg) => ({
+            id: pkg.packageId,
+            root: pkg.packageRoot,
+            manifest: pkg.projectConfig,
+            isCurrentProject: isSingle,
+        }));
+        return new PackageGraphBuilder({
+            packages: discovered,
+            root: isSingle ? target.localSkill.packages[0].packageId : undefined,
+        }).buildSync();
+    }
+    return new PackageGraphBuilder({
+        root: target.targetPackageRoot,
+        customHome: context?.customHome,
+        allowDevLinks: true,
+    }).buildSync();
 }
 /**
  * 统一解析 CLI 命令的目标拓扑与包作用域（run, describe, list 等命令的单一事实源）。
@@ -64,55 +178,35 @@ export function resolveTargetFromOptions(options, context) {
  * 保证：
  * - 优先判定目标拓扑；
  * - 远端目标（remote）完全隔离：不执行任何本地目录探测、清单加载或包根寻址；
- * - 远端目标动作引用保持原始词法包 ID 拼接（${options.package}/${actionId}），绝不被本地同名目录或清单 ID 篡改；
- * - 本地目标按本地封闭技能目录或工程包严格解析，不存在时透明抛出 packageNotFoundError。
+ * - 远端目标动作与规程引用保持原始词法包 ID 拼接（${options.package}/${id}），绝不被本地同名目录或清单 ID 篡改；
+ * - 本地目标默认按封闭技能目录或工程包严格解析；元数据策略仅跳过单包闭包校验；
+ * - 显式目标不存在时透明抛出 packageNotFoundError。
  */
-export function resolveCommandTarget(options, context) {
-    const resolved = resolveTargetFromOptions(options, context);
-    if (resolved.type === "remote") {
+export function resolveCommandTarget(options, context, strategy) {
+    const result = resolveCommandTargetInternal(options, context, strategy);
+    if (result.resolved.type === "remote") {
+        const resolveRemoteRef = (id) => {
+            if (options.package && !id.includes("/")) {
+                return `${options.package}/${id}`;
+            }
+            return id;
+        };
         return {
-            resolved,
+            resolved: result.resolved,
             isRemote: true,
             localSkill: null,
             targetPackageRoot: undefined,
-            resolveActionRef: (actionId) => {
-                if (options.package && !actionId.includes("/")) {
-                    return `${options.package}/${actionId}`;
-                }
-                return actionId;
-            },
+            resolveActionRef: resolveRemoteRef,
+            resolvePlaybookRef: resolveRemoteRef,
         };
     }
-    // 本地分支
-    const localSkill = options.package ? inspectLocalPackageDirectory(options.package) : null;
-    const targetPackageRoot = localSkill
-        ? localSkill.root
-        : options.package
-            ? resolveLocalPackageRoot(options.package)
-            : findProjectRoot();
-    if (options.package && !targetPackageRoot) {
-        throw packageNotFoundError(options.package);
-    }
     return {
-        resolved,
+        resolved: result.resolved,
         isRemote: false,
-        localSkill,
-        targetPackageRoot: targetPackageRoot || undefined,
-        resolveActionRef: (actionId) => {
-            if (!options.package)
-                return actionId;
-            if (localSkill) {
-                if (localSkill.type === "single" && !actionId.includes("/")) {
-                    return `${localSkill.packages[0].packageId}/${actionId}`;
-                }
-                // 复合技能短名不拼目录名，保持 actionId 供 Host resolveAction 裁决唯一匹配或多包歧义
-                return actionId;
-            }
-            if (!actionId.includes("/")) {
-                return `${options.package}/${actionId}`;
-            }
-            return actionId;
-        },
+        localSkill: result.localSkill,
+        targetPackageRoot: result.targetPackageRoot,
+        resolveActionRef: (actionId) => resolveResourceRef(actionId, options, result.localSkill),
+        resolvePlaybookRef: (playbookId) => resolvePlaybookRef(playbookId, options, result.localSkill),
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/cli",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "ActionDock CLI facade for developing, testing, building, and exporting standalone Agent Actions and Skills",
   "type": "module",
   "bin": {
@@ -34,10 +34,10 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/builder": "^2.14.0",
-    "@actiondock/core": "^2.14.0",
-    "@actiondock/mcp": "^2.14.0",
-    "@actiondock/sdk": "^2.14.0",
+    "@actiondock/builder": "^2.15.0",
+    "@actiondock/core": "^2.15.0",
+    "@actiondock/mcp": "^2.15.0",
+    "@actiondock/sdk": "^2.15.0",
     "commander": "^13.1.0",
     "selfsigned": "^5.5.0"
   },