@actiondock/cli 2.15.0 → 2.16.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, loadManifest, loadPlaybooks, saveManifest, filterWithFallbackInfo, } from "@actiondock/core/project";
-import { DefaultActionCatalog, resolveAction, resolvePlaybook, } from "@actiondock/core/graph";
+import { assertPathWithinRoot, loadActions, loadManifest, loadPlaybooks, saveManifest, filterWithFallbackInfo, } from "@actiondock/core/project";
+import { DefaultActionCatalog, PackageGraphBuilder, 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, writeStderr, writeStdout, } from "../renderer.js";
-import { applyTargetOptions, buildScopedPackageGraph, getEffectiveOptions, remoteTargetSuffix, requirePackageRoot, resolveCommandTarget, resolveFallbackStrategy, resolveIntent, } from "../utils/index.js";
+import { renderPlaybookDetail, renderPlaybookList, renderResult, writeStdout, } from "../renderer.js";
+import { applyTargetOptions, getEffectiveOptions, remoteTargetSuffix, requirePackageRoot, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, resolveTargetFromOptions, } from "../utils/index.js";
 /**
  * 注册 Playbook 命令集合（list, show, validate, create）。
  *
@@ -34,15 +34,14 @@ export function registerPlaybookCommands(program, context) {
         const hints = [
             "Tip: Run 'ad playbook show <id>' to inspect procedure steps before execution.",
         ];
-        // 1. 目标拓扑统一解析
-        const target = resolveCommandTarget(options, context);
-        // 2. 远端服务分支
-        if (target.isRemote) {
-            const remotePbs = await fetchRemotePlaybooks(target.resolved.serverUrl, target.resolved.token, {
+        // 1. 远端服务分支
+        const target = resolveTargetFromOptions(options, context);
+        if (target.type === "remote") {
+            const remotePbs = await fetchRemotePlaybooks(target.serverUrl, target.token, {
                 intent: effectiveIntent,
                 package: options.package,
                 allowInsecureHttp: Boolean(options.allowInsecureHttp),
-                insecure: target.resolved.insecure,
+                insecure: target.insecure,
             });
             if (isMachine) {
                 renderResult({ items: remotePbs, hints }, { json: options.json, context });
@@ -50,44 +49,24 @@ export function registerPlaybookCommands(program, context) {
             }
             renderResult(remotePbs, {
                 json: options.json,
-                humanFormatter: () => renderPlaybookList(remotePbs, `Playbooks ${remoteTargetSuffix(target.resolved)}`, false, effectiveIntent),
+                humanFormatter: () => renderPlaybookList(remotePbs, `Playbooks ${remoteTargetSuffix(target)}`, false, effectiveIntent),
                 context,
             });
             return;
         }
-        // 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);
+        // 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);
             if (isMachine) {
                 if (filterRes.isFallback) {
                     renderResult({ items: filterRes.items, isFallback: true, matchedCount: 0, hints }, { json: options.json, context });
@@ -102,7 +81,7 @@ export function registerPlaybookCommands(program, context) {
             }
             renderResult(filterRes.items, {
                 json: options.json,
-                humanFormatter: () => renderPlaybookList(filterRes.items, title, filterRes.isFallback, effectiveIntent),
+                humanFormatter: () => renderPlaybookList(filterRes.items, `Playbooks in ${config.id} (${targetRoot})`, filterRes.isFallback, effectiveIntent),
                 context,
             });
             return;
@@ -123,22 +102,25 @@ export function registerPlaybookCommands(program, context) {
         }
         const aggregated = [];
         for (const pkg of linkedList) {
-            if (!existsSync(pkg.path)) {
-                writeStderr(`Skipping inaccessible linked package '${pkg.id}' at '${pkg.path}'`, context);
+            if (!existsSync(pkg.path))
                 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;
@@ -201,14 +183,13 @@ export function registerPlaybookCommands(program, context) {
         if (!id) {
             throw new ArgumentError("Playbook ID is required for show");
         }
-        // 1. 目标拓扑统一解析
-        const target = resolveCommandTarget(options, context);
-        // 2. 远端服务分支
-        if (target.isRemote) {
+        // 1. 远端服务分支
+        const target = resolveTargetFromOptions(options, context);
+        if (target.type === "remote") {
             try {
-                const detail = await fetchRemotePlaybookShow(target.resolved.serverUrl, target.resolvePlaybookRef(id), target.resolved.token, {
+                const detail = await fetchRemotePlaybookShow(target.serverUrl, id, target.token, {
                     allowInsecureHttp: Boolean(options.allowInsecureHttp),
-                    insecure: target.resolved.insecure,
+                    insecure: target.insecure,
                 });
                 renderResult(detail, {
                     json: options.json,
@@ -222,15 +203,20 @@ export function registerPlaybookCommands(program, context) {
                 throw new ArgumentError(`${err.message}\n${hint}`, err?.details, err?.code, hint);
             }
         }
-        // 3. 本地分支（单包技能、复合技能、本地工程或已链接包）
-        const showTarget = target.resolvePlaybookRef(id);
+        // 2. 本地项目模式
+        let showTarget = id;
+        if (options.package && !id.includes("/")) {
+            requirePackageRoot(options.package);
+            showTarget = `${options.package}/${id}`;
+        }
         let resolved;
         try {
-            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 });
+            const graph = new PackageGraphBuilder({
+                root: resolveLocalPackageRoot() || undefined,
+                customHome: context?.customHome,
+                allowDevLinks: true,
+            }).buildSync();
+            resolved = resolvePlaybook(showTarget, { graph });
         }
         catch (err) {
             const hint = "Tip: Run 'ad playbook list' to discover available playbooks.";
@@ -263,73 +249,36 @@ export function registerPlaybookCommands(program, context) {
         .option("--json", "Output as JSON")
         .action(async (id, rawOptions, cmd) => {
         const options = getEffectiveOptions(rawOptions, cmd);
-        // 保持本地校验定位，profile 始终为 local
-        const target = resolveCommandTarget({ ...options, profile: "local" }, context);
-        const graph = buildScopedPackageGraph(target, context);
-        const catalog = new DefaultActionCatalog(graph);
+        const root = options.package
+            ? requirePackageRoot(options.package).root
+            : resolveLocalPackageRoot();
         const targets = [];
-        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;
+        if (root) {
             const config = loadProjectConfig(root);
+            const playbooks = loadPlaybooks(root, config.playbooksDir);
             if (id) {
-                const showTarget = target.resolvePlaybookRef(id);
-                let resolved;
-                try {
-                    resolved = resolvePlaybook(showTarget, { graph, caller: config.id });
+                const pb = playbooks.get(id);
+                if (!pb) {
+                    throw new ArgumentError(`Playbook '${id}' not found in package '${config.id}'`);
                 }
-                catch (err) {
-                    throw new ArgumentError(err.message, err?.details, err?.code);
-                }
-                targets.push({
-                    root: resolved.projectRoot,
-                    packageId: resolved.packageId,
-                    playbooks: [resolved.playbook],
-                });
+                targets.push({ root, packageId: config.id, playbooks: [pb] });
             }
             else {
-                const playbooks = loadPlaybooks(root, config.playbooksDir);
-                targets.push({
-                    root,
-                    packageId: config.id,
-                    playbooks: Array.from(playbooks.values()),
-                });
+                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, err?.details, err?.code);
+                throw new ArgumentError(err.message);
             }
             targets.push({
                 root: resolved.projectRoot,
@@ -343,22 +292,34 @@ 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)) {
-                    writeStderr(`Skipping inaccessible linked package '${pkg.id}' at '${pkg.path}'`, context);
+                if (!existsSync(pkg.path))
                     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 = [];
-        for (const targetItem of targets) {
-            for (const pb of targetItem.playbooks) {
+        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) {
                 const warnings = [];
                 const errors = [];
                 if (!pb.id) {
@@ -369,30 +330,26 @@ export function registerPlaybookCommands(program, context) {
                 }
                 if (pb.actions && Array.isArray(pb.actions)) {
                     for (const actRef of pb.actions) {
-                        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("/")) {
+                        if (actRef.includes("/")) {
                             try {
-                                resolveAction(trimmed, { graph, catalog, caller: targetItem.packageId });
+                                resolveAction(actRef, { graph, catalog, caller: target.packageId });
                             }
                             catch (e) {
-                                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.`);
+                                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.`);
                             }
                         }
                         else {
-                            // 短引用只接受所属包清单登记的 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.`);
+                            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.`);
                             }
                         }
                     }
                 }
                 results.push({
                     id: pb.id,
-                    packageId: targetItem.packageId,
+                    packageId: target.packageId,
                     valid: errors.length === 0,
                     warnings,
                     errors,

package/dist/commands/run.js

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

package/dist/commands/state.js

@@ -1,11 +1,11 @@
 import { decodeStateKey, } from "@actiondock/sdk";
-import { loadProjectConfig, inspectLocalPackageDirectory, } from "@actiondock/core";
+import { loadProjectConfig, } 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, assertNotCompositeSkill, getEffectiveOptions, getTargetRoot, remoteTargetLabel, requirePackageRoot, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, resolveTargetFromOptions, withService, } from "../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, getTargetRoot, remoteTargetLabel, requirePackageRoot, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, resolveTargetFromOptions, withService, } from "../utils/index.js";
 /**
  * 统一预解码状态键寻址（get、set、delete 共享的单一事实源）。
  *
@@ -57,22 +57,6 @@ 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);
@@ -191,7 +175,6 @@ 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,7 +43,3 @@ 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,19 +194,3 @@ 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,4 +1,3 @@
-import { type LocalSkillDirectory } from "@actiondock/core/project";
 import type { AggregatedPackage, CliContext, ProjectDetailInfo } from "../types.js";
 /**
  * 装配单个工程的详情自省信息（清单、动作映射与 Playbook 映射）。
@@ -6,18 +5,6 @@ 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 明细映射）。
  *
@@ -26,7 +13,7 @@ export declare function filterProjectDetails(details: ProjectDetailInfo[], effec
 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 { filterWithFallbackInfo, loadManifest, loadPlaybooks, } from "@actiondock/core/project";
+import { loadManifest, loadPlaybooks, } from "@actiondock/core/project";
 /**
  * 装配单个工程的详情自省信息（清单、动作映射与 Playbook 映射）。
  *
@@ -38,51 +38,6 @@ 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 明细映射）。
  *
@@ -108,7 +63,7 @@ export function getPackageSummary(root) {
 }
 /**
  * 扫描本地候选包集合（当前工程根目录优先，叠加全局已链接包，按物理路径去重）。
- * 失效或损坏链接给出明确诊断记录，不静默吞没也不中断其余条目聚合。
+ * 清单损坏或磁盘失效的候选项跳过，不影响其余条目聚合。
  *
  * @param context CLI 上下文（提供 customHome 定位全局注册表）
  */
@@ -118,22 +73,25 @@ export function scanLocalAggregatedPackages(context) {
     const aggregated = [];
     const seenPaths = new Set();
     if (currentRoot) {
-        aggregated.push(getPackageSummary(currentRoot));
-        seenPaths.add(currentRoot);
+        try {
+            aggregated.push(getPackageSummary(currentRoot));
+            seenPaths.add(currentRoot);
+        }
+        catch {
+            // 忽略异常工程根目录（清单损坏）
+        }
     }
     for (const pkg of linkedList) {
-        if (!existsSync(pkg.path)) {
-            process.stderr.write(`[actiondock] Diagnostic: Skipping inaccessible linked package '${pkg.id}' at '${pkg.path}'\n`);
+        if (!existsSync(pkg.path))
             continue;
-        }
         if (seenPaths.has(pkg.path))
             continue;
         try {
             aggregated.push(getPackageSummary(pkg.path));
             seenPaths.add(pkg.path);
         }
-        catch (err) {
-            process.stderr.write(`[actiondock] Diagnostic: Skipping invalid linked package '${pkg.id}' at '${pkg.path}': ${err?.message || String(err)}\n`);
+        catch {
+            // 忽略失效链接（清单损坏或磁盘异常）
         }
     }
     return { currentRoot, aggregated };