@actiondock/core 2.14.0 → 2.16.0

package/dist/catalog/graph.d.ts

@@ -6,6 +6,10 @@ 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;
 /**
  * 版本冲突错误。
@@ -141,8 +145,6 @@ export declare class DefaultPackageGraph implements PackageGraph {
 export interface PackageGraphBuilderOptions {
     /** 预先发现的包集合，若未提供则通过 PackageDiscovery 自动发现 */
     packages?: DiscoveredPackage[];
-    /** 完整显式集合的依赖存在性与选定版本校验（Host 增量注册时不启用）。 */
-    validateDependencies?: boolean;
     /** 根工程根目录或根包标识（与 projectRoot 互为别名） */
     root?: string;
     /** 当前工程根目录绝对或相对物理路径 */

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, PACKAGE_ID_CONFLICT, INVALID_ARGUMENT, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
+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 { computeManifestDigest, parseJsonWithoutDuplicates } from "../project/digest.js";
 import { loadLockfile } from "../project/lockfile.js";
 import { loadPlaybooks, loadProjectConfig } from "../project/loader.js";
@@ -10,124 +10,30 @@ import { createPackageIdentity } from "../runtime/identity.js";
 import { parseSemVer } from "../utils/index.js";
 import { PackageDiscovery } from "./discovery.js";
 export { parseSemVer };
-/** 有限版本契约：严格三段版本（允许 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;
-    }
-    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);
-    }
-    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 等；
- * - 版本三段式开头但未被严格解析器支持的非法形态。
+ * 校验两个语义化版本范围是否兼容并能收敛为单一解析版本。
+ * 遵循设计规范：直接或传递版本范围无法收敛时拒绝并抛出 ACTION_PACKAGE_VERSION_CONFLICT。
  */
-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))
+export function areVersionsCompatible(v1, v2) {
+    if (v1 === v2 || v1 === "*" || v2 === "*" || !v1 || !v2) {
         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 *`);
     }
-    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}'`);
+    const clean1 = v1.trim().replace(/^[\^~=]/, "");
+    const clean2 = v2.trim().replace(/^[\^~=]/, "");
+    const sem1 = parseSemVer(clean1);
+    const sem2 = parseSemVer(clean2);
+    if (!sem1 || !sem2) {
+        return v1 === v2;
+    }
+    if (sem1.major !== sem2.major) {
+        return false;
+    }
+    if (v1.startsWith("~") || v2.startsWith("~")) {
+        if (sem1.minor !== sem2.minor) {
+            return false;
+        }
     }
-    return requirements;
+    return true;
 }
 /**
  * 版本冲突错误。
@@ -374,9 +280,6 @@ 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,
@@ -419,39 +322,6 @@ export class PackageGraphBuilder {
                 rootNode.isDirect = true;
             }
         }
-        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);
         computeTransitiveDependencies(nodes);
         const effectiveRootNode = rootIdentity ? nodes.get(rootIdentity.id) : undefined;
@@ -545,13 +415,6 @@ 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) || [];
@@ -566,22 +429,10 @@ 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);
-                recordDependency(depId, rootPackageId, spec);
+                recordRequirement(depId, rootPackageId, spec);
                 queue.push({
                     pkgId: depId,
                     requester: rootPackageId,
@@ -609,7 +460,7 @@ export class PackageGraphBuilder {
                     continue;
                 }
                 let pkgDir = null;
-                const locked = getRequesterLock(item.requester)?.packages[item.pkgId] || lockfile?.packages[item.pkgId];
+                const locked = lockfile?.packages?.[item.pkgId];
                 if (packageRootsRecord?.[item.pkgId]) {
                     pkgDir = packageRootsRecord[item.pkgId];
                 }
@@ -623,7 +474,7 @@ export class PackageGraphBuilder {
                     }
                     candidateNames.push(item.rangeOrSpec);
                     candidateNames.push(item.pkgId);
-                    let cur = nodes.get(item.requester)?.root || absProjectRoot;
+                    let cur = absProjectRoot;
                     while (true) {
                         for (const candName of candidateNames) {
                             const candPath = join(cur, "node_modules", candName);
@@ -655,9 +506,6 @@ 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.`);
@@ -690,13 +538,15 @@ export class PackageGraphBuilder {
                 };
                 nodes.set(item.pkgId, newNode);
                 for (const [subDepId, subSpec] of Object.entries(depManifest.dependencies || {})) {
-                    recordDependency(subDepId, item.pkgId, subSpec);
-                    queue.push({
-                        pkgId: subDepId,
-                        requester: item.pkgId,
-                        rangeOrSpec: subSpec,
-                        isDirect: false,
-                    });
+                    recordRequirement(subDepId, item.pkgId, subSpec);
+                    if (!nodes.has(subDepId)) {
+                        queue.push({
+                            pkgId: subDepId,
+                            requester: item.pkgId,
+                            rangeOrSpec: subSpec,
+                            isDirect: false,
+                        });
+                    }
                 }
             }
             if (scanLinked) {

package/dist/index.d.ts

@@ -22,8 +22,6 @@ 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 { inspectLocalPackageDirectory, validateLocalSkillPackages, isExplicitPath, } from "./project/skill-dir.js";
 export type { ProjectConfig, } 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

@@ -19,6 +19,5 @@ export { startActionDockServer, } from "./server/server.js";
 // 6. 核心工程辅助
 export { initProject } from "./project/init.js";
 export { loadProjectConfig, findProjectRoot, } from "./project/loader.js";
-export { inspectLocalPackageDirectory, 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/project/index.d.ts

@@ -3,7 +3,6 @@ export * from "./init.js";
 export * from "./loader.js";
 export * from "./lockfile.js";
 export * from "./manifest.js";
-export * from "./skill-dir.js";
 export { SNAPSHOT_TRACKED_FILES, type TransactionFileRecord, type TransactionMetadata, type ProjectTransaction, isProjectLockHeld, acquireProjectLock, runFrozenInstall, hasPendingTransactions, beginTransaction, recoverPendingTransactions, } from "./transactions.js";
 export * from "./types.js";
 export * from "./types-generator.js";

package/dist/project/index.js

@@ -3,7 +3,6 @@ export * from "./init.js";
 export * from "./loader.js";
 export * from "./lockfile.js";
 export * from "./manifest.js";
-export * from "./skill-dir.js";
 export { SNAPSHOT_TRACKED_FILES, isProjectLockHeld, acquireProjectLock, runFrozenInstall, hasPendingTransactions, beginTransaction, recoverPendingTransactions, } from "./transactions.js";
 export * from "./types.js";
 export * from "./types-generator.js";

package/dist/project/init.js

@@ -86,10 +86,10 @@ export function initProject(targetDir, options = {}) {
             node: ">=24.12.0",
         },
         dependencies: {
-            "@actiondock/sdk": "^2.14.0",
+            "@actiondock/sdk": "^2.16.0",
         },
         devDependencies: {
-            "@actiondock/testing": "^2.14.0",
+            "@actiondock/testing": "^2.16.0",
             "@types/node": "^22.13.0",
             "tsx": "^4.19.0",
             "typescript": "^5.7.0",

package/dist/project/types.d.ts

@@ -75,8 +75,6 @@ export interface ActionDockManifest {
     actions?: Record<string, ActionManifestEntry>;
     /** 声明的 Playbooks 集合（唯一事实源） */
     playbooks?: Record<string, PlaybookManifestEntry>;
-    /** 包级静态依赖引用，与 Action 的 uses 共用引用语义。 */
-    uses?: string[];
     /** 跨包外部依赖映射（逻辑包 ID 到 npm 包名） */
     dependencies?: Record<string, string>;
     /** 框架导出与分发边界文件列表 */

package/dist/registry/registry.js

@@ -2,7 +2,6 @@ import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from "node:
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { findProjectRoot, loadProjectConfig } from "../project/loader.js";
-import { inspectLocalPackageDirectory, isExplicitPath } from "../project/skill-dir.js";
 import { getActionDockHome, getPackageSlug } from "../utils/index.js";
 import { ActionDockError, MANIFEST_NOT_FOUND, REGISTRY_CORRUPTED } from "../errors.js";
 import { withRegistryLock } from "./lock.js";
@@ -400,42 +399,31 @@ export function resolvePackageRoot(packageIdOrPath, cwd, customHome) {
     const resolvedPath = resolve(baseDir, packageIdOrPath);
     // 检查 packageIdOrPath 是否为磁盘上现存的目录或文件路径
     if (existsSync(resolvedPath)) {
-        let info;
         try {
-            info = statSync(resolvedPath);
-        }
-        catch (err) {
-            if (err?.code !== "ENOENT" && err?.code !== "ENOTDIR") {
-                throw err;
-            }
-        }
-        if (info) {
+            const info = statSync(resolvedPath);
             const targetDir = info.isDirectory() ? resolvedPath : dirname(resolvedPath);
-            // 普通开发包根目录：直接包含 actiondock.json 清单。
-            // 普通清单根目录定位与封闭 Skill 执行校验分离，不能被当成只含一个包的 Skill 闭包拒绝。
             if (existsSync(join(targetDir, "actiondock.json"))) {
-                loadProjectConfig(targetDir);
                 return targetDir;
             }
-            // 复合技能布局：根目录下存在 packages/ 目录且包含有效子包。
-            const localSkill = inspectLocalPackageDirectory(targetDir);
-            if (localSkill) {
-                return localSkill.root;
-            }
-            // 具体文件查找所属工程根目录：仅当 packageIdOrPath 指向具体文件（非目录）时，
-            // 才尝试向上查找所属工程根目录；目录形态绝不向上回退，防止显式目录越界命中父级工程。
-            if (!info.isDirectory()) {
-                const parentRoot = findProjectRoot(targetDir);
-                if (parentRoot) {
-                    loadProjectConfig(parentRoot);
-                    return parentRoot;
-                }
+            const parentRoot = findProjectRoot(targetDir);
+            if (parentRoot) {
+                return parentRoot;
             }
         }
+        catch {
+            // stat 失败（如并发删除）：忽略并继续走标识符解析路径
+        }
     }
     // 显式路径形态但未解析成功的场景：
     // scoped package 标识符（如 @team/tools）虽含 '/' 但属于包 ID 而非文件路径
-    if (isExplicitPath(packageIdOrPath)) {
+    const isScopedPackage = packageIdOrPath.startsWith("@");
+    const isExplicitPath = !isScopedPackage &&
+        (packageIdOrPath.startsWith(".") ||
+            packageIdOrPath.startsWith("/") ||
+            packageIdOrPath.startsWith("~") ||
+            packageIdOrPath.includes("/") ||
+            packageIdOrPath.includes("\\"));
+    if (isExplicitPath) {
         // 显式路径不存在或不是 ActionDock 项目时必须失败，禁止静默回退
         return null;
     }

package/dist/runtime/standalone-commands.js

@@ -29,7 +29,7 @@ export async function handleList(ctx, subArgs) {
     const effectiveIntent = intent || (positionalPatterns.length > 0 ? positionalPatterns.join("|") : undefined);
     const actions = await ctx.service.discovery.listActions();
     const list = actions.map((a) => ({
-        id: ctx.options.multiPackage && a.packageId && !a.id.includes("/") ? `${a.packageId}/${a.id}` : a.id,
+        id: a.id,
         description: a.description || "",
     }));
     const filterRes = filterWithFallbackInfo(list, effectiveIntent, [(a) => a.id, (a) => a.description], !noFallback);
@@ -66,7 +66,7 @@ export async function handleDescribe(ctx, subArgs) {
         });
     }
     const payload = buildActionDescribePayload(action, {
-        packageId: action.packageId || ctx.options.packageId,
+        packageId: ctx.options.packageId,
     });
     if (isJson) {
         ctx.writeOut(JSON.stringify(payload, null, 2));
@@ -274,9 +274,6 @@ function isServiceCapabilityError(err) {
         code === "TARGET_CAPABILITY_UNAVAILABLE");
 }
 export async function handleConfig(ctx, subArgs) {
-    if (ctx.options.multiPackage) {
-        return ctx.emitError(subArgs.includes("--json"), "CAPABILITY_UNAVAILABLE", "Multi-package entries do not support config/state management; configure actions using --config and --data-dir.", ExitCode.INVALID_ARGUMENT);
-    }
     const sub = subArgs[0] || "list";
     if (!ctx.service.management) {
         ctx.writeErr("Error: management port is not enabled on this service");
@@ -353,9 +350,6 @@ function decodeStateKeyArg(key) {
     }
 }
 export async function handleState(ctx, subArgs) {
-    if (ctx.options.multiPackage) {
-        return ctx.emitError(subArgs.includes("--json"), "CAPABILITY_UNAVAILABLE", "Multi-package entries do not support config/state management; configure actions using --config and --data-dir.", ExitCode.INVALID_ARGUMENT);
-    }
     const sub = subArgs[0] || "list";
     let namespace;
     let isAll = false;

package/dist/runtime/standalone.d.ts

@@ -24,8 +24,6 @@ export interface InvocationControl {
 export interface StandaloneDispatcherOptions {
     /** 所属 Package ID */
     packageId: string;
-    /** 多包入口使用完全限定发现标识，不以展示名操作配置和状态。 */
-    multiPackage?: boolean;
     /** 版本号 */
     version: string;
     /** 描述信息 */

package/dist/utils/semver.d.ts

@@ -6,11 +6,10 @@ export interface SemVer {
     minor: number;
     patch: number;
     prerelease?: string;
-    build?: string;
 }
 /**
  * 解析基础 SemVer 版本字符串（单一事实源）。
- * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀与构建元数据；
+ * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀；
  * 其余形态（两段式、非数值等）返回 null，由调用方自行兜底。
  *
  * 本模块不依赖任何 Node 内建与 core 领域模块，可在无 loader 的原生

package/dist/utils/semver.js

@@ -1,25 +1,19 @@
 /**
  * 解析基础 SemVer 版本字符串（单一事实源）。
- * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀与构建元数据；
+ * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀；
  * 其余形态（两段式、非数值等）返回 null，由调用方自行兜底。
  *
  * 本模块不依赖任何 Node 内建与 core 领域模块，可在无 loader 的原生
  * Node 直接以 .ts 形态导入（工程脚本域复用此处单一事实源）。
  */
 export function parseSemVer(v) {
-    const match = v.trim().replace(/^[v=]/, "").match(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/);
+    const match = v.trim().replace(/^[v=]/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
     if (!match)
         return null;
-    const [major, minor, patch] = match.slice(1, 4).map(Number);
-    if (![major, minor, patch].every(Number.isSafeInteger))
-        return null;
-    if (match[4]?.split(".").some((id) => /^\d+$/.test(id) && id.length > 1 && id.startsWith("0")))
-        return null;
     return {
-        major,
-        minor,
-        patch,
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
         prerelease: match[4],
-        ...(match[5] === undefined ? {} : { build: match[5] }),
     };
 }

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export declare const ACTIONDOCK_VERSION = "2.14.0";
+export declare const ACTIONDOCK_VERSION = "2.16.0";

package/dist/version.js

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export const ACTIONDOCK_VERSION = "2.14.0";
+export const ACTIONDOCK_VERSION = "2.16.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/core",
-  "version": "2.14.0",
+  "version": "2.16.0",
   "description": "ActionDock Core Engine - Project loader, runtime execution, SQLite storage, standalone builder, and skill exporter",
   "type": "module",
   "main": "./dist/index.js",
@@ -59,7 +59,7 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/sdk": "^2.14.0",
+    "@actiondock/sdk": "^2.16.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "undici": "^7.29.1"

package/dist/project/skill-dir.d.ts

@@ -1,56 +0,0 @@
-import type { ProjectConfig } from "./types.js";
-/**
- * 本地封闭包条目。
- */
-export interface LocalPackageEntry {
-    packageId: string;
-    packageRoot: string;
-    projectConfig: ProjectConfig;
-}
-/**
- * 本地技能 / 包目录发现视图。
- */
-export interface LocalSkillDirectory {
-    type: "single" | "composite";
-    root: string;
-    packages: LocalPackageEntry[];
-}
-/**
- * 判定路径字符串是否为显式文件/目录路径形态（而非包标识符）。
- *
- * 规则：
- * - 以 .、/、~ 开头；
- * - 包含 / 或 \\，且不是 scoped 包（@scope/name 仅含一个 /）；
- * - scoped 包若包含反斜杠或多于一个 /，亦视作路径。
- */
-export declare function isExplicitPath(p: string): boolean;
-/**
- * 对明确的本地封闭包集合实施一致性校验。
- *
- * 校验规则：
- * - 重复包标识防护：集合内不得存在相同 packageId；
- * - 依赖存在性与版本兼容性：声明的直接依赖必须在集合内存在且满足语义版本约束（复用 PackageGraphBuilder）；
- * - 跨包 uses 目标完整性：uses 声明引用的目标包与目标 Action 必须在集合内存在。
- *
- * @param packages 封闭包条目集合
- */
-export declare function validateLocalSkillPackages(packages: Array<{
-    packageId: string;
-    packageRoot: string;
-    projectConfig: ProjectConfig;
-}>): void;
-/**
- * 探测指定路径是否为本地 Skill / 包目录（支持单包根目录与 packages/* 复合套件布局）。
- *
- * 封闭包装配与校验规则：
- * - 边界安全防护：packages 目录、各子包目录与 actiondock.json 清单真实路径必须在 Skill 根边界内，禁止越界符号链接；
- * - 单包布局：目录根部存在 actiondock.json，解析为包含单一包的 LocalSkillDirectory；
- * - 复合布局：目录根部存在 packages/ 目录，遍历其直接子目录，收集包含 actiondock.json 的子包；
- * - 集合一致性校验：通过 validateLocalSkillPackages 严格核查依赖闭包、版本兼容与 uses 目标；
- * - 异常透传：坏清单或权限异常原样抛出，严禁静默回退 Registry；
- * - 若非候选技能目录，返回 null。
- *
- * @param directoryPath 待检查的目录路径（相对路径将基于 cwd 解析）
- * @param cwd 解析基准工作目录（默认为 process.cwd()）
- */
-export declare function inspectLocalPackageDirectory(directoryPath: string, cwd?: string): LocalSkillDirectory | null;

package/dist/project/skill-dir.js

@@ -1,214 +0,0 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { ActionDockError, ACTION_NOT_FOUND, PACKAGE_NOT_FOUND, PACKAGE_ID_CONFLICT, } from "../errors.js";
-import { loadProjectConfig } from "./loader.js";
-import { PackageGraphBuilder } from "../catalog/graph.js";
-import { parseActionRef } from "../catalog/resolve-action.js";
-import { createPackageIdentity } from "../runtime/identity.js";
-/**
- * 判定路径字符串是否为显式文件/目录路径形态（而非包标识符）。
- *
- * 规则：
- * - 以 .、/、~ 开头；
- * - 包含 / 或 \\，且不是 scoped 包（@scope/name 仅含一个 /）；
- * - scoped 包若包含反斜杠或多于一个 /，亦视作路径。
- */
-export function isExplicitPath(p) {
-    if (!p)
-        return false;
-    if (p.startsWith("@")) {
-        const slashCount = (p.match(/\//g) || []).length;
-        return slashCount > 1 || p.includes("\\");
-    }
-    return (p.startsWith(".") ||
-        p.startsWith("/") ||
-        p.startsWith("~") ||
-        p.includes("/") ||
-        p.includes("\\"));
-}
-/**
- * 对明确的本地封闭包集合实施一致性校验。
- *
- * 校验规则：
- * - 重复包标识防护：集合内不得存在相同 packageId；
- * - 依赖存在性与版本兼容性：声明的直接依赖必须在集合内存在且满足语义版本约束（复用 PackageGraphBuilder）；
- * - 跨包 uses 目标完整性：uses 声明引用的目标包与目标 Action 必须在集合内存在。
- *
- * @param packages 封闭包条目集合
- */
-export function validateLocalSkillPackages(packages) {
-    if (!packages || packages.length === 0)
-        return;
-    // 1. 重复 packageId 校验
-    const seenIds = new Set();
-    for (const pkg of packages) {
-        if (seenIds.has(pkg.packageId)) {
-            throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${pkg.packageId}' is declared more than once in skill packages`);
-        }
-        seenIds.add(pkg.packageId);
-    }
-    // 2. 构造包发现视图并交由 PackageGraphBuilder 校验依赖与版本
-    const discovered = packages.map((pkg) => ({
-        id: pkg.packageId,
-        root: pkg.packageRoot,
-        manifest: pkg.projectConfig,
-        identity: createPackageIdentity({
-            id: pkg.packageId,
-            instanceId: `${pkg.packageId}:${pkg.packageRoot}`,
-            generation: "skill-local",
-        }),
-        isCurrentProject: true,
-    }));
-    const builder = new PackageGraphBuilder({
-        packages: discovered,
-        validateDependencies: true,
-    });
-    builder.buildSync();
-    // 3. uses 声明目标存在性校验
-    const pkgMap = new Map();
-    for (const pkg of packages) {
-        pkgMap.set(pkg.packageId, pkg.projectConfig);
-    }
-    const validateUseRef = (rawRef, caller, currentPkg) => {
-        if (typeof rawRef !== "string" || !rawRef.trim())
-            return;
-        const trimmed = rawRef.trim();
-        // 先按完整包身份识别裸包引用，包括 scoped 包。
-        if (pkgMap.has(trimmed)) {
-            return;
-        }
-        // 裸 scoped 包只有一个斜杠，不能按限定动作拆分。
-        if (trimmed.startsWith("@") && (trimmed.match(/\//g) || []).length === 1) {
-            throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${trimmed}' referenced by uses in '${caller}' was not found in skill directory`);
-        }
-        // 限定动作与包级通配符复用统一引用解析器。
-        if (trimmed.includes("/")) {
-            const ref = parseActionRef(trimmed);
-            const targetPkgId = ref.packageId;
-            const targetActionId = ref.actionId;
-            const targetPkg = pkgMap.get(targetPkgId);
-            if (!targetPkg) {
-                throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${targetPkgId}' referenced by uses in '${caller}' was not found in skill directory`);
-            }
-            if (targetActionId !== "*") {
-                const hasAction = Boolean(targetPkg.actions && targetPkg.actions[targetActionId]);
-                if (!hasAction) {
-                    throw new ActionDockError(ACTION_NOT_FOUND, `Action '${targetActionId}' referenced by uses in '${caller}' was not found in package '${targetPkgId}'`);
-                }
-            }
-            return;
-        }
-        // 本包短动作引用。
-        if (currentPkg.actions && currentPkg.actions[trimmed]) {
-            return;
-        }
-        // 目标不存在。
-        throw new ActionDockError(PACKAGE_NOT_FOUND, `Package or action '${trimmed}' referenced by uses in '${caller}' was not found in skill directory`);
-    };
-    for (const pkg of packages) {
-        const pkgUses = pkg.projectConfig.uses;
-        if (Array.isArray(pkgUses)) {
-            for (const ref of pkgUses) {
-                validateUseRef(ref, `package '${pkg.packageId}'`, pkg.projectConfig);
-            }
-        }
-        if (pkg.projectConfig.actions && typeof pkg.projectConfig.actions === "object") {
-            for (const [actionId, actionEntry] of Object.entries(pkg.projectConfig.actions)) {
-                if (actionEntry && Array.isArray(actionEntry.uses)) {
-                    for (const ref of actionEntry.uses) {
-                        validateUseRef(ref, `action '${pkg.packageId}/${actionId}'`, pkg.projectConfig);
-                    }
-                }
-            }
-        }
-    }
-}
-/**
- * 探测指定路径是否为本地 Skill / 包目录（支持单包根目录与 packages/* 复合套件布局）。
- *
- * 封闭包装配与校验规则：
- * - 边界安全防护：packages 目录、各子包目录与 actiondock.json 清单真实路径必须在 Skill 根边界内，禁止越界符号链接；
- * - 单包布局：目录根部存在 actiondock.json，解析为包含单一包的 LocalSkillDirectory；
- * - 复合布局：目录根部存在 packages/ 目录，遍历其直接子目录，收集包含 actiondock.json 的子包；
- * - 集合一致性校验：通过 validateLocalSkillPackages 严格核查依赖闭包、版本兼容与 uses 目标；
- * - 异常透传：坏清单或权限异常原样抛出，严禁静默回退 Registry；
- * - 若非候选技能目录，返回 null。
- *
- * @param directoryPath 待检查的目录路径（相对路径将基于 cwd 解析）
- * @param cwd 解析基准工作目录（默认为 process.cwd()）
- */
-export function inspectLocalPackageDirectory(directoryPath, cwd) {
-    if (!directoryPath || typeof directoryPath !== "string") {
-        return null;
-    }
-    const absDir = resolve(cwd || process.cwd(), directoryPath);
-    if (!existsSync(absDir)) {
-        return null;
-    }
-    try {
-        const stat = statSync(absDir);
-        if (!stat.isDirectory()) {
-            return null;
-        }
-    }
-    catch {
-        return null;
-    }
-    // 单包布局：根目录包含 actiondock.json
-    const rootManifest = join(absDir, "actiondock.json");
-    if (existsSync(rootManifest)) {
-        const config = loadProjectConfig(absDir);
-        const packages = [
-            {
-                packageId: config.id,
-                packageRoot: absDir,
-                projectConfig: config,
-            },
-        ];
-        validateLocalSkillPackages(packages);
-        return {
-            type: "single",
-            root: absDir,
-            packages,
-        };
-    }
-    // 复合 Skill 布局：存在 packages/ 目录且包含至少一个有效子包
-    const packagesDir = join(absDir, "packages");
-    if (existsSync(packagesDir)) {
-        const pStat = statSync(packagesDir);
-        if (pStat.isDirectory()) {
-            const entries = readdirSync(packagesDir, { withFileTypes: true });
-            const packages = [];
-            const seenIds = new Set();
-            entries.sort((a, b) => a.name.localeCompare(b.name));
-            for (const entry of entries) {
-                const subDir = join(packagesDir, entry.name);
-                const sStat = statSync(subDir);
-                if (sStat.isDirectory()) {
-                    const subManifest = join(subDir, "actiondock.json");
-                    if (existsSync(subManifest)) {
-                        const childConfig = loadProjectConfig(subDir);
-                        if (seenIds.has(childConfig.id)) {
-                            throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${childConfig.id}' is declared more than once in skill directory '${absDir}'`);
-                        }
-                        seenIds.add(childConfig.id);
-                        packages.push({
-                            packageId: childConfig.id,
-                            packageRoot: subDir,
-                            projectConfig: childConfig,
-                        });
-                    }
-                }
-            }
-            if (packages.length > 0) {
-                validateLocalSkillPackages(packages);
-                return {
-                    type: "composite",
-                    root: absDir,
-                    packages,
-                };
-            }
-        }
-    }
-    return null;
-}