@actiondock/builder 2.7.0 → 2.8.0

package/README.md

@@ -1,12 +1,12 @@
 # @actiondock/builder
 
-ActionDock 2.0 构建规划、目录交付与技能导出包。
+ActionDock 2.x 构建规划、目录交付与技能导出包。
 
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D24.12.0-green?logo=node.js)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue?logo=typescript)](https://www.typescriptlang.org/)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
-`@actiondock/builder` 负责静态分析依赖关系、构建 Node.js 目录交付产物、打包标准 npm 压缩包以及将工具和规程导出为可分发的 Agent Skill 资产。
+`@actiondock/builder` 负责静态分析依赖关系、构建 Node.js 目录交付产物、打包标准 npm 压缩包以及将工具和规程导出为可分发的 Agent Skill 资产。在 ActionDock 2.x 中，Skill 模板生成与规程渲染能力已统一归位并入本包作为内置支持。
 
 ---
 
@@ -29,7 +29,6 @@ ActionDock 2.0 构建规划、目录交付与技能导出包。
 - 预置生产依赖：支持 `--vendor-deps` 选项，将锁定的生产依赖物化至产物目录内，实现离线自包含运行。
 - 可重现构建检验：支持 `--require-reproducible` 选项，当存在不受控的生命周期安装脚本时严格报错阻断，保证构建确定性。
 - 标准归档打包：支持 `--archive` 选项，自动将构建目录打包为标准 `.zip` 压缩归档文件。
-- 原单文件二进制编译选项（`--target` 与 `--bytecode`）已彻底删除，统一采用 Node.js 目录交付格式。
 
 ### packProject npm 包打包
 
@@ -39,9 +38,9 @@ ActionDock 2.0 构建规划、目录交付与技能导出包。
 - 预检模式：支持 `--dry-run` 选项，完整校验打包清单、动作列表与文件总数，无需实际写入磁盘。
 - 完整性校验：自动计算并输出打包产物的字节大小与 SHA-256 校验和。
 
-### SkillExporter 技能导出器
+### SkillExporter 与技能导出
 
-[SkillExporter](./src/exporter.ts) 将原子 Action 与操作规程 Playbook 打包导出为面向主流 AI 智能体生态的标准 Agent Skill 资产：
+[SkillExporter](./src/exporter.ts) 与 `exportSkill` 导出函数将原子 Action 与操作规程 Playbook 打包导出为面向主流 AI 智能体生态的标准 Agent Skill 资产：
 
 - 生成 SKILL.md 指令：提取 Playbook 规程内容与工具元数据，合成符合智能体规范的操作指南文档与声明头部。
 - 源码模式技能导出：使用 `--mode source`（默认模式），保留 TypeScript 源码与依赖声明，适合具备 Node.js 运行环境的智能体容器直接运行。

package/dist/archive.d.ts

@@ -4,14 +4,6 @@ export declare function dosDateTime(ms: number): {
     date: number;
     time: number;
 };
-/**
- * 将目录打包为标准 zip 归档（PKZIP APPNOTE 结构）。
- * 直接流式分块写入磁盘，避免在内存中积压全量归档内容。
- *
- * @param dir 待打包目录（目录名即归档内根文件夹名）
- * @param outPath 输出 zip 文件路径
- */
-export declare function createZipArchive(dir: string, outPath: string): void;
 /**
  * 向可写流安全写入数据块，严格处理背压与流异常。
  * 当 stream.write 返回 false 时挂起等待 drain 事件触发；
@@ -23,14 +15,6 @@ export declare function writeToStream(stream: Writable, chunk: Buffer): Promise<
  * 逐文件流式读取与增量压缩写入磁盘，避免在内存中积压全量原文件与压缩内容。
  */
 export declare function createZipArchiveAsync(dir: string, outPath: string): Promise<void>;
-/**
- * 将目录打包为标准 tar.gz 归档（USTAR + gzip）。
- *
- * @param dir 待打包目录（目录名即归档内根文件夹名）
- * @param outPath 输出 tar.gz 文件路径
- */
-export declare function createTarGzArchive(dir: string, outPath: string): void;
-/** tar.gz 异步流式归档配置选项 */
 export interface TarGzArchiveOptions {
     /** 自定义可读流创建器，默认使用 node:fs 的 createReadStream */
     createReadStream?: (path: string) => Readable;

package/dist/archive.js

@@ -1,71 +1,39 @@
-import { closeSync, createReadStream, createWriteStream, existsSync, openSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync, writeSync } from "node:fs";
-import { createDeflateRaw, deflateRawSync, gzipSync, createGzip } from "node:zlib";
-import { basename, join, relative, sep } from "node:path";
+import { createReadStream, createWriteStream, existsSync, statSync } from "node:fs";
+import { createDeflateRaw, createGzip } from "node:zlib";
+import { basename, join } from "node:path";
 import { Transform, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { assertPathWithinRoot } from "@actiondock/core";
-/** 递归收集目录内全部条目，执行安全路径边界校验与符号链接循环拦截 */
-function collectEntries(dir, baseDir = dir, visited = new Set()) {
+import { traverseDirectory } from "@actiondock/core/project";
+/**
+ * 递归收集目录内全部条目。
+ * 目录遍历统一复用 core 的 traverseDirectory 单一事实源，
+ * 自带安全路径边界校验、软链接越界跳过与循环拦截。
+ */
+function collectEntries(dir) {
     if (!existsSync(dir))
         return [];
-    if (visited.size === 0) {
-        try {
-            visited.add(existsSync(baseDir) ? realpathSync(baseDir) : baseDir);
-        }
-        catch {
-            // 忽略
-        }
-    }
-    const entries = [];
-    let names;
-    try {
-        names = readdirSync(dir).sort();
-    }
-    catch {
-        return [];
-    }
-    for (const name of names) {
-        const fullPath = join(dir, name);
-        try {
-            assertPathWithinRoot(baseDir, fullPath, "archive path");
-        }
-        catch {
-            continue;
-        }
-        let real;
-        try {
-            real = existsSync(fullPath) ? realpathSync(fullPath) : fullPath;
-        }
-        catch {
-            continue;
-        }
-        try {
-            assertPathWithinRoot(baseDir, real, "archive path");
-        }
-        catch {
-            // 忽略并跳过指向 baseDir 外部的软链接
-            continue;
-        }
-        if (visited.has(real)) {
-            continue;
-        }
-        visited.add(real);
-        try {
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-                entries.push({ relPath: relative(baseDir, fullPath).split(sep).join("/"), isDir: true });
-                entries.push(...collectEntries(fullPath, baseDir, visited));
-            }
-            else if (stat.isFile()) {
-                entries.push({ relPath: relative(baseDir, fullPath).split(sep).join("/"), isDir: false });
-            }
-        }
-        catch {
-            // 忽略无法访问或损坏的文件/符号链接
-            continue;
-        }
+    return traverseDirectory(dir, { includeDirs: true }).map((entry) => ({
+        relPath: entry.relPath,
+        isDir: entry.isDir,
+    }));
+}
+/**
+ * 归档条目可执行位启发式：bin/ 路径前缀约定为可执行产物。
+ * 与磁盘 mode 权限位任一命中即按 0755 落归档元数据。
+ */
+const EXECUTABLE_PATH_HINT = "bin/";
+/**
+ * 计算归档条目的 Unix 权限位：目录固定 0755；文件按「磁盘 mode 含执行位
+ * 或相对路径命中 bin/ 启发式」判定为 0755，其余 0644。
+ */
+function computeUnixMode(relPath, mode, isDir) {
+    if (isDir) {
+        return 0o40755;
     }
-    return entries;
+    const isExec = Boolean(mode & 0o111) ||
+        relPath.includes(EXECUTABLE_PATH_HINT) ||
+        relPath.startsWith(EXECUTABLE_PATH_HINT);
+    return isExec ? 0o100755 : 0o100644;
 }
 /* ------------------------------------------------------------------ */
 /* zip 格式写入                                                        */
@@ -88,9 +56,6 @@ function updateCrc32(crc, buf) {
     }
     return crc;
 }
-function crc32(buf) {
-    return (updateCrc32(0xffffffff, buf) ^ 0xffffffff) >>> 0;
-}
 /** Unix 毫秒时间戳转 DOS 时间格式（date/time 各 16 位） */
 export function dosDateTime(ms) {
     const d = new Date(ms);
@@ -104,104 +69,6 @@ export function dosDateTime(ms) {
     const date = ((year - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
     return { date, time };
 }
-/**
- * 将目录打包为标准 zip 归档（PKZIP APPNOTE 结构）。
- * 直接流式分块写入磁盘，避免在内存中积压全量归档内容。
- *
- * @param dir 待打包目录（目录名即归档内根文件夹名）
- * @param outPath 输出 zip 文件路径
- */
-export function createZipArchive(dir, outPath) {
-    const rootName = basename(dir);
-    const entries = collectEntries(dir);
-    const fd = openSync(outPath, "w");
-    const centralRecords = [];
-    let offset = 0;
-    try {
-        for (const entry of entries) {
-            // 归档内路径带根目录前缀；目录条目名以 / 结尾
-            const name = `${rootName}/${entry.relPath}${entry.isDir ? "/" : ""}`;
-            const nameBuf = Buffer.from(name, "utf8");
-            const stat = statSync(join(dir, entry.relPath));
-            const { date, time } = dosDateTime(stat.mtimeMs);
-            const content = entry.isDir ? Buffer.alloc(0) : readFileSync(join(dir, entry.relPath));
-            let method = 0;
-            let payload = content;
-            if (!entry.isDir && content.length > 0) {
-                const deflated = deflateRawSync(content, { level: 9 });
-                if (deflated.length < content.length) {
-                    method = 8;
-                    payload = deflated;
-                }
-            }
-            const crc = crc32(content);
-            // Local File Header（30 字节 + 文件名）
-            const local = Buffer.alloc(30);
-            local.writeUInt32LE(0x04034b50, 0);
-            local.writeUInt16LE(20, 4);
-            local.writeUInt16LE(0x0800, 6); // UTF-8 文件名标志
-            local.writeUInt16LE(method, 8);
-            local.writeUInt16LE(time, 10);
-            local.writeUInt16LE(date, 12);
-            local.writeUInt32LE(crc, 14);
-            local.writeUInt32LE(payload.length, 18);
-            local.writeUInt32LE(content.length, 22);
-            local.writeUInt16LE(nameBuf.length, 26);
-            local.writeUInt16LE(0, 28);
-            writeSync(fd, local);
-            writeSync(fd, nameBuf);
-            if (payload.length > 0) {
-                writeSync(fd, payload);
-            }
-            // Central Directory Header（46 字节 + 文件名）
-            const central = Buffer.alloc(46);
-            central.writeUInt32LE(0x02014b50, 0);
-            central.writeUInt16LE((3 << 8) | 20, 4); // version made by: Unix + ZIP 2.0
-            central.writeUInt16LE(20, 6); // version needed
-            central.writeUInt16LE(0x0800, 8);
-            central.writeUInt16LE(method, 10);
-            central.writeUInt16LE(time, 12);
-            central.writeUInt16LE(date, 14);
-            central.writeUInt32LE(crc, 16);
-            central.writeUInt32LE(payload.length, 20);
-            central.writeUInt32LE(content.length, 24);
-            central.writeUInt16LE(nameBuf.length, 28);
-            central.writeUInt16LE(0, 30); // extra len
-            central.writeUInt16LE(0, 32); // comment len
-            central.writeUInt16LE(0, 34); // disk start
-            central.writeUInt16LE(0, 36); // internal attrs
-            // 外部属性：Unix 权限左移 16 位，目录附加 MS-DOS 目录位
-            const isExec = !entry.isDir &&
-                (Boolean(stat.mode & 0o111) || entry.relPath.includes("bin/") || entry.relPath.startsWith("bin/"));
-            const fileMode = isExec ? 0o100755 : 0o100644;
-            const extAttrs = ((entry.isDir ? 0o40755 : fileMode) << 16) | (entry.isDir ? 0x10 : 0);
-            central.writeUInt32LE(extAttrs >>> 0, 38);
-            central.writeUInt32LE(offset, 42);
-            centralRecords.push({ header: Buffer.concat([central, nameBuf]), localOffset: offset });
-            offset += local.length + nameBuf.length + payload.length;
-        }
-        const centralDirOffset = offset;
-        let centralDirSize = 0;
-        for (const record of centralRecords) {
-            writeSync(fd, record.header);
-            centralDirSize += record.header.length;
-        }
-        // End of Central Directory Record（22 字节）
-        const eocd = Buffer.alloc(22);
-        eocd.writeUInt32LE(0x06054b50, 0);
-        eocd.writeUInt16LE(0, 4);
-        eocd.writeUInt16LE(0, 6);
-        eocd.writeUInt16LE(centralRecords.length, 8);
-        eocd.writeUInt16LE(centralRecords.length, 10);
-        eocd.writeUInt32LE(centralDirSize, 12);
-        eocd.writeUInt32LE(centralDirOffset, 16);
-        eocd.writeUInt16LE(0, 20); // comment len
-        writeSync(fd, eocd);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
 /**
  * 向可写流安全写入数据块，严格处理背压与流异常。
  * 当 stream.write 返回 false 时挂起等待 drain 事件触发；
@@ -267,10 +134,8 @@ export async function createZipArchiveAsync(dir, outPath) {
             const stat = statSync(fullPath);
             const { date, time } = dosDateTime(stat.mtimeMs);
             // 外部属性：Unix 权限左移 16 位，目录附加 MS-DOS 目录位
-            const isExec = !entry.isDir &&
-                (Boolean(stat.mode & 0o111) || entry.relPath.includes("bin/") || entry.relPath.startsWith("bin/"));
-            const fileMode = isExec ? 0o100755 : 0o100644;
-            const extAttrs = ((entry.isDir ? 0o40755 : fileMode) << 16) | (entry.isDir ? 0x10 : 0);
+            const fileMode = computeUnixMode(entry.relPath, stat.mode, entry.isDir);
+            const extAttrs = (fileMode << 16) | (entry.isDir ? 0x10 : 0);
             const localOffset = offset;
             const isDeflatedFile = !entry.isDir && stat.size > 0;
             const method = isDeflatedFile ? 8 : 0;
@@ -429,37 +294,6 @@ function tarHeader(path, size, mtimeSec, isDir, modeOrExec = false) {
     buf.write(" ", 155, 1, "ascii");
     return buf;
 }
-/** 将字节数补齐到 512 的整数倍 */
-function pad512(length) {
-    const rem = length % 512;
-    return rem === 0 ? Buffer.alloc(0) : Buffer.alloc(512 - rem);
-}
-/**
- * 将目录打包为标准 tar.gz 归档（USTAR + gzip）。
- *
- * @param dir 待打包目录（目录名即归档内根文件夹名）
- * @param outPath 输出 tar.gz 文件路径
- */
-export function createTarGzArchive(dir, outPath) {
-    const rootName = basename(dir);
-    const entries = collectEntries(dir);
-    const chunks = [];
-    for (const entry of entries) {
-        const path = `${rootName}/${entry.relPath}${entry.isDir ? "/" : ""}`;
-        const fullPath = join(dir, entry.relPath);
-        const stat = statSync(fullPath);
-        const content = entry.isDir ? Buffer.alloc(0) : readFileSync(fullPath);
-        const isExec = !entry.isDir &&
-            (Boolean(stat.mode & 0o111) || entry.relPath.includes("bin/") || entry.relPath.startsWith("bin/"));
-        chunks.push(tarHeader(path, content.length, Math.floor(stat.mtimeMs / 1000), entry.isDir, isExec));
-        if (!entry.isDir) {
-            chunks.push(content, pad512(content.length));
-        }
-    }
-    // 归档结尾：两个全零块
-    chunks.push(Buffer.alloc(1024));
-    writeFileSync(outPath, gzipSync(Buffer.concat(chunks), { level: 9 }));
-}
 /**
  * 将目录异步流式打包为标准 tar.gz 归档（USTAR 与 gzip 流），避免在内存中积压全量原文件与压缩内容。
  * 严格基于 Node.js 异步流背压机制与错误传播链路实现。
@@ -482,9 +316,8 @@ export async function createTarGzArchiveAsync(dir, outPath, options) {
             const path = `${rootName}/${entry.relPath}${entry.isDir ? "/" : ""}`;
             const fullPath = join(dir, entry.relPath);
             const stat = statSync(fullPath);
-            const isExec = !entry.isDir &&
-                (Boolean(stat.mode & 0o111) || entry.relPath.includes("bin/") || entry.relPath.startsWith("bin/"));
-            const header = tarHeader(path, entry.isDir ? 0 : stat.size, Math.floor(stat.mtimeMs / 1000), entry.isDir, isExec);
+            const mode = computeUnixMode(entry.relPath, stat.mode, entry.isDir);
+            const header = tarHeader(path, entry.isDir ? 0 : stat.size, Math.floor(stat.mtimeMs / 1000), entry.isDir, entry.isDir ? "0000755" : mode === 0o100755);
             await writeToStream(gzip, header);
             if (!entry.isDir && stat.size > 0) {
                 const fileStream = getReadStream(fullPath);

package/dist/build.d.ts

@@ -1,3 +1,4 @@
+export { copyPlanEntries } from "./stage-sources.js";
 import type { BuildOptions, BuildResult } from "./types.js";
 /**
  * 构建 Node.js 目录型交付产物。

package/dist/build.js

@@ -1,12 +1,16 @@
 import { createHash } from "node:crypto";
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { STANDALONE_ASYNC_UNSUPPORTED, getPackageSlug, } from "@actiondock/core";
+import { STANDALONE_ASYNC_UNSUPPORTED, } from "@actiondock/core";
+import { getPackageSlug } from "@actiondock/core/project";
 import { createZipArchiveAsync } from "./archive.js";
 import { BuilderError } from "./errors.js";
 import { collectRelativeFiles, getInternalDependencyVersion, replaceDirAtomic } from "./fs-utils.js";
 import { assertValidManifestActionIds, serializePlanManifest } from "./manifest.js";
 import { SelectionPlanner } from "./planner.js";
+import { copyPlanEntries } from "./stage-sources.js";
+import { isOwnAction } from "./types.js";
+export { copyPlanEntries } from "./stage-sources.js";
 /**
  * 检查外部依赖中声明的生命周期安装脚本。
  */
@@ -67,7 +71,7 @@ function calculateDirectoryDigest(dir) {
  */
 function generateNodeHostEntrySource(plan) {
     // 仅包自有 Action 参与 import 与注册，与产物清单保持同一事实源
-    const ownActions = plan.actions.filter((a) => !a.isExternal && !a.id.includes("/"));
+    const ownActions = plan.actions.filter((a) => isOwnAction(a));
     const imports = ownActions
         .map((act, idx) => `import action_${idx} from ${JSON.stringify(`./${act.entry.replace(/\\/g, "/")}`)};`)
         .join("\n");
@@ -101,11 +105,10 @@ function generateNodeHostEntrySource(plan) {
     return `#!/usr/bin/env node
 // AUTO-GENERATED HOST ENTRYPOINT BY ACTIONDOCK BUILDER. DO NOT EDIT.
 import {
-  createActionDockHost,
-  createActionDockTarget,
-  serveParentIpc,
+  createActionDock,
+  createNodePlatform,
 } from "@actiondock/core";
-import { createNodePlatform } from "@actiondock/runtime-node";
+import { serveParentIpc } from "@actiondock/core/server";
 ${imports}
 
 let dataDir;
@@ -127,7 +130,7 @@ for (let i = 0; i < args.length; i++) {
   }
 }
 
-const host = await createActionDockHost({
+const service = await createActionDock({
   dataDir,
   packages: [
     {
@@ -147,10 +150,10 @@ const host = await createActionDockHost({
     },
   ],
   platform: createNodePlatform({ dataDir }),
+  autoLoadCurrentProject: false,
+  scanLinkedPackages: false,
 });
-
-const target = await createActionDockTarget({ type: "local", host });
-await serveParentIpc(target);
+await serveParentIpc(service);
 `;
 }
 /**
@@ -162,11 +165,13 @@ function generateNodeSupervisorEntrySource(plan) {
 import { spawn } from "node:child_process";
 import { join } from "node:path";
 import {
-  IpcActionDockTarget,
-  StandaloneDispatcher,
-  ExitCode,
   STANDALONE_ASYNC_UNSUPPORTED,
 } from "@actiondock/core";
+import {
+  ExitCode,
+  IpcActionDockService,
+  StandaloneDispatcher,
+} from "@actiondock/core/server";
 
 const METADATA = {
   packageId: ${JSON.stringify(plan.packageId)},
@@ -232,7 +237,7 @@ const child = spawn(process.execPath, [hostScript, ...argv], {
 });
 
 // 4. 标准输出通道物理隔离与受控限流排空
-const target = new IpcActionDockTarget({
+const service = new IpcActionDockService({
   childProcess: child,
   maxDiagnosticBytes: 512 * 1024,
   maxDiagnosticRate: 64 * 1024,
@@ -244,7 +249,7 @@ const cleanup = async () => {
   if (cleanedUp) return;
   cleanedUp = true;
   try {
-    await target.close();
+    await service.close();
   } catch {}
 };
 
@@ -262,7 +267,7 @@ const dispatcher = new StandaloneDispatcher({
   packageId: METADATA.packageId,
   version: METADATA.version,
   description: METADATA.description,
-  target,
+  service,
 });
 
 try {
@@ -282,45 +287,10 @@ try {
 }
 /**
  * 拷贝 Action 源码、Playbook 规程与声明的代码文件/静态资产到暂存目录。
- * 与 serializePlanManifest 的过滤条件保持一致：跨包外部 Action 不物化进本包目录，
- * 避免产物混入外部源文件与本包入口发生非确定性覆盖。
+ * 拷贝内核统一复用 stage-sources 的 copyPlanEntries，无差异化调优时直接全量拷贝。
  */
-function stageSources(root, stagingDir, plan) {
-    // 拷贝 Action 源码文件，保留相对路径（仅拷贝包自有 Action，跨包外部依赖不物化进本包目录）
-    const relativeActionImports = [];
-    for (const act of plan.actions) {
-        if (act.isExternal || act.id.includes("/")) {
-            continue;
-        }
-        if (existsSync(act.resolvedPath)) {
-            const destFile = join(stagingDir, act.entry);
-            mkdirSync(dirname(destFile), { recursive: true });
-            copyFileSync(act.resolvedPath, destFile);
-            relativeActionImports.push(`./${act.entry.replace(/\\/g, "/")}`);
-        }
-    }
-    // 拷贝 Playbook 规程文件
-    if (plan.playbooks.length > 0) {
-        const playbooksDir = plan.playbooksDir || "playbooks";
-        const playbooksDestDir = join(stagingDir, playbooksDir);
-        mkdirSync(playbooksDestDir, { recursive: true });
-        for (const pb of plan.playbooks) {
-            if (existsSync(pb.filePath)) {
-                const destPb = join(playbooksDestDir, basename(pb.filePath));
-                copyFileSync(pb.filePath, destPb);
-            }
-        }
-    }
-    // 拷贝声明的代码文件与静态资产
-    for (const dep of plan.dependencies.modulesAndAssets) {
-        if ((dep.type === "asset" || dep.type === "module" || dep.type === "file") &&
-            existsSync(dep.resolvedPath)) {
-            const destPath = join(stagingDir, dep.path);
-            mkdirSync(dirname(destPath), { recursive: true });
-            copyFileSync(dep.resolvedPath, destPath);
-        }
-    }
-    return relativeActionImports;
+function stageSources(stagingDir, plan) {
+    return copyPlanEntries(stagingDir, plan);
 }
 /**
  * 生成裁剪后的 actiondock.json（项目元数据与清单的单一事实源）。
@@ -339,7 +309,6 @@ function writePkgJsonAndLockfiles(root, stagingDir, plan, pkgSlug) {
     // 准备锁定的生产依赖
     const productionDependencies = {
         "@actiondock/core": getInternalDependencyVersion(),
-        "@actiondock/runtime-node": getInternalDependencyVersion(),
         "@actiondock/sdk": getInternalDependencyVersion(),
     };
     for (const ext of plan.dependencies.external) {
@@ -450,7 +419,7 @@ function vendorDependencies(root, stagingDir, plan) {
         }
     }
     // 复制 ActionDock 内部依赖
-    for (const internalPkg of ["@actiondock/core", "@actiondock/sdk", "@actiondock/runtime-node"]) {
+    for (const internalPkg of ["@actiondock/core", "@actiondock/sdk"]) {
         for (const baseModules of sourceCandidates) {
             const srcDep = join(baseModules, internalPkg);
             if (existsSync(srcDep)) {
@@ -470,10 +439,6 @@ function vendorDependencies(root, stagingDir, plan) {
  * @returns 构建产物结果描述
  */
 export async function buildProject(options) {
-    // 彻底删除原有单文件二进制输出语义，明确拒绝并报错
-    if (options.target !== undefined || options.bytecode !== undefined) {
-        throw new BuilderError("Unsupported build mode: '--target' and '--bytecode' standalone single-file binary compilation have been removed in ActionDock 2.0. Directory-based Node.js builds are now the standard distribution format.", "UNSUPPORTED_BUILD_MODE");
-    }
     const root = resolve(options.projectRoot);
     const plan = SelectionPlanner.plan({
         projectRoot: root,
@@ -512,7 +477,7 @@ export async function buildProject(options) {
     mkdirSync(stagingDir, { recursive: true });
     let platformInfo;
     try {
-        stageSources(root, stagingDir, plan);
+        stageSources(stagingDir, plan);
         writeManifest(stagingDir, plan);
         writePkgJsonAndLockfiles(root, stagingDir, plan, pkgSlug);
         writeEntrypoints(stagingDir, plan);