@actiondock/builder 2.7.0 → 2.8.0

package/dist/skill/templates.js

@@ -0,0 +1,507 @@
+import { basename } from "node:path";
+function getCleanSkillMetadata(config) {
+    const cleanName = config.id.replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
+    const desc = config.description || `AI Agent skill for ${config.name} (${config.id})`;
+    return { cleanName, desc };
+}
+function renderActionListMarkdown(actions, options = {}) {
+    return actions
+        .map((a) => {
+        const aDesc = a.description ? ` - ${a.description}` : "";
+        const idLabel = options.packageId
+            ? `\`${options.packageId}/${a.id}\` (或 \`${a.id}\`)`
+            : `\`${a.id}\``;
+        const lines = [`- ${idLabel}${aDesc}`];
+        // 标注元数据解析
+        if (a.annotations && typeof a.annotations === "object") {
+            const annoList = [];
+            if (a.annotations.readOnly === true) {
+                annoList.push("只读操作");
+            }
+            if (a.annotations.destructive === true) {
+                annoList.push("破坏性操作（执行前须向用户确认）");
+            }
+            if (annoList.length > 0) {
+                lines.push(`  - 属性标注: ${annoList.join(", ")}`);
+            }
+        }
+        // 输入参数模式解析
+        if (a.inputSchema &&
+            typeof a.inputSchema === "object" &&
+            a.inputSchema.properties) {
+            const props = a.inputSchema.properties;
+            const req = (a.inputSchema.required || []);
+            const propKeys = Object.keys(props);
+            if (propKeys.length > 0) {
+                lines.push("  - 输入参数:");
+                for (const k of propKeys) {
+                    const p = props[k] || {};
+                    const typeStr = p.type ? `\`${p.type}\`` : "`any`";
+                    const reqStr = req.includes(k) ? ", 必填" : "";
+                    const descStr = p.description ? `: ${p.description}` : "";
+                    const defStr = p.default !== undefined
+                        ? ` (默认值: \`${JSON.stringify(p.default)}\`)`
+                        : "";
+                    lines.push(`    - \`${k}\` (${typeStr}${reqStr})${descStr}${defStr}`);
+                }
+            }
+            else {
+                lines.push("  - 输入参数: 无");
+            }
+        }
+        else {
+            lines.push("  - 输入参数: 无");
+        }
+        // 输出字段模式解析
+        if (a.outputSchema &&
+            typeof a.outputSchema === "object" &&
+            a.outputSchema.properties) {
+            const outProps = a.outputSchema.properties;
+            const outKeys = Object.keys(outProps);
+            if (outKeys.length > 0) {
+                lines.push("  - 输出字段:");
+                for (const k of outKeys) {
+                    const p = outProps[k] || {};
+                    const typeStr = p.type ? `\`${p.type}\`` : "`any`";
+                    const descStr = p.description ? `: ${p.description}` : "";
+                    lines.push(`    - \`${k}\` (${typeStr})${descStr}`);
+                }
+            }
+        }
+        return lines.join("\n");
+    })
+        .join("\n\n");
+}
+function renderPlaybookSectionMarkdown(playbooks, playbooksDir = "playbooks") {
+    if (playbooks.length === 0)
+        return "";
+    const normalizedDir = playbooksDir.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+    const list = playbooks
+        .map((p) => {
+        const rel = `./${normalizedDir}/${basename(p.filePath)}`;
+        return `- **${p.id}** (\`${rel}\`): ${p.description || "业务操作指南"}`;
+    })
+        .join("\n");
+    return `
+## 业务操作规程
+
+> [!IMPORTANT]
+> **规程优先准则**：当处理复合业务任务时，智能体必须优先检查是否存在匹配场景的 Playbook。若存在规程，必须优先查阅并严格遵循规程界定的步骤时序与校验逻辑推进，严禁无序拼凑调用底层 Action。
+
+Playbook SOPs 为复杂业务任务提供逐步指导规程。详细规程请查阅对应文档：
+
+${list}
+`;
+}
+/**
+ * 渲染「结构化响应解析」小节：三处生成器共用同一 JSON 信封代码块，
+ * 仅首行名词与 stdout/stderr 描述行随变体分化。
+ */
+function renderJsonEnvelopeSection(wording, options) {
+    const noun = wording === "envelope" ? "信封" : "结果";
+    const stdoutLine = wording === "envelope"
+        ? "- `stdout`：标准 JSON 信封结果。当 `ok` 为 `true` 时，从 `data` 提取业务返回值推进后续步骤；当 `ok` 为 `false` 时，从 `error` 提取错误码与信息以判定自愈策略或上报。"
+        : "- `stdout`：标准 JSON 结果信封。当 `ok` 为 `true` 时，从 `data` 提取业务数据；当 `ok` 为 `false` 时，从 `error` 读取错误原因以处理异常。";
+    const stderrTail = wording === "envelope" ? "跟踪" : "";
+    const descriptionBlock = options?.withDescriptions === false
+        ? ""
+        : `\n\n${stdoutLine}\n- \`stderr\`：执行日志与诊断${stderrTail}信息。`;
+    return `### 结构化响应解析
+
+所有 Action 执行结果均在 \`stdout\` 输出标准格式的 JSON ${noun}：
+
+\`\`\`json
+// 执行成功响应 (ok 为 true)
+{
+  "ok": true,
+  "runId": "01J...",
+  "data": { ... }
+}
+
+// 执行失败响应 (ok 为 false)
+{
+  "ok": false,
+  "runId": "01J...",
+  "error": {
+    "code": "ACTION_EXECUTION_FAILED",
+    "message": "错误详细描述信息"
+  }
+}
+\`\`\`${descriptionBlock}`;
+}
+/**
+ * 渲染「故障排查与环境安装指引」整节：source 与 composite 共用完整安装指引，
+ * 差异点（依赖安装步骤标题、重新链接步骤标题、复合链接语义说明）通过参数分化。
+ */
+function renderTroubleshootingSection(options) {
+    const relinkNote = options.compositeLinkNote
+        ? `\n  \`ad link\` 会自动识别并注册工作区下的所有子包，使其中的 Action 随时可以通过完全限定标识调用。`
+        : "";
+    return `---
+
+## 故障排查与环境安装指引（按需查阅）
+
+> [!NOTE]
+> **按需排查原则**：默认宿主环境中已预置 \`ad\` 命令行工具与 Node.js 运行环境。正常执行流程直接调用上述 Action 即可，**严禁在任务启动前盲目进行前置环境检查或体检**；仅在终端明确报错提示命令不存在（如 \`ad: command not found\`）或提示依赖缺失时，方可按本节指引安装初始化。
+
+### 命令行工具与环境依赖未就绪时的安装指引
+
+若宿主环境未安装 \`ad\` 命令行工具或依赖缺失，请依次按如下步骤完成安装：
+
+- **环境要求**：Node.js 版本大于等于 24.12.0（执行 \`node -v\` 确认）。
+- **全局安装 ActionDock 命令行工具**：
+  \`\`\`bash
+  npm install -g @actiondock/cli
+  \`\`\`
+- **${options.dependencyStepLabel}**：
+  若在技能目录内调用时提示模块缺失，在 \`<skill_root>\` 目录下安装生产依赖：
+  \`\`\`bash
+  cd "<skill_root>" && npm install --omit=dev
+  \`\`\`
+- **验证工具就绪**：
+  \`\`\`bash
+  ad --version
+  \`\`\`
+- **环境诊断与体检**：
+  安装完成后若仍遇到异常，执行体检命令排查：
+  \`\`\`bash
+  ad doctor
+  \`\`\`
+- **${options.relinkStepLabel}**：
+  \`\`\`bash
+  ad link "<skill_root>"
+  \`\`\`${relinkNote}`;
+}
+export function generateSourceSkillMd(config, actions, playbooks) {
+    const { cleanName, desc } = getCleanSkillMetadata(config);
+    const pkgId = config.id;
+    const firstAction = actions[0]?.id || "sample.greet";
+    const playbookSection = renderPlaybookSectionMarkdown(playbooks, config.playbooksDir || "playbooks");
+    const actionListMd = renderActionListMarkdown(actions, { packageId: pkgId });
+    return `---
+name: ${cleanName}
+description: ${desc}
+---
+
+# ${config.name} (${config.id})
+
+${desc}
+
+## ActionDock 运行时
+
+本技能为 **ActionDock 源码型技能包**。智能体可直接通过宿主环境中已安装的 ActionDock 命令行工具 \`ad\` 执行其中的 Action。
+
+### 注册与链接
+
+在初次调用或初始化时，将包含本 \`SKILL.md\` 的目录解析为 \`<skill_root>\` 并完成注册：
+
+\`\`\`bash
+ad link "<skill_root>"
+\`\`\`
+
+> \`ad link\` 天然具备幂等性，同一 Package 多次执行会直接更新路径，可安全重复调用。若初次运行提示依赖缺失，可在 \`<skill_root>\` 目录下执行 \`npm install --omit=dev\` 安装生产依赖。
+
+### 动作参数契约按需调阅
+
+在调用未知参数的 Action 前，可在终端执行命令查阅该 Action 的输入输出模式与详细说明：
+
+\`\`\`bash
+ad describe ${pkgId}/${firstAction}
+\`\`\`
+
+### 执行 Action
+
+为避免多技能之间的 Action ID 命名冲突，建议统一使用带有 Package 前缀的完全限定 ID。
+
+推荐在执行前调用 describe 命令调阅确切参数契约：
+
+\`\`\`bash
+# 调阅参数契约与建议赋值样例
+ad describe ${pkgId}/${firstAction}
+
+# 调用语法格式（其中 ASSIGNMENT 根据 ad describe 查阅的参数契约提供）
+ad run ${pkgId}/${firstAction} --json -- ASSIGNMENT...
+\`\`\`
+
+将参数写入 JSON 文件并通过 --input-file 传递：
+
+\`\`\`bash
+ad run ${pkgId}/${firstAction} --json --input-file input.json
+\`\`\`
+
+> 免注册本地执行：
+> 若工作目录已位于本技能根目录，亦可直接免 link 执行：
+> \`\`\`bash
+> cd <skill_root>
+> ad run ${firstAction} --json
+> \`\`\`
+
+${renderJsonEnvelopeSection("envelope")}
+${playbookSection}
+---
+
+## Action 目录
+
+${actionListMd}
+
+---
+
+## 运行时配置与持久化状态
+
+如需检查或配置该 Package 的运行时参数与持久化数据：
+
+\`\`\`bash
+# 查看与设置配置项
+ad config list --package ${pkgId}
+ad config set KEY VALUE --package ${pkgId}
+
+# 查看与检索状态数据
+ad state list --package ${pkgId}
+ad state get KEY --package ${pkgId}
+\`\`\`
+
+${renderTroubleshootingSection({
+        dependencyStepLabel: "安装技能源码依赖",
+        relinkStepLabel: "完成安装后重新链接本技能",
+    })}
+`;
+}
+export function generateStandaloneSkillMd(config, actions, playbooks, binaryRelPath = "./bin/action-bin") {
+    const { cleanName, desc } = getCleanSkillMetadata(config);
+    const firstAction = actions[0]?.id || "sample.greet";
+    const playbookSection = renderPlaybookSectionMarkdown(playbooks, config.playbooksDir || "playbooks");
+    const actionListMd = renderActionListMarkdown(actions);
+    return `---
+name: ${cleanName}
+description: ${desc}
+---
+
+# ${config.name} (${config.id})
+
+${desc}
+
+
+### 动作参数契约按需调阅
+
+在调用未知参数的 Action 前，可在终端执行命令查阅该 Action 的输入输出模式与详细说明：
+
+\`\`\`bash
+${binaryRelPath} describe ${firstAction}
+\`\`\`
+
+### 执行 Action
+
+推荐在执行前调用 describe 命令调阅确切参数契约：
+
+\`\`\`bash
+# 调阅参数契约与建议赋值样例
+${binaryRelPath} describe ${firstAction}
+
+# 调用语法格式（其中 ASSIGNMENT 根据 describe 查阅的参数契约提供）
+${binaryRelPath} run ${firstAction} --json -- ASSIGNMENT...
+\`\`\`
+
+将参数写入 JSON 文件并通过 --input-file 传递：
+
+\`\`\`bash
+${binaryRelPath} run ${firstAction} --json --input-file input.json
+\`\`\`
+
+${renderJsonEnvelopeSection("result")}
+${playbookSection}
+---
+
+## Action 目录
+
+${actionListMd}
+
+---
+
+## 运行时配置与持久化状态
+
+程序会自动管理其 SQLite 数据库。如需检查或配置：
+
+\`\`\`bash
+# 查看与设置配置项
+${binaryRelPath} config list
+${binaryRelPath} config set KEY VALUE
+
+# 查看与检索状态数据
+${binaryRelPath} state list
+${binaryRelPath} state get KEY
+\`\`\`
+
+---
+
+## 故障排查与依赖自愈指引（按需查阅）
+
+若在宿主环境中执行时提示模块缺失，在技能根目录下安装生产依赖：
+
+\`\`\`bash
+npm install --omit=dev
+\`\`\`
+`;
+}
+export const COMPOSITE_CUSTOM_SLOTS = [
+    "intro",
+    "after-init",
+    "after-describe",
+    "after-actions",
+    "after-playbooks",
+    "after-invoke",
+    "append",
+];
+/** 工作区内约定俗成的复合技能自定义说明书文件名。 */
+export const COMPOSITE_CUSTOM_DECLARATION_FILE = "SKILL.custom.md";
+const CUSTOM_SLOT_MARKER_PATTERN = /^\s*<!--\s*actiondock:slot\s+([a-zA-Z][a-zA-Z0-9-]*)\s*-->\s*$/;
+/**
+ * 解析自定义说明书正文：以 `<!-- actiondock:slot <name> -->` 标记行分段。
+ * 首个标记之前的内容归入 `append` 槽位；未知槽位名直接抛错，避免拼写错误被静默吞掉。
+ */
+export function parseCustomSections(source) {
+    const sections = [];
+    let currentSlot = "append";
+    let buffer = [];
+    const flush = () => {
+        const content = buffer.join("\n").trim();
+        buffer = [];
+        if (content) {
+            sections.push({ slot: currentSlot, content });
+        }
+    };
+    for (const line of source.split(/\r?\n/)) {
+        const match = line.match(CUSTOM_SLOT_MARKER_PATTERN);
+        if (match) {
+            flush();
+            const slot = match[1];
+            if (!COMPOSITE_CUSTOM_SLOTS.includes(slot)) {
+                throw new Error(`Unknown ActionDock custom slot '${match[1]}'. Valid slots: ${COMPOSITE_CUSTOM_SLOTS.join(", ")}`);
+            }
+            currentSlot = slot;
+            continue;
+        }
+        buffer.push(line);
+    }
+    flush();
+    return sections;
+}
+/**
+ * 解析复合技能自定义说明书文件：支持 YAML frontmatter 中的 `description` 覆盖，
+ * 正文按槽位标记解析为自定义段落。
+ */
+export function parseCustomSkillDeclaration(source) {
+    let body = source;
+    let description;
+    const frontmatter = source.match(/^\uFEFF?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/);
+    if (frontmatter) {
+        body = source.slice(frontmatter[0].length);
+        const descLine = frontmatter[1].match(/^description:[ \t]*(.+?)[ \t]*$/m);
+        if (descLine) {
+            description = descLine[1].replace(/^["']|["']$/g, "");
+        }
+    }
+    return { description, sections: parseCustomSections(body) };
+}
+/**
+ * 生成多包聚合的复合模式 SKILL.md 文档。
+ */
+export function generateCompositeSkillMd(bundleName, description, packages, options) {
+    const cleanName = bundleName.replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
+    const samplePkg = packages.find((p) => p.actions && p.actions.length > 0);
+    const sampleActionId = samplePkg
+        ? `${samplePkg.config.id}/${samplePkg.actions[0].id}`
+        : "sample.greet";
+    const actionSections = packages
+        .map((pkg) => {
+        const actList = pkg.actions
+            .map((a) => {
+            const desc = a.description ? `: ${a.description}` : "";
+            return `- \`${pkg.config.id}/${a.id}\`${desc}`;
+        })
+            .join("\n");
+        return `### ${pkg.config.name} (${pkg.config.id})\n${actList || "- 无可用 Action"}`;
+    })
+        .join("\n\n");
+    const playbookEntries = [];
+    const packagesBaseDir = options?.packagesBaseDir ?? "packages";
+    for (const pkg of packages) {
+        for (const pb of pkg.playbooks) {
+            const relPath = packagesBaseDir === "."
+                ? `./${pkg.packageDir}/playbooks/${basename(pb.filePath)}`
+                : `packages/${pkg.packageDir}/playbooks/${basename(pb.filePath)}`;
+            playbookEntries.push(`- [${pb.name || pb.id}](${relPath}): ${pb.description || "标准操作规程"}`);
+        }
+    }
+    const sIntro = `---
+name: ${cleanName}
+description: ${description}
+---
+
+# ${bundleName} 复合技能套件
+
+${description}`;
+    const sDescribe = `## 动作参数契约按需调阅
+
+为节省上下文开销，各 Action 的详细参数结构不静态内嵌在说明书中。在调用未知参数的 Action 前，可在终端执行命令查阅输入输出约束：
+
+\`\`\`bash
+ad describe ${sampleActionId}
+\`\`\``;
+    const sActions = `## 可用 Action 工具清单
+
+${actionSections}
+
+---`;
+    const sPlaybooks = playbookEntries.length > 0
+        ? `## 推荐操作规程
+
+涉及多步骤或业务流程时，优先遵循以下原位规程：
+
+${playbookEntries.join("\n")}
+
+---`
+        : "";
+    const sInvoke = `## 标准调用命令
+ 
+推荐在执行前调用 describe 命令调阅确切参数契约：
+
+\`\`\`bash
+# 调阅参数契约与建议赋值样例
+ad describe ${sampleActionId}
+
+# 调用语法格式（其中 ASSIGNMENT 根据 ad describe 查阅的参数契约提供）
+ad run ${sampleActionId} --json -- ASSIGNMENT...
+\`\`\`
+ 
+将参数写入 JSON 文件并通过 --input-file 传递：
+ 
+\`\`\`bash
+ad run ${sampleActionId} --json --input-file input.json
+\`\`\`
+
+${renderJsonEnvelopeSection("envelope", { withDescriptions: false })}`;
+    const sTroubleshooting = renderTroubleshootingSection({
+        dependencyStepLabel: "安装复合技能聚合依赖",
+        relinkStepLabel: "完成安装后重新链接复合技能",
+        compositeLinkNote: true,
+    });
+    const parts = [
+        { slot: "intro", text: sIntro },
+        { slot: "after-describe", text: sDescribe },
+        { slot: "after-actions", text: sActions },
+        { slot: "after-playbooks", text: sPlaybooks },
+        { slot: "after-invoke", text: sInvoke },
+        { slot: "after-init", text: sTroubleshooting },
+        { slot: "append", text: "" },
+    ];
+    // 自定义段落按文件顺序插入到对应槽位（倒序插入保证同槽位多段保持先后）
+    const customSections = options?.customSections ?? [];
+    for (const section of [...customSections].reverse()) {
+        const anchorIndex = parts.findIndex((p) => p.slot === section.slot);
+        parts.splice(anchorIndex + 1, 0, { slot: section.slot, text: section.content });
+    }
+    return (parts
+        .filter((p) => p.text.trim().length > 0)
+        .map((p) => p.text.trim())
+        .join("\n\n") + "\n");
+}

package/dist/skill-md.d.ts

@@ -1,4 +1,5 @@
-import { type CompositeCustomDeclaration, type PlaybookDefinition, type ProjectConfig, type SkillActionItem } from "@actiondock/core";
+import { type PlaybookDefinition, type ProjectConfig } from "@actiondock/core/project";
+import { type CompositeCustomDeclaration, type SkillActionItem } from "./skill/index.js";
 import type { CompositeSkillExportOptions, SelectionPlan } from "./types.js";
 /**
  * SKILL.md 发现、复用与模板视图适配层。

package/dist/skill-md.js

@@ -1,6 +1,7 @@
 import { copyFileSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { COMPOSITE_CUSTOM_DECLARATION_FILE, parseCustomSkillDeclaration, getPackageSlug, } from "@actiondock/core";
+import { getPackageSlug, } from "@actiondock/core/project";
+import { COMPOSITE_CUSTOM_DECLARATION_FILE, parseCustomSkillDeclaration, } from "./skill/index.js";
 import { BuilderError } from "./errors.js";
 /**
  * 将规划产物中的 Action 列表适配为模板所需的 SkillActionItem 视图。

package/dist/stage-sources.d.ts

@@ -0,0 +1,25 @@
+import type { ActionDependency, AssetDependency, PlaybookPlanEntry, SelectionPlan } from "./types.js";
+/**
+ * stageSources 共享拷贝内核。
+ *
+ * build 与 pack 两个同名 stageSources 的拷贝循环（Action 入口、Playbook、
+ * modulesAndAssets）重叠约七成，差异仅在编译排除与目标路径细节；
+ * 本模块收敛为单一拷贝实现，各链路通过谓词与目标路径计算函数分化差异，
+ * 产物文件清单保持不变。
+ */
+/**
+ * 共享拷贝内核选项：各链路仅通过谓词分化差异。
+ */
+export interface CopyPlanEntriesOptions {
+    /** Action 入口拷贝谓词（如 build 拷贝全部自有入口、pack 仅拷贝非 TypeScript 入口） */
+    copyAction?: (action: ActionDependency) => boolean;
+    /** modulesAndAssets 拷贝谓词（如 pack 跳过已编译的 TypeScript 模块） */
+    copyModule?: (dep: AssetDependency) => boolean;
+    /** Playbook 目标相对路径计算（build 收敛到 playbooksDir，pack 保留源工程相对路径） */
+    playbookRelPath?: (playbook: PlaybookPlanEntry) => string;
+}
+/**
+ * stageSources 共享拷贝内核：Action 入口、Playbook 规程、modulesAndAssets 三类条目的统一物化。
+ * 返回已拷贝 Action 入口的相对导入说明符清单（build 的入口生成使用，pack 忽略）。
+ */
+export declare function copyPlanEntries(stagingDir: string, plan: SelectionPlan, options?: CopyPlanEntriesOptions): string[];

package/dist/stage-sources.js

@@ -0,0 +1,51 @@
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { isOwnAction } from "./types.js";
+/** 拷贝单个文件到目标相对路径，自动创建父目录 */
+function copyPlanFile(stagingDir, srcPath, relPath) {
+    const destPath = join(stagingDir, relPath);
+    mkdirSync(dirname(destPath), { recursive: true });
+    copyFileSync(srcPath, destPath);
+}
+/**
+ * stageSources 共享拷贝内核：Action 入口、Playbook 规程、modulesAndAssets 三类条目的统一物化。
+ * 返回已拷贝 Action 入口的相对导入说明符清单（build 的入口生成使用，pack 忽略）。
+ */
+export function copyPlanEntries(stagingDir, plan, options = {}) {
+    // 拷贝 Action 源码文件，保留相对路径（仅拷贝包自有 Action，跨包外部依赖不物化进本包目录）
+    const relativeActionImports = [];
+    for (const act of plan.actions) {
+        if (!isOwnAction(act)) {
+            continue;
+        }
+        if (options.copyAction && !options.copyAction(act)) {
+            continue;
+        }
+        if (existsSync(act.resolvedPath)) {
+            copyPlanFile(stagingDir, act.resolvedPath, act.entry);
+            relativeActionImports.push(`./${act.entry.replace(/\\/g, "/")}`);
+        }
+    }
+    // 拷贝 Playbook 规程文件
+    if (plan.playbooks.length > 0) {
+        const defaultPlaybooksDir = plan.playbooksDir || "playbooks";
+        for (const pb of plan.playbooks) {
+            if (!existsSync(pb.filePath)) {
+                continue;
+            }
+            const relPath = options.playbookRelPath
+                ? options.playbookRelPath(pb)
+                : join(defaultPlaybooksDir, basename(pb.filePath));
+            copyPlanFile(stagingDir, pb.filePath, relPath);
+        }
+    }
+    // 拷贝声明的代码文件与静态资产
+    for (const dep of plan.dependencies.modulesAndAssets) {
+        if ((dep.type === "asset" || dep.type === "module" || dep.type === "file") &&
+            existsSync(dep.resolvedPath) &&
+            (!options.copyModule || options.copyModule(dep))) {
+            copyPlanFile(stagingDir, dep.resolvedPath, dep.path);
+        }
+    }
+    return relativeActionImports;
+}

package/dist/types.d.ts

@@ -1,4 +1,5 @@
-import type { ActionDockManifest, ProjectConfig } from "@actiondock/core";
+import type { ProjectConfig } from "@actiondock/core";
+import type { ActionDockManifest } from "@actiondock/core/project";
 /**
  * 规划输入侧的项目配置扩展字段。
  * actiondock.json 实际承载 uses、files、assets 等扩展声明，
@@ -37,6 +38,14 @@ export interface ActionDependency {
     /** 扩展注解 */
     annotations?: Record<string, unknown>;
 }
+/**
+ * 判定 Action 是否为当前包自有（非外部依赖包且 ID 不含跨包斜杠前缀）。
+ *
+ * 产物契约核心谓词：入口生成、清单序列化、源码物化、导出统计等全部链路
+ * 必须经由此单一事实源判定，避免外部标记与斜杠 ID 双条件在某处漏改一半
+ * 导致孤儿模块或清单漂移。
+ */
+export declare function isOwnAction(action: Pick<ActionDependency, "id" | "isExternal">): boolean;
 /**
  * 资产或模块依赖描述。
  */
@@ -196,20 +205,6 @@ export interface BuildOptions {
     manifest?: ActionDockManifest;
     /** 是否跳过本地相对依赖完整性校验（默认 false） */
     skipDependencyValidation?: boolean;
-    /**
-     * 已移除的单文件二进制输出目标平台参数。
-     * 若传入将抛出 UNSUPPORTED_BUILD_MODE 错误。
-     */
-    target?: string;
-    /**
-     * 已移除的字节码预编译参数。
-     * 若传入将抛出 UNSUPPORTED_BUILD_MODE 错误。
-     */
-    bytecode?: boolean;
-    /**
-     * 代码混淆选项（历史遗留占位字段，目录型构建不再读取）。
-     */
-    minify?: boolean;
 }
 /**
  * 目录型构建产物结果描述。
@@ -326,15 +321,11 @@ export interface SkillExporterOptions {
     customMdPath?: string;
     /** 所属 Workspace 根目录（可选） */
     workspaceRoot?: string;
-    /**
-     * 已废弃的独立单文件编译选项。
-     * 若传入将抛出替代方案提示或错误。
-     */
-    standalone?: boolean;
-    target?: string;
-    bytecode?: boolean;
-    minify?: boolean;
 }
+/**
+ * 导出 Skill 选项契约（对齐标准接口命名）。
+ */
+export type ExportSkillOptions = SkillExporterOptions;
 /**
  * Skill 导出完成结果。
  */
@@ -362,6 +353,10 @@ export interface SkillExportResult {
     /** 若复用了已有的 SKILL.md 文件，返回该文件的绝对路径 */
     usedExistingSkillMd?: string;
 }
+/**
+ * 导出 Skill 结果契约（对齐标准接口命名）。
+ */
+export type ExportSkillResult = SkillExportResult;
 /**
  * 批量 Skill 导出选项。
  */

package/dist/types.js

@@ -1 +1,10 @@
-export {};
+/**
+ * 判定 Action 是否为当前包自有（非外部依赖包且 ID 不含跨包斜杠前缀）。
+ *
+ * 产物契约核心谓词：入口生成、清单序列化、源码物化、导出统计等全部链路
+ * 必须经由此单一事实源判定，避免外部标记与斜杠 ID 双条件在某处漏改一半
+ * 导致孤儿模块或清单漂移。
+ */
+export function isOwnAction(action) {
+    return !action.isExternal && !action.id.includes("/");
+}