@actiondock/cli 2.13.0 → 2.15.0

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/commands/run.js

@@ -1,9 +1,8 @@
 import { validateActionInputValue, mapInputValidationFailure, } from "@actiondock/core/project";
-import { resolveTarget, } from "@actiondock/core/profile";
 import { ACTION_NOT_FOUND, NOT_FOUND, resolveExecutionHint, } from "@actiondock/core";
-import { ArgumentError, ExecutionError, SigintError, packageNotFoundError } from "../errors.js";
+import { ArgumentError, ExecutionError, SigintError } from "../errors.js";
 import { extractTextFieldPayload, resolveActionDefaultTextField, writeStderr, writeStdout, } from "../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, resolveActionInput, resolveLocalPackageRoot, resolveTimeoutMs, withService, } from "../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, resolveActionInput, resolveCommandTarget, resolveTimeoutMs, withService, } from "../utils/index.js";
 /**
  * 以原始纯文本形式渲染 Action 执行终态结果（默认纯文本模式）。
  *
@@ -111,25 +110,13 @@ export async function executeAction(id, options, context, flatArgs, control) {
         }
     }
     try {
+        // 目标拓扑与动作引用解析（远端目标完全隔离本地文件系统）
+        const target = resolveCommandTarget(options, context);
         // 异步执行仅支持远端目标，本地模式直接拒绝
-        const resolvedTopology = resolveTarget({
-            profile: options.profile,
-            server: options.server,
-            token: options.token,
-            insecure: options.insecure,
-        }, context?.customHome);
-        if (resolvedTopology.type === "local" && options.async) {
+        if (!target.isRemote && options.async) {
             throw new ExecutionError("Async execution requires a long-running ActionDock server.\nUse --profile, --server, or start 'ad serve'.");
         }
-        // 目标拓扑解析（仅 local 分支需要包寻址）
-        const targetPackageRoot = resolveLocalPackageRoot(options.package);
-        if (options.package && !targetPackageRoot) {
-            throw packageNotFoundError(options.package);
-        }
-        let targetRef = id;
-        if (options.package && !id.includes("/")) {
-            targetRef = `${options.package}/${id}`;
-        }
+        const targetRef = target.resolveActionRef(id);
         // 通过 Service 统一执行
         await withService(options, context, async (service) => {
             const isMachine = Boolean(options.json);
@@ -205,7 +192,7 @@ export async function executeAction(id, options, context, flatArgs, control) {
                     return;
                 }
             }
-        }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true, ownDataDir: true });
+        }, { localRoot: target.targetPackageRoot || undefined, scanLinkedPackages: !target.localSkill, ownDataDir: true });
     }
     catch (err) {
         // sigint 取消源、中断链路特征错误码或 SigintError 本身，均统一归并为 SigintError

package/dist/commands/state.js

@@ -1,11 +1,11 @@
 import { decodeStateKey, } from "@actiondock/sdk";
-import { loadProjectConfig, } from "@actiondock/core";
+import { loadProjectConfig, inspectLocalPackageDirectory, } from "@actiondock/core";
 import { filterWithFallbackInfo, } from "@actiondock/core/project";
 import { listLinkedPackages, } from "@actiondock/core/registry";
 import { existsSync } from "node:fs";
 import { ArgumentError, ExecutionError, NO_PROJECT_NO_LINKED_MESSAGE } from "../errors.js";
 import { renderResult, renderStateList, writeStderr, writeStdout } from "../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, getTargetRoot, remoteTargetLabel, requirePackageRoot, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, resolveTargetFromOptions, withService, } from "../utils/index.js";
+import { applyTargetOptions, assertNotCompositeSkill, getEffectiveOptions, getTargetRoot, remoteTargetLabel, requirePackageRoot, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, resolveTargetFromOptions, withService, } from "../utils/index.js";
 /**
  * 统一预解码状态键寻址（get、set、delete 共享的单一事实源）。
  *
@@ -57,6 +57,22 @@ function resolveStateScope(resolved, options, rawKey) {
             localRoot: undefined,
         };
     }
+    assertNotCompositeSkill(options.package);
+    // 本地单包技能目录优先处理
+    if (options.package) {
+        const localSkill = inspectLocalPackageDirectory(options.package);
+        if (localSkill?.type === "single") {
+            const pkg = localSkill.packages[0];
+            return {
+                packageId: pkg.packageId,
+                scopeSuffix: `in package '${pkg.packageId}'`,
+                deleteSuffix: `from package '${pkg.packageId}'`,
+                effectiveKey: rawKey || "",
+                projConfig: pkg.projectConfig,
+                localRoot: pkg.packageRoot,
+            };
+        }
+    }
     // 本地项目模式：getTargetRoot 会从键中剥离 pkg/ 前缀，寻址基于解耦后的裸键
     const { root, key: effectiveKey } = getTargetRoot(options.package, rawKey);
     const projConfig = loadProjectConfig(root);
@@ -175,6 +191,7 @@ export function registerStateCommands(program, context) {
                 return;
             }
             // 本地工程与链接包模式：按目标根目录决策输出范围
+            assertNotCompositeSkill(options.package);
             const targetRoot = options.package
                 ? requirePackageRoot(options.package).root
                 : resolveLocalPackageRoot();

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/index.d.ts

@@ -4,4 +4,3 @@ export * from "./spawn.js";
 export * from "./cert.js";
 export * from "./input.js";
 export * from "./server-launch.js";
-export * from "./warning.js";

package/dist/utils/index.js

@@ -4,4 +4,3 @@ export * from "./spawn.js";
 export * from "./cert.js";
 export * from "./input.js";
 export * from "./server-launch.js";
-export * from "./warning.js";