@actiondock/core 2.13.0 → 2.15.0

package/dist/catalog/discovery.d.ts

@@ -1,4 +1,4 @@
-import type { ActionDockManifest } from "../project/types.js";
+import type { ActionDockManifest, PlaybookSourceManifest } from "../project/types.js";
 import type { PackageIdentity } from "../runtime/identity.js";
 /**
  * 发现的包基本信息规范。
@@ -8,8 +8,8 @@ export interface DiscoveredPackage {
     readonly id: string;
     /** 包物理根目录绝对路径 */
     readonly root: string;
-    /** 包清单定义 */
-    readonly manifest: ActionDockManifest;
+    /** 包清单定义（支持磁盘声明式清单与运行时规程来源清单） */
+    readonly manifest: ActionDockManifest | PlaybookSourceManifest;
     /** 包物理与快照身份凭证（可选，由已有运行时传入） */
     readonly identity?: PackageIdentity;
     /** 是否来自工作区目录扫描发现 */

package/dist/catalog/graph.d.ts

@@ -1,15 +1,11 @@
 import { ActionDockError } from "../errors.js";
 import { type ActionDockLockfile } from "../project/lockfile.js";
-import type { ActionDockManifest, PlaybookDefinition } from "../project/types.js";
+import type { ActionDockManifest, PlaybookDefinition, PlaybookSourceManifest } from "../project/types.js";
 import { type PackageIdentity } from "../runtime/identity.js";
 import { parseSemVer, type SemVer } from "../utils/index.js";
 import { type DiscoveredPackage, type PackageDiscoveryOptions } from "./discovery.js";
 export type { SemVer };
 export { parseSemVer };
-/**
- * 校验两个语义化版本范围是否兼容并能收敛为单一解析版本。
- * 遵循设计规范：直接或传递版本范围无法收敛时拒绝并抛出 ACTION_PACKAGE_VERSION_CONFLICT。
- */
 export declare function areVersionsCompatible(v1: string, v2: string): boolean;
 /**
  * 版本冲突错误。
@@ -55,8 +51,8 @@ export interface PackageNode {
     readonly packageId: string;
     /** 包根目录绝对物理路径 */
     readonly root: string;
-    /** 包清单规范 */
-    readonly manifest: ActionDockManifest;
+    /** 包清单规范（支持磁盘声明式清单与运行时规程来源清单） */
+    readonly manifest: ActionDockManifest | PlaybookSourceManifest;
     /** 包清单摘要哈希 */
     readonly manifestDigest: string;
     /** 包版本号 */
@@ -145,12 +141,14 @@ export declare class DefaultPackageGraph implements PackageGraph {
 export interface PackageGraphBuilderOptions {
     /** 预先发现的包集合，若未提供则通过 PackageDiscovery 自动发现 */
     packages?: DiscoveredPackage[];
+    /** 完整显式集合的依赖存在性与选定版本校验（Host 增量注册时不启用）。 */
+    validateDependencies?: boolean;
     /** 根工程根目录或根包标识（与 projectRoot 互为别名） */
     root?: string;
     /** 当前工程根目录绝对或相对物理路径 */
     projectRoot?: string;
     /** 显式根清单 */
-    manifest?: ActionDockManifest;
+    manifest?: ActionDockManifest | PlaybookSourceManifest;
     /** 锁文件规范对象（若未显式提供且 projectRoot 存在，则尝试自动读取 actiondock.lock.json） */
     lockfile?: ActionDockLockfile;
     /** 是否允许扫描与链接开发软链接包（默认根据 discoveryOptions 判定） */

package/dist/catalog/graph.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { ActionDockError, ACTION_PACKAGE_VERSION_CONFLICT, MANIFEST_DIGEST_MISMATCH, MANIFEST_NOT_FOUND, MANIFEST_READ_FAILED, PACKAGE_NOT_FOUND, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
+import { ActionDockError, ACTION_PACKAGE_VERSION_CONFLICT, MANIFEST_DIGEST_MISMATCH, MANIFEST_NOT_FOUND, MANIFEST_READ_FAILED, PACKAGE_NOT_FOUND, PACKAGE_ID_CONFLICT, INVALID_ARGUMENT, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
 import { computeManifestDigest, parseJsonWithoutDuplicates } from "../project/digest.js";
 import { loadLockfile } from "../project/lockfile.js";
 import { loadPlaybooks, loadProjectConfig } from "../project/loader.js";
@@ -10,30 +10,124 @@ import { createPackageIdentity } from "../runtime/identity.js";
 import { parseSemVer } from "../utils/index.js";
 import { PackageDiscovery } from "./discovery.js";
 export { parseSemVer };
-/**
- * 校验两个语义化版本范围是否兼容并能收敛为单一解析版本。
- * 遵循设计规范：直接或传递版本范围无法收敛时拒绝并抛出 ACTION_PACKAGE_VERSION_CONFLICT。
- */
-export function areVersionsCompatible(v1, v2) {
-    if (v1 === v2 || v1 === "*" || v2 === "*" || !v1 || !v2) {
-        return true;
+/** 有限版本契约：严格三段版本（允许 v/= 前缀）、^、~、*；不猜测其他范围。 */
+function parseVersionRange(value) {
+    const text = value.trim();
+    if (!text || text === "*")
+        return {};
+    const prefix = text[0];
+    const minimum = parseSemVer(prefix === "^" || prefix === "~" ? text.slice(1) : text);
+    if (!minimum)
+        return undefined;
+    if (prefix !== "^" && prefix !== "~")
+        return { minimum, exact: true };
+    const maximum = prefix === "~"
+        ? { major: minimum.major, minor: minimum.minor + 1, patch: 0 }
+        : minimum.major > 0 ? { major: minimum.major + 1, minor: 0, patch: 0 }
+            : minimum.minor > 0 ? { major: 0, minor: minimum.minor + 1, patch: 0 }
+                : { major: 0, minor: 0, patch: minimum.patch + 1 };
+    return { minimum, maximum };
+}
+function compareVersions(a, b) {
+    const core = a.major - b.major || a.minor - b.minor || a.patch - b.patch;
+    if (core)
+        return core;
+    if (a.prerelease === b.prerelease)
+        return 0;
+    if (a.prerelease === undefined)
+        return 1;
+    if (b.prerelease === undefined)
+        return -1;
+    const left = a.prerelease.split(".");
+    const right = b.prerelease.split(".");
+    for (let i = 0; i < Math.max(left.length, right.length); i++) {
+        if (left[i] === undefined)
+            return -1;
+        if (right[i] === undefined)
+            return 1;
+        if (left[i] === right[i])
+            continue;
+        const numericLeft = /^\d+$/.test(left[i]);
+        const numericRight = /^\d+$/.test(right[i]);
+        if (numericLeft && numericRight)
+            return BigInt(left[i]) < BigInt(right[i]) ? -1 : 1;
+        if (numericLeft !== numericRight)
+            return numericLeft ? -1 : 1;
+        return left[i] < right[i] ? -1 : 1;
     }
-    const clean1 = v1.trim().replace(/^[\^~=]/, "");
-    const clean2 = v2.trim().replace(/^[\^~=]/, "");
-    const sem1 = parseSemVer(clean1);
-    const sem2 = parseSemVer(clean2);
-    if (!sem1 || !sem2) {
-        return v1 === v2;
+    return 0;
+}
+function satisfiesRange(version, range) {
+    if (range.exact)
+        return compareVersions(version, range.minimum) === 0;
+    if (range.minimum && compareVersions(version, range.minimum) < 0)
+        return false;
+    if (range.maximum && compareVersions(version, range.maximum) >= 0)
+        return false;
+    // 预发布版本仅在范围下界显式点名同一核心版本的预发布时纳入。
+    if (version.prerelease !== undefined) {
+        const min = range.minimum;
+        return Boolean(min?.prerelease && version.major === min.major && version.minor === min.minor && version.patch === min.patch);
     }
-    if (sem1.major !== sem2.major) {
+    return true;
+}
+export function areVersionsCompatible(v1, v2) {
+    const left = parseVersionRange(v1);
+    const right = parseVersionRange(v2);
+    if (!left || !right)
         return false;
+    const candidate = !left.minimum ? right.minimum : !right.minimum ? left.minimum
+        : compareVersions(left.minimum, right.minimum) >= 0 ? left.minimum : right.minimum;
+    if (!candidate)
+        return true;
+    if (satisfiesRange(candidate, left) && satisfiesRange(candidate, right))
+        return true;
+    // 两个范围可以在预发布下界之后的稳定版本交汇，但不能改变精确版本。
+    const stable = { major: candidate.major, minor: candidate.minor, patch: candidate.patch };
+    return satisfiesRange(stable, left) && satisfiesRange(stable, right);
+}
+/**
+ * 判定给定的依赖规格是否为不支持的语义化版本范围形态（而非获取描述）。
+ *
+ * 规则：
+ * - 范围操作符开头：^, ~, <, >, =, *；
+ * - 复合范围操作符：|| 或 - 范围；
+ * - X 范围与通配：如 1.x, 1.2.x, 1.*, 1.2.*, v1.x 等；
+ * - 不完整两段或一段版本：如 1, 1.2, v1, v1.2 等；
+ * - 版本三段式开头但未被严格解析器支持的非法形态。
+ */
+function isUnsupportedVersionRange(spec) {
+    const text = spec.trim();
+    if (!text)
+        return false;
+    if (/^[~^<>=*]/.test(text))
+        return true;
+    if (/\|\||\s+-\s+/.test(text))
+        return true;
+    if (/^v?\d+\.(?:[xX*]|\d+\.[xX*])(?:$|[-+])/.test(text))
+        return true;
+    if (/^v?\d+(?:\.\d+)?$/.test(text))
+        return true;
+    if (/^v?\d+\.\d+\.\d+/.test(text))
+        return true;
+    return false;
+}
+/** 获取描述不是版本约束；仅真实范围及锁定版本参与版本兼容校验。 */
+function dependencyVersionRequirements(spec, locked) {
+    const requirements = [];
+    const range = spec === undefined ? undefined : parseVersionRange(spec);
+    if (spec !== undefined && range)
+        requirements.push(spec);
+    else if (spec !== undefined && isUnsupportedVersionRange(spec)) {
+        throw new ActionDockError(INVALID_ARGUMENT, `Unsupported Action package version range '${spec}'; supported forms are exact versions, ^, ~ and *`);
     }
-    if (v1.startsWith("~") || v2.startsWith("~")) {
-        if (sem1.minor !== sem2.minor) {
-            return false;
-        }
+    const lockedVersion = locked?.resolved || locked?.version;
+    if (lockedVersion && parseSemVer(lockedVersion))
+        requirements.push(lockedVersion);
+    else if (lockedVersion) {
+        throw new ActionDockError(INVALID_ARGUMENT, `Invalid locked Action package version '${lockedVersion}'`);
     }
-    return true;
+    return requirements;
 }
 /**
  * 版本冲突错误。
@@ -227,30 +321,20 @@ function computeTransitiveDependencies(nodes) {
 function collectVisiblePlaybooks(rootNode, nodes) {
     const visiblePlaybooks = new Map();
     const delegatedActions = new Set();
-    if (rootNode && rootNode.root && existsSync(rootNode.root)) {
-        try {
-            const rootPbs = loadPlaybooks(rootNode.root, undefined, rootNode.manifest);
-            for (const [id, pb] of rootPbs.entries()) {
-                visiblePlaybooks.set(id, pb);
-                visiblePlaybooks.set(`${rootNode.packageId}/${id}`, pb);
-            }
-        }
-        catch {
-            // 忽略根包 Playbook 加载异常
+    if (rootNode) {
+        const rootPbs = loadPlaybooks(rootNode.root || "", undefined, rootNode.manifest);
+        for (const [id, pb] of rootPbs.entries()) {
+            visiblePlaybooks.set(id, pb);
+            visiblePlaybooks.set(`${rootNode.packageId}/${id}`, pb);
         }
         for (const depId of rootNode.directDependencies) {
             if (depId === rootNode.packageId)
                 continue;
             const depNode = nodes.get(depId);
-            if (depNode && depNode.root && existsSync(depNode.root)) {
-                try {
-                    const depPbs = loadPlaybooks(depNode.root, undefined, depNode.manifest);
-                    for (const [id, pb] of depPbs.entries()) {
-                        visiblePlaybooks.set(`${depId}/${id}`, pb);
-                    }
-                }
-                catch {
-                    // 忽略依赖包 Playbook 加载异常
+            if (depNode) {
+                const depPbs = loadPlaybooks(depNode.root || "", undefined, depNode.manifest);
+                for (const [id, pb] of depPbs.entries()) {
+                    visiblePlaybooks.set(`${depId}/${id}`, pb);
                 }
             }
         }
@@ -280,13 +364,16 @@ export class PackageGraphBuilder {
      */
     buildFromPackages(nodes, generation) {
         for (const pkg of this.options.packages) {
+            if (nodes.has(pkg.id)) {
+                throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID '${pkg.id}' occurs more than once in explicit package graph`);
+            }
             const fields = createPackageNodeFields({
                 id: pkg.id,
                 root: pkg.root,
                 manifest: pkg.manifest,
                 npmPackage: pkg.id,
                 isDirect: Boolean(pkg.isCurrentProject),
-                isRoot: Boolean(pkg.isCurrentProject),
+                isRoot: false,
                 identity: pkg.identity,
                 generation,
             });
@@ -308,18 +395,46 @@ export class PackageGraphBuilder {
             }
         }
         if (!rootIdentity) {
-            for (const node of nodes.values()) {
-                if (node.isRoot) {
-                    rootIdentity = node.identity;
-                    break;
-                }
+            const currentProjectNodes = Array.from(nodes.values()).filter((n) => n.isDirect);
+            if (currentProjectNodes.length === 1) {
+                rootIdentity = currentProjectNodes[0].identity;
             }
         }
-        if (rootIdentity) {
-            const rootNode = nodes.get(rootIdentity.id);
-            if (rootNode) {
-                rootNode.isRoot = true;
-                rootNode.isDirect = true;
+        for (const [id, node] of nodes) {
+            const isTheRoot = Boolean(rootIdentity && node.identity.id === rootIdentity.id);
+            nodes.set(id, { ...node, isRoot: isTheRoot, isDirect: isTheRoot || Boolean(node.isDirect) });
+        }
+        if (this.options.validateDependencies) {
+            for (const node of nodes.values()) {
+                const lockfile = node.root ? loadLockfile(node.root) : null;
+                for (const [depId, spec] of Object.entries(node.manifest.dependencies || {})) {
+                    const dep = nodes.get(depId);
+                    if (!dep) {
+                        throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${depId}' required by '${node.packageId}' is missing from explicit graph`);
+                    }
+                    for (const requirement of dependencyVersionRequirements(spec)) {
+                        if (!areVersionsCompatible(requirement, dep.version)) {
+                            throw new ActionPackageVersionConflictError(depId, [
+                                { requester: node.packageId, rangeOrVersion: requirement },
+                                { requester: depId, rangeOrVersion: dep.version },
+                            ]);
+                        }
+                    }
+                }
+                // 根锁文件也可能锁定传递依赖，不能只检查直接 dependencies。
+                for (const [depId, locked] of Object.entries(lockfile?.packages || {})) {
+                    const dep = nodes.get(depId);
+                    if (!dep)
+                        continue;
+                    for (const requirement of dependencyVersionRequirements(undefined, locked)) {
+                        if (!areVersionsCompatible(requirement, dep.version)) {
+                            throw new ActionPackageVersionConflictError(depId, [
+                                { requester: node.packageId, rangeOrVersion: requirement },
+                                { requester: depId, rangeOrVersion: dep.version },
+                            ]);
+                        }
+                    }
+                }
             }
         }
         linkDirectDependencies(nodes);
@@ -415,6 +530,13 @@ export class PackageGraphBuilder {
                     // 忽略扫描外部链接包异常
                 }
             }
+            const requesterLocks = new Map([[rootPackageId, lockfile]]);
+            const getRequesterLock = (requester) => {
+                if (!requesterLocks.has(requester)) {
+                    requesterLocks.set(requester, loadLockfile(nodes.get(requester).root));
+                }
+                return requesterLocks.get(requester);
+            };
             const versionRequirements = new Map();
             function recordRequirement(pkgId, requester, rangeOrVersion) {
                 const existing = versionRequirements.get(pkgId) || [];
@@ -429,10 +551,22 @@ export class PackageGraphBuilder {
                 existing.push({ requester, rangeOrVersion });
                 versionRequirements.set(pkgId, existing);
             }
+            const recordDependency = (pkgId, requester, spec) => {
+                const requesterLocked = getRequesterLock(requester)?.packages[pkgId];
+                for (const requirement of dependencyVersionRequirements(spec, requesterLocked)) {
+                    recordRequirement(pkgId, requester, requirement);
+                }
+                const rootLocked = lockfile?.packages[pkgId];
+                if (rootLocked && rootLocked !== requesterLocked) {
+                    for (const requirement of dependencyVersionRequirements(undefined, rootLocked)) {
+                        recordRequirement(pkgId, rootPackageId, requirement);
+                    }
+                }
+            };
             const queue = [];
             for (const [depId, spec] of Object.entries(rootManifest.dependencies || {})) {
                 rootNode.directDependencies.add(depId);
-                recordRequirement(depId, rootPackageId, spec);
+                recordDependency(depId, rootPackageId, spec);
                 queue.push({
                     pkgId: depId,
                     requester: rootPackageId,
@@ -460,7 +594,7 @@ export class PackageGraphBuilder {
                     continue;
                 }
                 let pkgDir = null;
-                const locked = lockfile?.packages?.[item.pkgId];
+                const locked = getRequesterLock(item.requester)?.packages[item.pkgId] || lockfile?.packages[item.pkgId];
                 if (packageRootsRecord?.[item.pkgId]) {
                     pkgDir = packageRootsRecord[item.pkgId];
                 }
@@ -474,7 +608,7 @@ export class PackageGraphBuilder {
                     }
                     candidateNames.push(item.rangeOrSpec);
                     candidateNames.push(item.pkgId);
-                    let cur = absProjectRoot;
+                    let cur = nodes.get(item.requester)?.root || absProjectRoot;
                     while (true) {
                         for (const candName of candidateNames) {
                             const candPath = join(cur, "node_modules", candName);
@@ -506,6 +640,9 @@ export class PackageGraphBuilder {
                     throw new ActionDockError(MANIFEST_READ_FAILED, `Failed to read manifest for '${item.pkgId}': ${err.message}`);
                 }
                 const depManifest = parseJsonWithoutDuplicates(manifestRaw);
+                if (depManifest.id !== item.pkgId) {
+                    throw new ActionDockError(PACKAGE_ID_CONFLICT, `Expected package '${item.pkgId}' at '${pkgDir}', found '${depManifest.id}'`);
+                }
                 const actualDigest = computeManifestDigest(depManifest);
                 if (locked?.manifestDigest && locked.manifestDigest !== actualDigest) {
                     throw new ActionDockError(MANIFEST_DIGEST_MISMATCH, `Manifest digest mismatch for package '${item.pkgId}': expected '${locked.manifestDigest}', got '${actualDigest}'. Re-resolution required.`);
@@ -538,15 +675,13 @@ export class PackageGraphBuilder {
                 };
                 nodes.set(item.pkgId, newNode);
                 for (const [subDepId, subSpec] of Object.entries(depManifest.dependencies || {})) {
-                    recordRequirement(subDepId, item.pkgId, subSpec);
-                    if (!nodes.has(subDepId)) {
-                        queue.push({
-                            pkgId: subDepId,
-                            requester: item.pkgId,
-                            rangeOrSpec: subSpec,
-                            isDirect: false,
-                        });
-                    }
+                    recordDependency(subDepId, item.pkgId, subSpec);
+                    queue.push({
+                        pkgId: subDepId,
+                        requester: item.pkgId,
+                        rangeOrSpec: subSpec,
+                        isDirect: false,
+                    });
                 }
             }
             if (scanLinked) {

package/dist/catalog/resolve-playbook.d.ts

@@ -20,7 +20,7 @@ export interface ResolvePlaybookContext {
     readonly caller?: string;
 }
 /**
- * 纯领域规程解析函数 resolvePlaybook。
- * 基于 PackageGraph 替代原 registry 内部的 resolvePlaybookProject 启发式搜索。
+ * 基于 PackageGraph 的规程寻址函数，正文统一由规程加载层提供。
+ * 替代原 registry 内部的 resolvePlaybookProject 启发式搜索。
  */
 export declare function resolvePlaybook(identifier: string, context: ResolvePlaybookContext): ResolvedPlaybook;

package/dist/catalog/resolve-playbook.js

@@ -1,48 +1,12 @@
-import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { loadPlaybooks } from "../project/loader.js";
 import { getPackageSlug } from "../utils/index.js";
 import { ActionDockError, INVALID_ACTION_REF, NOT_FOUND, PACKAGE_NOT_FOUND } from "../errors.js";
 function getNodePlaybooks(node) {
-    const map = new Map();
-    if (node.root && existsSync(node.root)) {
-        try {
-            const diskPlaybooks = loadPlaybooks(node.root, node.manifest?.playbooksDir);
-            for (const [k, v] of diskPlaybooks) {
-                map.set(k, v);
-            }
-        }
-        catch {
-            // 忽略磁盘规程目录扫描异常
-        }
-    }
-    if (node.manifest?.playbooks && typeof node.manifest.playbooks === "object") {
-        for (const [id, item] of Object.entries(node.manifest.playbooks)) {
-            const existing = map.get(id);
-            let content = item.content ?? existing?.content ?? "";
-            let filePath = item.entry && node.root
-                ? resolve(node.root, item.entry)
-                : existing?.filePath;
-            if (!content && filePath && existsSync(filePath)) {
-                try {
-                    content = readFileSync(filePath, "utf-8");
-                }
-                catch { }
-            }
-            map.set(id, {
-                id,
-                description: item.description ?? existing?.description,
-                actions: item.actions ?? existing?.actions ?? [],
-                content,
-                filePath: filePath || "",
-            });
-        }
-    }
-    return map;
+    return loadPlaybooks(node.root, node.manifest.playbooksDir, node.manifest);
 }
 /**
- * 纯领域规程解析函数 resolvePlaybook。
- * 基于 PackageGraph 替代原 registry 内部的 resolvePlaybookProject 启发式搜索。
+ * 基于 PackageGraph 的规程寻址函数，正文统一由规程加载层提供。
+ * 替代原 registry 内部的 resolvePlaybookProject 启发式搜索。
  */
 export function resolvePlaybook(identifier, context) {
     const str = identifier.trim();
@@ -87,20 +51,15 @@ export function resolvePlaybook(identifier, context) {
     // 3. 全局搜索
     const matches = [];
     for (const node of context.graph.packages.values()) {
-        try {
-            const playbooks = getNodePlaybooks(node);
-            const pb = playbooks.get(str);
-            if (pb) {
-                matches.push({
-                    packageId: node.identity.id,
-                    projectRoot: node.root,
-                    playbookId: str,
-                    playbook: pb,
-                });
-            }
-        }
-        catch {
-            // 忽略单个包加载异常
+        const playbooks = getNodePlaybooks(node);
+        const pb = playbooks.get(str);
+        if (pb) {
+            matches.push({
+                packageId: node.identity.id,
+                projectRoot: node.root,
+                playbookId: str,
+                playbook: pb,
+            });
         }
     }
     if (matches.length === 1) {

package/dist/execution/types.d.ts

@@ -1,5 +1,5 @@
 import type { ActionDefinition, ActionRef, ExecutionEvent, ExecutionResult, JsonValue, Logger, ProcessAPI, RunRecord, RunStatus } from "@actiondock/sdk";
-import type { ProjectConfig } from "../project/types.js";
+import type { ProjectConfig, RuntimeProjectConfig } from "../project/types.js";
 import type { Clock } from "../storage/clock.js";
 import type { EventSink } from "../runtime/events.js";
 import type { RuntimeStorage } from "../storage/types.js";
@@ -40,7 +40,7 @@ export interface ExecutionServiceOptions {
     storage: RuntimeStorage;
     globalStorage?: RuntimeStorage;
     projectRoot?: string;
-    projectConfig?: ProjectConfig;
+    projectConfig?: ProjectConfig | RuntimeProjectConfig;
     configOverrides?: Record<string, unknown>;
     actions?: Map<string, ActionDefinition>;
     process?: ProcessAPI;

package/dist/host/routing.d.ts

@@ -25,7 +25,7 @@ export declare function listVisiblePlaybooks(runtimes: readonly PackageRuntime[]
     graph?: PackageGraph;
 }): Promise<PlaybookSummary[]>;
 /**
- * 静态查询指定 Playbook 规范：基于 resolvePlaybook 统一纯领域解析。
+ * 静态查询指定 Playbook 规范：委托 resolvePlaybook 统一寻址与来源加载。
  */
 export declare function describeVisiblePlaybook(runtimes: readonly PackageRuntime[], id: string, visibility: {
     hostPublicPackageIds: ReadonlySet<string>;

package/dist/host/routing.js

@@ -83,7 +83,7 @@ function buildFallbackGraph(runtimes) {
     ])));
 }
 /**
- * 静态查询指定 Playbook 规范：基于 resolvePlaybook 统一纯领域解析。
+ * 静态查询指定 Playbook 规范：委托 resolvePlaybook 统一寻址与来源加载。
  */
 export async function describeVisiblePlaybook(runtimes, id, visibility) {
     const graph = visibility.graph || buildFallbackGraph(runtimes);

package/dist/index.d.ts

@@ -5,7 +5,6 @@
  * 平台大对象驱动与解析器工具移至特定子路径导出（./server, ./project, ./registry,
  * ./profile, ./graph, ./package），严格杜绝在根导出泄露内部执行与平台上下文机制。
  */
-export { suppressExperimentalWarnings } from "./utils/warning.js";
 export { ACTIONDOCK_VERSION } from "./version.js";
 export { createActionDock, connectActionDock, } from "./service/factory.js";
 export type { ActionDockService, ActionDockService as ActionDock, DiscoveryPort, ExecutionPort, RunsPort, EventsPort, RunEventSubscriptionOptions, ConfigPort, StatePort, CreateActionDockOptions, ConnectActionDockOptions, RemoteServiceOptions, ConfigValueView, ListRunsOptions, RunReadOptions, StateScopeOptions, } from "./service/types.js";
@@ -23,6 +22,8 @@ export { startActionDockServer, } from "./server/server.js";
 export type { ServerOptions, ServerOptions as ActionDockServerOptions, ActionDockServerInstance, } from "./server/types.js";
 export { initProject } from "./project/init.js";
 export { loadProjectConfig, findProjectRoot, } from "./project/loader.js";
-export type { ProjectConfig, } from "./project/types.js";
+export { discoverLocalSkillDirectory, inspectLocalPackageDirectory, queryLocalPackageDirectory, validateLocalSkillPackages, isExplicitPath, } from "./project/skill-dir.js";
+export type { ProjectConfig, PlaybookSourceManifest, RuntimeProjectConfig, } from "./project/types.js";
+export type { LocalSkillDirectory, LocalPackageEntry, } from "./project/skill-dir.js";
 export type { PackageGraph, } from "./catalog/graph.js";
 export { ActionDockError, ProcessError, PACKAGE_NOT_FOUND, ACTION_PACKAGE_VERSION_CONFLICT, ACTION_NOT_FOUND, ACTION_LOAD_FAILED, ACTION_FAILED, ACTION_TIMEOUT, ACTION_CANCELLED, INPUT_VALIDATION_FAILED, OUTPUT_VALIDATION_FAILED, INPUT_NOT_JSON, OUTPUT_NOT_JSON, ACTION_SUBRUN_LIMIT, ACTION_CALL_CYCLE, UNDECLARED_ACTION_DEPENDENCY, INVALID_ACTION_REF, IDEMPOTENCY_CONFLICT, EXECUTION_FAILED, UNHANDLED_EXECUTION_ERROR, RUN_REPOSITORY_UNAVAILABLE, RUN_PERSISTENCE_FAILED, STANDALONE_ASYNC_UNSUPPORTED, HOST_PROCESS_EXITED, EXECUTION_ABORTED, TIMEOUT, NETWORK_ERROR, CAPABILITY_UNAVAILABLE, STATE_KEY_NOT_FOUND, STORAGE_BUSY, PROJECT_BUSY, PROJECT_RECOVERY_REQUIRED, EVENT_BACKPRESSURE_LIMIT, EVENT_CURSOR_EXPIRED, PROCESS_OUTPUT_LIMIT, PROCESS_SPAWN_ERROR, PROCESS_CANCELLED, PROCESS_TIMEOUT, UNAUTHORIZED, NOT_FOUND, SERVER_ERROR, PACKAGE_FORBIDDEN, ACTION_FORBIDDEN, PLAYBOOK_NOT_FOUND, REQUEST_TOO_LARGE, ACTION_START_FAILED, ACTION_EXECUTION_ERROR, DATA_DIR_IN_USE, DATA_DIR_RECOVERY_REQUIRED, PROCESS_FAILED, MCP_TOOL_NAME_COLLISION, ACCESS_DENIED, INVALID_FLAT_ARGUMENT, INVALID_JSON, INVALID_JSON_LITERAL, INPUT_PATH_CONFLICT, FLAT_INPUT_LIMIT_EXCEEDED, INPUT_LIMIT_EXCEEDED, INPUT_POLICY_VIOLATION, INPUT_CONFLICT, INPUT_FILE_NOT_FOUND, INPUT_FILE_READ_FAILED, INVALID_ARGUMENT, PACKAGE_NOT_ALLOWED, INVALID_PACKAGE_ID, PATH_TRAVERSAL, AMBIGUOUS_STATE_KEY, RUN_NOT_FOUND, RUN_ALREADY_FINISHED, PROJECT_ROOT_NOT_FOUND, describeActionLoadFailure, createErrorEnvelope, resolveExecutionHint, } from "./errors.js";

package/dist/index.js

@@ -5,7 +5,6 @@
  * 平台大对象驱动与解析器工具移至特定子路径导出（./server, ./project, ./registry,
  * ./profile, ./graph, ./package），严格杜绝在根导出泄露内部执行与平台上下文机制。
  */
-export { suppressExperimentalWarnings } from "./utils/warning.js";
 // 1. 核心版本号单一事实源
 export { ACTIONDOCK_VERSION } from "./version.js";
 // 2. 统一服务门面与聚合契约接口
@@ -20,5 +19,6 @@ export { startActionDockServer, } from "./server/server.js";
 // 6. 核心工程辅助
 export { initProject } from "./project/init.js";
 export { loadProjectConfig, findProjectRoot, } from "./project/loader.js";
+export { discoverLocalSkillDirectory, inspectLocalPackageDirectory, queryLocalPackageDirectory, validateLocalSkillPackages, isExplicitPath, } from "./project/skill-dir.js";
 // 8. 统一错误模型与核心标准错误码常量
 export { ActionDockError, ProcessError, PACKAGE_NOT_FOUND, ACTION_PACKAGE_VERSION_CONFLICT, ACTION_NOT_FOUND, ACTION_LOAD_FAILED, ACTION_FAILED, ACTION_TIMEOUT, ACTION_CANCELLED, INPUT_VALIDATION_FAILED, OUTPUT_VALIDATION_FAILED, INPUT_NOT_JSON, OUTPUT_NOT_JSON, ACTION_SUBRUN_LIMIT, ACTION_CALL_CYCLE, UNDECLARED_ACTION_DEPENDENCY, INVALID_ACTION_REF, IDEMPOTENCY_CONFLICT, EXECUTION_FAILED, UNHANDLED_EXECUTION_ERROR, RUN_REPOSITORY_UNAVAILABLE, RUN_PERSISTENCE_FAILED, STANDALONE_ASYNC_UNSUPPORTED, HOST_PROCESS_EXITED, EXECUTION_ABORTED, TIMEOUT, NETWORK_ERROR, CAPABILITY_UNAVAILABLE, STATE_KEY_NOT_FOUND, STORAGE_BUSY, PROJECT_BUSY, PROJECT_RECOVERY_REQUIRED, EVENT_BACKPRESSURE_LIMIT, EVENT_CURSOR_EXPIRED, PROCESS_OUTPUT_LIMIT, PROCESS_SPAWN_ERROR, PROCESS_CANCELLED, PROCESS_TIMEOUT, UNAUTHORIZED, NOT_FOUND, SERVER_ERROR, PACKAGE_FORBIDDEN, ACTION_FORBIDDEN, PLAYBOOK_NOT_FOUND, REQUEST_TOO_LARGE, ACTION_START_FAILED, ACTION_EXECUTION_ERROR, DATA_DIR_IN_USE, DATA_DIR_RECOVERY_REQUIRED, PROCESS_FAILED, MCP_TOOL_NAME_COLLISION, ACCESS_DENIED, INVALID_FLAT_ARGUMENT, INVALID_JSON, INVALID_JSON_LITERAL, INPUT_PATH_CONFLICT, FLAT_INPUT_LIMIT_EXCEEDED, INPUT_LIMIT_EXCEEDED, INPUT_POLICY_VIOLATION, INPUT_CONFLICT, INPUT_FILE_NOT_FOUND, INPUT_FILE_READ_FAILED, INVALID_ARGUMENT, PACKAGE_NOT_ALLOWED, INVALID_PACKAGE_ID, PATH_TRAVERSAL, AMBIGUOUS_STATE_KEY, RUN_NOT_FOUND, RUN_ALREADY_FINISHED, PROJECT_ROOT_NOT_FOUND, describeActionLoadFailure, createErrorEnvelope, resolveExecutionHint, } from "./errors.js";

package/dist/package/runtime.d.ts

@@ -1,6 +1,6 @@
 import type { ExecutionEvent, ExecutionResult, JsonValue, RunRecord } from "@actiondock/sdk";
 import type { ActionInvoker, CancelResult, ExecutionTicket } from "../execution/types.js";
-import type { ProjectConfig } from "../project/types.js";
+import type { ProjectConfig, RuntimeProjectConfig } from "../project/types.js";
 import { type PackageIdentity } from "../runtime/identity.js";
 import { type InvocationContext, type RunOptions } from "../invocation/types.js";
 import type { ActionSpec, ActionSummary, ConfigValueView, HostManagedPackageRuntime, ListActionsOptions, ListRunsOptions, PackageInfo, PackageRuntime, PackageRuntimeOptions, PackageRuntimeInternalOptions, PlaybookSpec, PlaybookSummary, StateScopeOptions } from "./types.js";
@@ -21,7 +21,7 @@ export declare class DefaultPackageRuntime implements HostManagedPackageRuntime
     readonly packageInstanceId: string;
     readonly generationId: string;
     readonly packageRoot?: string;
-    readonly projectConfig: ProjectConfig;
+    readonly projectConfig: ProjectConfig | RuntimeProjectConfig;
     readonly inMemory: boolean;
     private readonly platform;
     private readonly actionsMap;

package/dist/package/runtime.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { DefaultExecutionService } from "../execution/service.js";
 import { createNodePlatform } from "../platform/index.js";
-import { findProjectRoot, loadProjectConfig } from "../project/loader.js";
+import { completeRuntimeProjectConfig, findProjectRoot, loadProjectConfig } from "../project/loader.js";
 import { RuntimeConfig } from "../runtime/context.js";
 import { normalizeActionCollection } from "../runtime/action-collection.js";
 import { isSecretConfigKey, sanitizeConfigDefinitions } from "../storage/mask.js";
@@ -125,6 +125,8 @@ export class DefaultPackageRuntime {
                 version: "0.1.0",
             };
         }
+        // 在唯一装配边界确定规程来源，索引与包图共享同一份完整配置快照。
+        projectConfig = completeRuntimeProjectConfig(packageRoot, projectConfig);
         this.packageRoot = packageRoot;
         this.projectConfig = projectConfig;
         // 兼容未在公开选项契约中显式声明的包实例标识与代系标识内部参数透传

package/dist/package/static-index.d.ts

@@ -1,5 +1,5 @@
 import type { ActionDefinition } from "@actiondock/sdk";
-import type { ProjectConfig } from "../project/types.js";
+import type { ProjectConfig, RuntimeProjectConfig } from "../project/types.js";
 import type { ActionSpec, PlaybookSpec } from "./types.js";
 /**
  * 静态清单索引构建入参：同一包的全部静态事实来源。
@@ -10,8 +10,8 @@ export interface StaticIndexInput {
     packageRoot?: string;
     /** 包唯一标识 */
     packageId: string;
-    /** 项目配置（规范化清单配置快照，单一事实源） */
-    projectConfig: ProjectConfig;
+    /** 项目配置（规范化清单配置快照或运行时来源，单一事实源） */
+    projectConfig: ProjectConfig | RuntimeProjectConfig;
 }
 /** Action 索引构建入参：静态事实来源之上叠加内存注入的 Action 定义集合 */
 export interface StaticActionIndexInput extends StaticIndexInput {
@@ -29,8 +29,6 @@ export interface StaticActionIndexInput extends StaticIndexInput {
 export declare function buildStaticActionMap(input: StaticActionIndexInput): Map<string, ActionSpec>;
 /**
  * 静态读取并聚合指定包的 Playbook 规范索引。
- *
- * 聚合来源：磁盘规程目录扫描（以 actiondock.json 声明为事实源）与
- * 项目配置中声明的 playbooks；同键时配置声明覆盖磁盘扫描结果。
+ * 统一复用 project/loader 的 loadPlaybooks（单一事实源），不再自行读文件或吞异常。
  */
 export declare function buildStaticPlaybookMap(input: StaticIndexInput): Map<string, PlaybookSpec>;