@actiondock/builder 2.15.0 → 2.17.0

package/README.md

@@ -40,21 +40,29 @@ ActionDock 2.x 构建规划、目录交付与技能导出包。
 
 ### SkillExporter 与技能导出
 
-[SkillExporter](./src/exporter.ts) 与 `exportSkill` 导出函数将原子 Action 与操作规程 Playbook 打包导出为面向主流 AI 智能体生态的标准 Agent Skill 资产：
+[SkillExporter](./src/exporter.ts)、`exportSkill` 以及 `exportCompositeSkill` 导出函数将原子 Action 与操作规程 Playbook 打包导出为面向主流 AI 智能体生态的标准 Agent Skill 资产：
 
-- 生成 SKILL.md 指令：提取 Playbook 规程内容与工具元数据，合成符合智能体规范的操作指南文档与声明头部。
-- 源码模式技能导出：使用 `--mode source`（默认模式），保留 TypeScript 源码与依赖声明，适合具备 Node.js 运行环境的智能体容器直接运行。
+- 默认单包浅导出机制：默认采用单包源码浅闭包导出，仅复制当前包自身源码与规程，产物清单完整保留 `uses` 跨包逻辑契约，不物理拷贝外部包源码，单包结构纯粹透明，天然支持配合 `playbooks` 或 `actions` 执行规程驱动剪枝。
+- 显式外部依赖物化：支持 `bundleDeps` 选项。当显式开启且依赖闭包跨越外部已链接包时，自顶向下递归解析依赖链并将外部依赖包物理物化进产物根目录的 `packages/*` 子目录，展开为自包含的微型工作区产物结构；展开为复合形态时与过滤参数严格互斥（抛出 `FILTERS_UNSUPPORTED_FOR_COMPOSITE` 错误）。
+- 独立自包含 Node 目录型导出：支持 `standalone` 选项（等价于 `mode: "node"`），生成免全局 `ad` 命令行工具的自包含目录，内置独立运行脚本与说明书，配合 `vendorDeps` 可实现生产依赖完全内置。
 - 本地依赖完整性强校验：严格断言 Action 源码中的相对路径导入。若引用了未在 `actions` 且未在 `files` 字段中声明的本地模块，直接中断构建并抛出 `BuilderError`（错误码 `UNMET_LOCAL_DEPENDENCY`），彻底杜绝缺失依赖的产物分发。
-- 自包含 Node 目录技能导出：使用 `--mode node`，将自包含的 Node.js 交付目录与技能文档一体化打包，开箱即用。
-- 复合套件导出：支持 `--bundle` 选项将工作区内的多个包统一导出为复合工作区技能套件。
-- 压缩归档：支持 `--archive` 选项将导出的技能目录打包为 `.zip` 或 `.tar.gz` 格式。
+- 生成 SKILL.md 指令：提取 Playbook 规程内容与工具元数据，合成符合智能体规范的操作指南文档与声明头部。
+- 复合套件导出与说明书定制：支持 `exportCompositeSkill` 函数将工作区内的多个包统一导出为复合工作区技能套件；支持通过 `customMdPath` 注入插槽定制模板，通过 `skillMdOnly` 实现就地仅原位刷新说明书。
+- 压缩归档：支持 `archive` 选项将导出的技能目录打包为 `.zip` 或 `.tar.gz` 格式。
 
 ---
 
 ## 编程调用示例
 
 ```ts
-import { buildProject, packProject, SelectionPlanner, SkillExporter, exportSkill } from "@actiondock/builder";
+import {
+  buildProject,
+  packProject,
+  SelectionPlanner,
+  SkillExporter,
+  exportSkill,
+  exportCompositeSkill,
+} from "@actiondock/builder";
 
 // 计算依赖规划闭包
 const planner = new SelectionPlanner({ projectRoot: "/path/to/project" });
@@ -73,20 +81,34 @@ const packResult = await packProject({
   outDir: "./dist/npm",
 });
 
-// 导出 Agent Skill 资产（顶层便捷入口，内部委托 SkillExporter 实例方法）
+// 默认源码单包浅导出（支持规程定向裁剪）
 const skillResult = await exportSkill({
   projectRoot: "/path/to/project",
-  outDir: "./dist/skills",
+  outDir: "./dist/skills/review-pr",
   playbooks: ["review-pr"],
-  mode: "source",
 });
 
-// 或直接实例化 SkillExporter 定制导出
-const exporter = new SkillExporter();
-const customResult = await exporter.export({
+// 显式物化外部依赖导出（展开为微型工作区）
+const bundledResult = await exportSkill({
   projectRoot: "/path/to/project",
-  outDir: "./dist/skills-custom",
-  mode: "source",
+  outDir: "./dist/skills/bundled",
+  bundleDeps: true,
+});
+
+// 独立自包含 Node.js 目录型导出（免全局 ad 命令行，物化生产依赖）
+const standaloneResult = await exportSkill({
+  projectRoot: "/path/to/project",
+  outDir: "./dist/skills/standalone",
+  standalone: true,
+  vendorDeps: true,
+});
+
+// 复合套件聚合导出与就地原位刷新说明书
+const compositeResult = await exportCompositeSkill({
+  bundleName: "vip-agent-tools",
+  projectRoots: ["/path/to/pkg-a", "/path/to/pkg-b"],
+  outDir: "./dist/composite-skill",
+  customMdPath: "/path/to/SKILL.custom.md",
 });
 ```
 

package/dist/dependency-check.d.ts

@@ -1,4 +1,4 @@
-import type { SelectionPlan } from "./types.js";
+import { type SelectionPlan } from "./types.js";
 /**
  * 从源码中快速提取以相对路径（./ 或 ../）引入的静态或动态导入说明符。
  */

package/dist/dependency-check.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { isPathOutsideBoundary } from "@actiondock/core/project";
 import { BuilderError } from "./errors.js";
+import { isOwnAction } from "./types.js";
 /**
  * 移除源码中的单行与多行注释，防止注释内的相对路径字符串误触发依赖解析。
  */
@@ -130,6 +131,8 @@ export function assertRelativeDependenciesIntegrity(projectRoot, plan) {
     // 收集已包含在构建规划中的全部文件物理绝对路径
     const collectedPaths = new Set();
     for (const act of plan.actions) {
+        if (!isOwnAction(act))
+            continue;
         if (act.resolvedPath) {
             collectedPaths.add(toRealPath(act.resolvedPath));
         }
@@ -142,6 +145,8 @@ export function assertRelativeDependenciesIntegrity(projectRoot, plan) {
     // 待校验文件队列（包括全部 Action 及其收集的 TS/JS 模块）
     const queue = [];
     for (const act of plan.actions) {
+        if (!isOwnAction(act))
+            continue;
         if (act.resolvedPath && existsSync(act.resolvedPath)) {
             queue.push({ file: toRealPath(act.resolvedPath), actionId: act.id });
         }

package/dist/entry-generators.d.ts

@@ -8,15 +8,8 @@ import type { SelectionPlan } from "./types.js";
  *   按需加载业务实现；跨包外部 Action 不混入本包源码，依赖调用继续经 Host 路由；
  * - 入口路径以产物包根目录为基准（import.meta.dirname），不依赖调用者当前工作目录。
  */
-export declare function generateNodeHostEntrySource(plan: SelectionPlan | undefined, options?: {
-    localPackages: Array<{
-        packageId: string;
-        relativeRoot: string;
-    }>;
-}): string;
+export declare function generateNodeHostEntrySource(plan: SelectionPlan): string;
 /**
  * 生成轻量监督父进程脚本源码（负责参数解析、诊断日志限流、退出码管理与标准输出隔离）。
  */
-export declare function generateNodeSupervisorEntrySource(plan: Pick<SelectionPlan, "packageId" | "version" | "description">, options?: {
-    multiPackage?: boolean;
-}): string;
+export declare function generateNodeSupervisorEntrySource(plan: SelectionPlan): string;

package/dist/entry-generators.js

@@ -1,5 +1,4 @@
 import { STANDALONE_ASYNC_UNSUPPORTED } from "@actiondock/core";
-import { BuilderError } from "./errors.js";
 import { serializePlanManifest } from "./manifest.js";
 /**
  * 生成 Host 子进程入口脚本源码（负责运行 ActionDockHost，通过 Node IPC 暴露 Target）。
@@ -10,49 +9,24 @@ import { serializePlanManifest } from "./manifest.js";
  *   按需加载业务实现；跨包外部 Action 不混入本包源码，依赖调用继续经 Host 路由；
  * - 入口路径以产物包根目录为基准（import.meta.dirname），不依赖调用者当前工作目录。
  */
-export function generateNodeHostEntrySource(plan, options) {
+export function generateNodeHostEntrySource(plan) {
     // 复用 SelectionPlan 的清单序列化单一事实源（含包内动作筛选与 Schema 字段映射），
     // 不单独复制一份 Schema 字段映射
-    if (!options && !plan)
-        throw new BuilderError("A plan or explicit local packages are required for the Host entry");
-    const manifestActions = options ? undefined : serializePlanManifest(plan).actions;
-    const packageEntries = options
-        ? options.localPackages.map((pkg) => `{
-      packageRoot: resolve(packageRoot, ${JSON.stringify(pkg.relativeRoot)}),
-      projectConfig: loadLocalConfig(${JSON.stringify(pkg.packageId)}, ${JSON.stringify(pkg.relativeRoot)}),
-      dataDir,
-      configOverrides,
-    }`).join(",\n")
-        : `{
-      packageRoot, dataDir, configOverrides,
-      projectConfig: ${JSON.stringify({
-            id: plan.packageId, name: plan.packageName, version: plan.version,
-            description: plan.description || "", config: plan.configDefs || {}, actions: manifestActions,
-        })},
-    }`;
+    const manifestActions = serializePlanManifest(plan).actions;
     return `#!/usr/bin/env node
 // AUTO-GENERATED HOST ENTRYPOINT BY ACTIONDOCK BUILDER. DO NOT EDIT.
-import { resolve } from "node:path";
 import {
-  loadProjectConfig,
   createActionDock,
   createNodePlatform,
-  validateLocalSkillPackages,
 } from "@actiondock/core";
 import { serveParentIpc } from "@actiondock/core/server";
 
 // 产物包根目录：以入口文件自身位置为基准，不依赖调用者当前工作目录
 const packageRoot = import.meta.dirname;
-${options ? `function loadLocalConfig(expectedId, relativeRoot) {
-  const config = loadProjectConfig(resolve(packageRoot, relativeRoot));
-  if (config.id !== expectedId) throw new Error("Local package ID mismatch: expected " + expectedId + ", found " + config.id);
-  return config;
-}` : ""}
 
 let dataDir;
 const configOverrides = {};
 const args = process.argv.slice(2);
-const commandArgs = [];
 for (let i = 0; i < args.length; i++) {
   if (args[i] === "--data-dir" && i + 1 < args.length) {
     dataDir = args[++i];
@@ -66,28 +40,33 @@ for (let i = 0; i < args.length; i++) {
     const raw = args[i].slice(9);
     const [k, ...v] = raw.split("=");
     if (k) configOverrides[k] = v.join("=");
-  } else {
-    commandArgs.push(args[i]);
   }
 }
 
 // 复用既有命令分发结果确定访问性质：发现命令（list/describe/show）为旁观初始化，
 // 不创建数据库、不取目录锁、不收割遗留运行记录；执行与写入命令为持有者初始化
-const command = commandArgs.find((a) => !a.startsWith("-")) || "";
+const command = args.find((a) => !a.startsWith("-")) || "";
 const DISCOVERY_COMMANDS = new Set(["list", "describe", "show"]);
 const recoverOrphans = DISCOVERY_COMMANDS.has(command) ? false : undefined;
 
-const localPackages = [${packageEntries}];
-validateLocalSkillPackages(localPackages.map((p) => ({
-  packageId: p.projectConfig.id,
-  packageRoot: p.packageRoot,
-  projectConfig: p.projectConfig,
-})));
-
 const service = await createActionDock({
   dataDir,
   ...(recoverOrphans === false ? { recoverOrphans: false } : {}),
-  packages: localPackages,
+  packages: [
+    {
+      packageRoot,
+      dataDir,
+      configOverrides,
+      projectConfig: {
+        id: ${JSON.stringify(plan.packageId)},
+        name: ${JSON.stringify(plan.packageName)},
+        version: ${JSON.stringify(plan.version)},
+        description: ${JSON.stringify(plan.description || "")},
+        config: ${JSON.stringify(plan.configDefs || {})},
+        actions: ${JSON.stringify(manifestActions)},
+      },
+    },
+  ],
   platform: createNodePlatform({ dataDir }),
   autoLoadCurrentProject: false,
   scanLinkedPackages: false,
@@ -98,7 +77,7 @@ await serveParentIpc(service);
 /**
  * 生成轻量监督父进程脚本源码（负责参数解析、诊断日志限流、退出码管理与标准输出隔离）。
  */
-export function generateNodeSupervisorEntrySource(plan, options) {
+export function generateNodeSupervisorEntrySource(plan) {
     return `#!/usr/bin/env node
 // AUTO-GENERATED SUPERVISOR ENTRYPOINT BY ACTIONDOCK BUILDER. DO NOT EDIT.
 import { spawn } from "node:child_process";
@@ -162,8 +141,8 @@ if (argv.includes("-h") || argv.includes("--help") || argv[0] === "help") {
   console.log("  <cmd> run <id> [--input '<json>']           Execute action with JSON input");
   console.log("  <cmd> run <id> [--stdin-field <field>] [-- <assignments...>]");
   console.log("                                             Bind raw stdin text to an input field");
-  ${options?.multiPackage ? 'console.log("  Multi-package config/state management is unavailable; use --config overrides.");'
-        : 'console.log("  <cmd> config list/get/set/delete            Manage package configuration");\n  console.log("  <cmd> state list/get/set/delete             Manage shared state store");'}
+  console.log("  <cmd> config list/get/set/delete            Manage package configuration");
+  console.log("  <cmd> state list/get/set/delete             Manage shared state store");
   console.log("\\nGlobal options:");
   console.log("  --data-dir <path>                           Custom runtime database directory");
   console.log("  --config <KEY=val>                          Temporary config override");
@@ -212,7 +191,6 @@ const dispatcher = new StandaloneDispatcher({
   version: METADATA.version,
   description: METADATA.description,
   service,
-  multiPackage: ${JSON.stringify(options?.multiPackage === true)},
 });
 
 try {

package/dist/export-composite.d.ts

@@ -3,7 +3,7 @@ import type { CompositeSkillExportOptions, CompositeSkillExportResult, SkillExpo
  * 复合套件导出装配层。
  *
  * 职责：将多个包聚合为一个统一的复合技能目录（mini-workspace 形态），
- * 保留各子包 npm 依赖并生成复合根 package.json，并生成或复用复合 SKILL.md。
+ * 聚合各子包依赖生成复合根 package.json，并生成或复用复合 SKILL.md。
  */
 /** 子包导出回调：由 SkillExporter 注入自身导出能力，避免模块间循环依赖 */
 export type SubpackageExporter = (options: SkillExporterOptions) => Promise<SkillExportResult>;

package/dist/export-composite.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { loadProjectConfig, } from "@actiondock/core";
 import { getPackageSlug, loadManifest, loadPlaybooks, } from "@actiondock/core/project";
@@ -6,10 +6,9 @@ import { generateCompositeSkillMd, RUNTIME_REFERENCE_REL_PATH } from "./skill/in
 import { writeRuntimeReferenceFile } from "./export-source.js";
 import { BuilderError } from "./errors.js";
 import { collectRelativeFiles, getInternalDependencyVersion, replaceDirAtomic } from "./fs-utils.js";
-import { allocatePackageDirName } from "./manifest.js";
-import { createSourcePackageGraph } from "./source-graph.js";
-import { generateNodeHostEntrySource, generateNodeSupervisorEntrySource } from "./entry-generators.js";
-import { findExistingCompositeSkillMd, resolveCustomSkillDeclaration, appendLocalExecutionContract, } from "./skill-md.js";
+import { allocatePackageDirName, sanitizeExportDependencies } from "./manifest.js";
+import { SelectionPlanner } from "./planner.js";
+import { findExistingCompositeSkillMd, resolveCustomSkillDeclaration, } from "./skill-md.js";
 import { createArchive, resolveArchiveFormat } from "./export-archive.js";
 /**
  * 执行复合模式导出：将多个包聚合为一个统一的复合技能目录。
@@ -21,6 +20,9 @@ export async function exportCompositeImpl(options, exportSubpackage) {
     if (!options.bundleName || !options.bundleName.trim()) {
         throw new BuilderError("bundleName is required for composite skill export.");
     }
+    if (options.standalone) {
+        throw new BuilderError("Composite Skill export currently only supports source mode. Standalone mode is not supported for composite bundles.", "UNSUPPORTED_BUILD_MODE");
+    }
     const skillMdOnly = options.skillMdOnly === true;
     const customDeclaration = resolveCustomSkillDeclaration(options);
     const bundleSlug = getPackageSlug(options.bundleName);
@@ -39,36 +41,30 @@ export async function exportCompositeImpl(options, exportSubpackage) {
         mkdirSync(packagesDestDir, { recursive: true });
     }
     const packageInfos = [];
-    const localPackages = [];
     const packageSummaries = [];
     let existingSkillPath;
     try {
-        const packageGraph = skillMdOnly ? undefined : options.packageGraph ?? createSourcePackageGraph(options.projectRoots);
-        const effectiveRoots = skillMdOnly
-            ? new Set(options.projectRoots.map((root) => resolve(root)))
-            : new Set(Array.from(packageGraph.packages.values(), (pkg) => pkg.root));
-        const usedDirNames = new Set();
-        const usedNpmNames = new Set();
-        const sourceNpmNames = new Map();
-        if (!skillMdOnly) {
-            // 先保留全部真实 npm 名，缺省名不得覆盖尚未导出的兄弟包身份。
-            for (const projectRoot of effectiveRoots) {
-                const pkgJsonPath = join(projectRoot, "package.json");
-                const name = existsSync(pkgJsonPath) ? readWorkspacePackageName(pkgJsonPath) : undefined;
-                sourceNpmNames.set(projectRoot, name);
-                if (name) {
-                    if (usedNpmNames.has(name)) {
-                        throw new BuilderError(`Duplicate npm workspace package name '${name}'.`, "DUPLICATE_WORKSPACE_PACKAGE_NAME");
+        // 收集项目根目录；仅在显式指定 bundleDeps 时展开依赖闭包中的外部项目根目录
+        const effectiveRoots = new Set();
+        for (const r of options.projectRoots) {
+            effectiveRoots.add(resolve(r));
+            if (!skillMdOnly && options.bundleDeps === true) {
+                try {
+                    const p = SelectionPlanner.plan({ projectRoot: r });
+                    if (p.externalProjectRoots) {
+                        for (const extRoot of p.externalProjectRoots) {
+                            effectiveRoots.add(resolve(extRoot));
+                        }
                     }
-                    usedNpmNames.add(name);
+                }
+                catch {
+                    // 忽略规划解析异常，由主循环处理
                 }
             }
         }
+        const usedDirNames = new Set();
         for (const projectRoot of effectiveRoots) {
-            const graphManifest = packageGraph && Array.from(packageGraph.packages.values()).find((p) => resolve(p.root) === resolve(projectRoot))?.manifest;
-            const config = graphManifest
-                ? { ...graphManifest, name: graphManifest.name || graphManifest.id, version: graphManifest.version || "0.1.0" }
-                : loadProjectConfig(projectRoot);
+            const config = loadProjectConfig(projectRoot);
             let pkgSlug;
             if (skillMdOnly) {
                 // 就地生成：规程链接基于工作区实际子目录名
@@ -78,49 +74,34 @@ export async function exportCompositeImpl(options, exportSubpackage) {
                 // 目录名分配统一复用 manifest 的 allocatePackageDirName，回退后仍冲突会追加数字后缀
                 pkgSlug = allocatePackageDirName(usedDirNames, config.id);
             }
-            let defaultPackageName;
-            if (!skillMdOnly && !sourceNpmNames.get(projectRoot)) {
-                const baseName = normalizeNpmPackageName(pkgSlug);
-                let candidate = baseName;
-                let suffix = 2;
-                while (usedNpmNames.has(candidate))
-                    candidate = `${baseName}-${suffix++}`;
-                defaultPackageName = candidate;
-                usedNpmNames.add(candidate);
-            }
             let actionIds;
-            let playbooks;
+            let playbookIds;
             let manifest;
             if (skillMdOnly) {
                 // 仅生成 SKILL.md：直接读取清单获取 Action 契约描述，不拷贝子包产物
                 manifest = loadManifest(projectRoot);
                 actionIds = manifest?.actions ? Object.keys(manifest.actions) : [];
-                playbooks = loadPlaybooks(projectRoot, config.playbooksDir);
+                playbookIds = Array.from(loadPlaybooks(projectRoot, config.playbooksDir).keys());
             }
             else {
                 const destPkgDir = join(packagesDestDir, pkgSlug);
                 const singleExport = await exportSubpackage({
                     projectRoot,
-                    packageGraph,
-                    config,
-                    manifest: graphManifest || undefined,
                     outDir: destPkgDir,
                     archive: false,
                     skipSkillMd: true,
                     mode: "source",
                     _isSubpackage: true,
-                    defaultPackageName,
                 });
-                manifest = loadManifest(destPkgDir);
+                manifest = loadManifest(destPkgDir) || loadManifest(projectRoot);
                 actionIds = singleExport.actions;
-                playbooks = loadPlaybooks(destPkgDir, manifest?.playbooksDir, manifest);
+                playbookIds = singleExport.playbooks;
             }
-            const playbookIds = Array.from(playbooks.keys());
+            const playbooks = loadPlaybooks(projectRoot, config.playbooksDir);
             const actionEntries = actionIds.map((actId) => ({
                 id: actId,
                 description: manifest?.actions?.[actId]?.description,
             }));
-            localPackages.push({ packageId: config.id, relativeRoot: `packages/${pkgSlug}` });
             packageInfos.push({
                 config,
                 actions: actionEntries,
@@ -140,7 +121,6 @@ export async function exportCompositeImpl(options, exportSubpackage) {
         const compositeSkillMd = generateCompositeSkillMd(options.bundleName, description, packageInfos, {
             customSections: customDeclaration?.sections,
             packagesBaseDir: skillMdOnly ? "." : "packages",
-            invocationStyle: skillMdOnly ? "global-ad" : "source-ad",
         });
         if (skillMdOnly) {
             // 就地仅重生成 SKILL.md：始终重新生成（忽略已有 SKILL.md 复用逻辑），不产出完整套件目录
@@ -176,10 +156,9 @@ export async function exportCompositeImpl(options, exportSubpackage) {
         }
         if (existingSkillPath) {
             const destSkillMdPath = join(stagingDir, "SKILL.md");
-            writeFileSync(destSkillMdPath, readFileSync(existingSkillPath, "utf-8"), "utf-8");
-            appendLocalExecutionContract(destSkillMdPath, packageInfos.map((p) => ({
-                packageId: p.config.id, actions: p.actions,
-            })));
+            if (resolve(existingSkillPath) !== resolve(destSkillMdPath)) {
+                copyFileSync(existingSkillPath, destSkillMdPath);
+            }
         }
         else {
             writeFileSync(join(stagingDir, "SKILL.md"), compositeSkillMd, "utf-8");
@@ -188,19 +167,11 @@ export async function exportCompositeImpl(options, exportSubpackage) {
                 dependencyStepLabel: "安装复合技能聚合依赖",
                 relinkStepLabel: "完成安装后重新链接复合技能",
                 compositeLinkNote: true,
-                invocationStyle: "source-ad",
-                entryRelPath: 'node "<skill_root>/entry.mjs"',
+                invocationStyle: "global-ad",
             });
         }
-        if (packagesDestDir) {
-            assertUniqueWorkspacePackageNames(packagesDestDir);
-        }
-        // npm workspaces 保留各包依赖约束，根目录仅声明入口运行依赖。
-        writeCompositePkgJson(stagingDir, bundleSlug, options);
-        const entryMetadata = { packageId: options.bundleName, version: "0.1.0", description };
-        writeFileSync(join(stagingDir, "entry.mjs"), generateNodeSupervisorEntrySource(entryMetadata, { multiPackage: true }), "utf-8");
-        // Host 生成仍复用单包生成器，但源码包元数据只从自身相对路径读取。
-        writeFileSync(join(stagingDir, "entry-host.js"), generateNodeHostEntrySource(undefined, { localPackages }), "utf-8");
+        // 聚合所有子包依赖生成复合根目录 package.json
+        writeCompositePkgJson(stagingDir, packagesDestDir, packageInfos, bundleSlug, options);
         // 原子替换目标复合技能目录
         await replaceDirAtomic(stagingDir, targetSkillDir);
     }
@@ -227,77 +198,35 @@ export async function exportCompositeImpl(options, exportSubpackage) {
     };
 }
 /**
- * 复合根目录声明入口运行依赖，业务依赖保留在各工作区包中，由 npm 安装解析。
+ * 复合套件聚合各子包依赖并生成复合根目录 package.json。
+ * 依赖清洗统一复用 manifest 的 sanitizeExportDependencies 单一入口，与单包导出口径一致。
  */
-function writeCompositePkgJson(stagingDir, bundleSlug, options) {
-    // 子包保留各自依赖约束，由 npm workspaces 正常安装与多版本解析，不聚合覆盖。
-    const runtimeDeps = {
-        "@actiondock/core": getInternalDependencyVersion(),
+function writeCompositePkgJson(stagingDir, packagesDestDir, packageInfos, bundleSlug, options) {
+    const aggregatedDeps = {
         "@actiondock/sdk": getInternalDependencyVersion(),
     };
+    for (const info of packageInfos) {
+        const pkgJsonPath = join(packagesDestDir, info.packageDir, "package.json");
+        if (existsSync(pkgJsonPath)) {
+            try {
+                const parsed = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+                Object.assign(aggregatedDeps, sanitizeExportDependencies(join(packagesDestDir, info.packageDir), parsed.dependencies, "exported skill packages", false));
+            }
+            catch (err) {
+                if (err instanceof BuilderError)
+                    throw err;
+                // 复合导出缺依赖影响面大：读文件与解析失败必须显式报错，严禁静默吞掉导致聚合依赖缺失
+                throw new BuilderError(`Failed to read or parse package.json of exported subpackage '${info.packageDir}' (${pkgJsonPath}): ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
     const compositePkg = {
         name: `${bundleSlug}-composite-skill`,
         version: "0.1.0",
         description: options.description || `Composite Skill suite: ${options.bundleName}`,
         type: "module",
         workspaces: ["packages/*"],
-        dependencies: runtimeDeps,
+        dependencies: aggregatedDeps,
     };
     writeFileSync(join(stagingDir, "package.json"), JSON.stringify(compositePkg, null, 2) + "\n", "utf-8");
 }
-/**
- * 规范化包目录标识为合法 npm 包名（小写字母、数字、连字符、下划线与点号）。
- */
-function normalizeNpmPackageName(name) {
-    const normalized = name
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9-_.]/g, "-")
-        .replace(/^[._]+/, "");
-    return normalized || "package";
-}
-/** 工作区清单读取失败必须透明报告，只有缺省 name 才允许自动分配。 */
-function readWorkspacePackageName(path) {
-    const raw = readFileSync(path, "utf-8");
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        throw new BuilderError(`Invalid package.json at '${path}': ${String(err)}`, "INVALID_PACKAGE_JSON");
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new BuilderError(`Invalid package.json at '${path}': expected an object.`, "INVALID_PACKAGE_JSON");
-    }
-    const name = parsed.name;
-    if (name === undefined || name === "")
-        return undefined;
-    if (typeof name !== "string" || !name.trim() || name !== name.trim()) {
-        throw new BuilderError(`Invalid npm workspace package name at '${path}'.`, "INVALID_PACKAGE_JSON");
-    }
-    return name;
-}
-/**
- * 校验复合暂存目录中所有子包导出的 package.json.name 唯一性。
- * 若已有真实 npm 名确实冲突，在发布产物前明确抛出 BuilderError。
- */
-function assertUniqueWorkspacePackageNames(packagesDir) {
-    const seenNames = new Map();
-    const entries = readdirSync(packagesDir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const pkgJsonPath = join(packagesDir, entry.name, "package.json");
-        if (!existsSync(pkgJsonPath))
-            continue;
-        const name = readWorkspacePackageName(pkgJsonPath);
-        if (!name) {
-            throw new BuilderError(`Missing npm workspace package name at '${pkgJsonPath}'.`, "INVALID_PACKAGE_JSON");
-        }
-        const existing = seenNames.get(name);
-        if (existing) {
-            throw new BuilderError(`Duplicate npm workspace package name '${name}' found in packages/${existing} and packages/${entry.name}.`, "DUPLICATE_WORKSPACE_PACKAGE_NAME");
-        }
-        seenNames.set(name, entry.name);
-    }
-}

package/dist/export-source.d.ts

@@ -1,5 +1,5 @@
 import { renderRuntimeReferenceContent } from "./skill/templates.js";
-import type { SelectionPlan, SkillExporterOptions } from "./types.js";
+import { type SelectionPlan, type SkillExporterOptions } from "./types.js";
 /**
  * 源码型 Skill 导出装配层。
  *