@actiondock/core 2.6.0 → 2.8.0

package/dist/project/resolver.js

@@ -1,376 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
-import { listLinkedPackages } from "../registry/registry.js";
-import { computeManifestDigest, parseJsonWithoutDuplicates } from "./digest.js";
-import { loadLockfile } from "./lockfile.js";
-import { loadPlaybooks } from "./loader.js";
-import { loadManifest, MANIFEST_FILE_NAME } from "./manifest.js";
-/**
- * 解析基础 SemVer 版本字符串。
- */
-export function parseSemVer(v) {
-    const match = v.trim().replace(/^[v=]/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
-    if (!match)
-        return null;
-    return {
-        major: parseInt(match[1], 10),
-        minor: parseInt(match[2], 10),
-        patch: parseInt(match[3], 10),
-        prerelease: match[4],
-    };
-}
-/**
- * 校验两个语义化版本范围是否兼容并能收敛为单一解析版本。
- * 遵循设计规范：直接或传递版本范围无法收敛时拒绝并抛出 ACTION_PACKAGE_VERSION_CONFLICT。
- */
-export function areVersionsCompatible(v1, v2) {
-    if (v1 === v2 || v1 === "*" || v2 === "*" || !v1 || !v2) {
-        return true;
-    }
-    // 处理前缀范围符（如 ^1.0.0, ~1.0.0）
-    const clean1 = v1.trim().replace(/^[\^~=]/, "");
-    const clean2 = v2.trim().replace(/^[\^~=]/, "");
-    const sem1 = parseSemVer(clean1);
-    const sem2 = parseSemVer(clean2);
-    if (!sem1 || !sem2) {
-        // 非标准 SemVer 时按字面匹配
-        return v1 === v2;
-    }
-    // 若存在主版本号不一致，则严格视为不兼容
-    if (sem1.major !== sem2.major) {
-        return false;
-    }
-    // 若带波浪号（~1.2.0），次版本号必须一致
-    if (v1.startsWith("~") || v2.startsWith("~")) {
-        if (sem1.minor !== sem2.minor) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * 版本冲突错误。
- */
-export class ActionPackageVersionConflictError extends Error {
-    code = "ACTION_PACKAGE_VERSION_CONFLICT";
-    packageId;
-    conflicts;
-    constructor(packageId, conflicts) {
-        const details = conflicts.map((c) => `'${c.requester}' 要求 '${c.rangeOrVersion}'`).join(", ");
-        super(`ACTION_PACKAGE_VERSION_CONFLICT: 逻辑包 '${packageId}' 存在不可收敛的版本冲突: ${details}`);
-        this.name = "ActionPackageVersionConflictError";
-        this.packageId = packageId;
-        this.conflicts = conflicts;
-    }
-}
-/**
- * 未声明依赖调用拦截错误。
- */
-export class UndeclaredActionDependencyError extends Error {
-    code = "UNDECLARED_ACTION_DEPENDENCY";
-    targetRef;
-    caller;
-    constructor(targetRef, caller, reason) {
-        const msg = caller
-            ? `UNDECLARED_ACTION_DEPENDENCY: Action '${caller}' 未在 'uses' 中声明对 '${targetRef}' 的跨包依赖`
-            : `UNDECLARED_ACTION_DEPENDENCY: 根调用 Action '${targetRef}' 被拒绝: 目标包既非 actiondock.json 直接依赖，亦未被可见 Playbook 委托${reason ? ` (${reason})` : ""}`;
-        super(msg);
-        this.name = "UndeclaredActionDependencyError";
-        this.targetRef = targetRef;
-        this.caller = caller;
-    }
-}
-/**
- * 依赖解析器 ActionPackageResolver。
- * 负责从 actiondock.json.dependencies 与 actiondock.lock.json 建立包索引与依赖闭包，
- * 实施版本冲突检测与调用可见性鉴权。
- */
-export class ActionPackageResolver {
-    projectRoot;
-    options;
-    resolvedGraph;
-    constructor(options) {
-        this.projectRoot = resolve(options.projectRoot);
-        this.options = { ...options, projectRoot: this.projectRoot };
-    }
-    /**
-     * 同步解析依赖图。
-     */
-    resolveSync() {
-        if (this.resolvedGraph) {
-            return this.resolvedGraph;
-        }
-        const rootManifest = this.options.manifest ||
-            loadManifest(this.projectRoot) || {
-            id: basename(this.projectRoot),
-            version: "0.1.0",
-        };
-        const rootPackageId = rootManifest.id;
-        const lockfile = this.options.lockfile ?? loadLockfile(this.projectRoot);
-        const packages = new Map();
-        const directDependencyIds = new Set();
-        const transitiveDependencyIds = new Set();
-        const versionRequirements = new Map();
-        // 记录根包自身
-        const rootDigest = computeManifestDigest(rootManifest);
-        packages.set(rootPackageId, {
-            packageId: rootPackageId,
-            npmPackage: rootPackageId,
-            version: rootManifest.version || "0.1.0",
-            packageRoot: this.projectRoot,
-            manifest: rootManifest,
-            manifestDigest: rootDigest,
-            isDirect: true,
-            isRoot: true,
-        });
-        directDependencyIds.add(rootPackageId);
-        // 探测开发本地软链接覆盖
-        const devLinkMap = new Map();
-        if (this.options.allowDevLinks) {
-            try {
-                const linked = listLinkedPackages(this.options.customHome);
-                for (const entry of linked) {
-                    if (existsSync(entry.path)) {
-                        devLinkMap.set(entry.id, entry.path);
-                    }
-                }
-            }
-            catch {
-                // 忽略扫描外部链接包异常
-            }
-        }
-        function recordRequirement(pkgId, requester, rangeOrVersion) {
-            const existing = versionRequirements.get(pkgId) || [];
-            for (const req of existing) {
-                if (!areVersionsCompatible(req.rangeOrVersion, rangeOrVersion)) {
-                    throw new ActionPackageVersionConflictError(pkgId, [
-                        req,
-                        { requester, rangeOrVersion },
-                    ]);
-                }
-            }
-            existing.push({ requester, rangeOrVersion });
-            versionRequirements.set(pkgId, existing);
-        }
-        // 广度优先遍历解析直接与间接依赖
-        const queue = [];
-        for (const [depId, spec] of Object.entries(rootManifest.dependencies || {})) {
-            directDependencyIds.add(depId);
-            recordRequirement(depId, rootPackageId, spec);
-            queue.push({
-                pkgId: depId,
-                requester: rootPackageId,
-                rangeOrSpec: spec,
-                isDirect: true,
-            });
-        }
-        while (queue.length > 0) {
-            const item = queue.shift();
-            if (packages.has(item.pkgId)) {
-                continue;
-            }
-            // 寻址包安装根目录
-            let pkgDir = null;
-            const locked = lockfile?.packages?.[item.pkgId];
-            // 优先级：显式注入路径 -> 开发软链接覆盖 -> 锁文件记录 -> node_modules 探测
-            if (this.options.packageRoots?.[item.pkgId]) {
-                pkgDir = this.options.packageRoots[item.pkgId];
-            }
-            else if (devLinkMap.has(item.pkgId)) {
-                pkgDir = devLinkMap.get(item.pkgId);
-            }
-            else {
-                const candidateNames = [];
-                if (locked?.npmPackage) {
-                    candidateNames.push(locked.npmPackage);
-                }
-                candidateNames.push(item.rangeOrSpec);
-                candidateNames.push(item.pkgId);
-                let cur = this.projectRoot;
-                while (true) {
-                    for (const candName of candidateNames) {
-                        const candPath = join(cur, "node_modules", candName);
-                        if (existsSync(candPath) && existsSync(join(candPath, MANIFEST_FILE_NAME))) {
-                            pkgDir = candPath;
-                            break;
-                        }
-                    }
-                    if (pkgDir)
-                        break;
-                    const parent = dirname(cur);
-                    if (parent === cur)
-                        break;
-                    cur = parent;
-                }
-            }
-            if (!pkgDir || !existsSync(pkgDir)) {
-                throw new Error(`PACKAGE_NOT_FOUND: Package '${item.pkgId}' required by '${item.requester}' is not installed in ${this.projectRoot}. Please run 'ad add ${item.rangeOrSpec}'.`);
-            }
-            const manifestPath = join(pkgDir, MANIFEST_FILE_NAME);
-            if (!existsSync(manifestPath)) {
-                throw new Error(`Action package '${item.pkgId}' at '${pkgDir}' misses required manifest 'actiondock.json'`);
-            }
-            let manifestRaw;
-            try {
-                manifestRaw = readFileSync(manifestPath, "utf-8");
-            }
-            catch (err) {
-                throw new Error(`Failed to read manifest for '${item.pkgId}': ${err.message}`);
-            }
-            const depManifest = parseJsonWithoutDuplicates(manifestRaw);
-            const actualDigest = computeManifestDigest(depManifest);
-            // 锁文件摘要校验
-            if (locked?.manifestDigest && locked.manifestDigest !== actualDigest) {
-                throw new Error(`Manifest digest mismatch for package '${item.pkgId}': expected '${locked.manifestDigest}', got '${actualDigest}'. Re-resolution required.`);
-            }
-            const pkgVersion = depManifest.version || locked?.version || "0.1.0";
-            // 校验版本是否满足已知要求
-            const reqs = versionRequirements.get(item.pkgId) || [];
-            for (const req of reqs) {
-                if (!areVersionsCompatible(req.rangeOrVersion, pkgVersion)) {
-                    throw new ActionPackageVersionConflictError(item.pkgId, [
-                        req,
-                        { requester: item.pkgId, rangeOrVersion: pkgVersion },
-                    ]);
-                }
-            }
-            const info = {
-                packageId: item.pkgId,
-                npmPackage: locked?.npmPackage || item.rangeOrSpec,
-                version: pkgVersion,
-                packageRoot: pkgDir,
-                manifest: depManifest,
-                manifestDigest: actualDigest,
-                isDirect: item.isDirect,
-                isRoot: false,
-            };
-            packages.set(item.pkgId, info);
-            if (!item.isDirect) {
-                transitiveDependencyIds.add(item.pkgId);
-            }
-            // 继续搜寻传递依赖
-            for (const [subDepId, subSpec] of Object.entries(depManifest.dependencies || {})) {
-                recordRequirement(subDepId, item.pkgId, subSpec);
-                if (!packages.has(subDepId)) {
-                    queue.push({
-                        pkgId: subDepId,
-                        requester: item.pkgId,
-                        rangeOrSpec: subSpec,
-                        isDirect: false,
-                    });
-                }
-            }
-        }
-        // 收集可见 Playbook 与被委托 Action
-        const visiblePlaybooks = new Map();
-        const delegatedActions = new Set();
-        // 根包 Playbooks
-        try {
-            const rootPbs = loadPlaybooks(this.projectRoot);
-            for (const [id, pb] of rootPbs.entries()) {
-                visiblePlaybooks.set(id, pb);
-                visiblePlaybooks.set(`${rootPackageId}/${id}`, pb);
-            }
-        }
-        catch {
-            // 忽略根包 Playbook 加载异常
-        }
-        // 直接依赖包 Playbooks
-        for (const depId of directDependencyIds) {
-            if (depId === rootPackageId)
-                continue;
-            const depPkg = packages.get(depId);
-            if (depPkg) {
-                try {
-                    const depPbs = loadPlaybooks(depPkg.packageRoot);
-                    for (const [id, pb] of depPbs.entries()) {
-                        visiblePlaybooks.set(`${depId}/${id}`, pb);
-                    }
-                }
-                catch {
-                    // 忽略依赖包 Playbook 加载异常
-                }
-            }
-        }
-        // 可见 Playbook 点名委托的 Action 收集
-        for (const pb of visiblePlaybooks.values()) {
-            if (Array.isArray(pb.actions)) {
-                for (const actRef of pb.actions) {
-                    if (typeof actRef === "string" && actRef.trim()) {
-                        delegatedActions.add(actRef.trim());
-                    }
-                }
-            }
-        }
-        this.resolvedGraph = {
-            rootPackageId,
-            packages,
-            directDependencyIds,
-            transitiveDependencyIds,
-            visiblePlaybooks,
-            delegatedActions,
-        };
-        return this.resolvedGraph;
-    }
-    /**
-     * 异步解析依赖图。
-     */
-    async resolve() {
-        return this.resolveSync();
-    }
-    /**
-     * 判定目标 Action 是否允许作为根调用发起。
-     * 规则：
-     * - 目标属于当前根包；
-     * - 目标属于 actiondock.json 直接依赖；
-     * - 目标属于可见 Playbook 精确委托点名的 Action。
-     */
-    canRootCall(targetPackageId, targetActionId) {
-        const graph = this.resolveSync();
-        if (targetPackageId === graph.rootPackageId) {
-            return true;
-        }
-        if (graph.directDependencyIds.has(targetPackageId)) {
-            return true;
-        }
-        const qualifiedRef = `${targetPackageId}/${targetActionId}`;
-        if (graph.delegatedActions.has(qualifiedRef)) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * 校验根调用权限，不合法时抛出 UNDECLARED_ACTION_DEPENDENCY。
-     */
-    assertRootCallAllowed(targetPackageId, targetActionId) {
-        if (!this.canRootCall(targetPackageId, targetActionId)) {
-            throw new UndeclaredActionDependencyError(`${targetPackageId}/${targetActionId}`);
-        }
-    }
-    /**
-     * 判定跨包级联调用是否合法。
-     * 规则：调用者 Action 必须在 actiondock.json 的 uses 中显式声明对目标 Action 的依赖。
-     */
-    canCascadeCall(callerPackageId, callerActionId, targetPackageId, targetActionId) {
-        if (callerPackageId === targetPackageId) {
-            return true;
-        }
-        const graph = this.resolveSync();
-        const callerPkg = graph.packages.get(callerPackageId);
-        if (!callerPkg) {
-            return false;
-        }
-        const callerActionEntry = callerPkg.manifest.actions?.[callerActionId];
-        const usesList = callerActionEntry?.uses || [];
-        const targetRef = `${targetPackageId}/${targetActionId}`;
-        return usesList.some((u) => u === targetRef || u === `${targetPackageId}/*` || u === targetPackageId);
-    }
-    /**
-     * 校验跨包级联调用权限，不合法时抛出 UNDECLARED_ACTION_DEPENDENCY。
-     */
-    assertCascadeCallAllowed(callerPackageId, callerActionId, targetPackageId, targetActionId) {
-        if (!this.canCascadeCall(callerPackageId, callerActionId, targetPackageId, targetActionId)) {
-            throw new UndeclaredActionDependencyError(`${targetPackageId}/${targetActionId}`, `${callerPackageId}/${callerActionId}`);
-        }
-    }
-}

package/dist/registry/resolve.d.ts

@@ -1,62 +0,0 @@
-import type { ActionDockManifest, PlaybookDefinition } from "../project/types.js";
-import type { LinkedPackageEntry } from "./types.js";
-/**
- * 流程步骤的惰性执行体：同步驱动器直接调用，异步驱动器 await，
- * 执行中抛出的异常由驱动器通过 it.throw 回灌生成器的 try/catch。
- */
-type FlowThunk = () => any;
-/**
- * 实体解析探针：命中返回实体值（Action 场景恒为 true），未命中返回 undefined。
- */
-type EntityProbe<V> = (projectRoot: string, config: ActionDockManifest, entityId: string) => V;
-/**
- * 由命中结果构造最终解析产物。
- */
-type EntityResultBuilder<V, R> = (projectRoot: string, packageId: string, entityId: string, value: V) => R;
-interface ResolveEntityFlowOptions<V, R> {
-    /** 实体完整标识符（可能是裸 ID 或 <pkg>/<id>、<pkg>:<id> 形式） */
-    identifier: string;
-    /** 起始工作目录 */
-    cwd: string;
-    /** 实体名词（Action 或 Playbook），仅用于错误文案 */
-    entityNoun: string;
-    /** 获取链接包列表（同步或异步由注入方决定，流程通过 thunk 统一驱动） */
-    listLinkedPackages: () => LinkedPackageEntry[];
-    /** 实体探针 */
-    probe: EntityProbe<V>;
-    /** 解析结果构造器 */
-    buildResult: EntityResultBuilder<V, R>;
-}
-/**
- * 实体解析唯一流程（生成器表达）：
- * 当前项目探测 → scoped 标识符拆分 → 注册表精确匹配 → 遍历链接包 →
- * 单命中返回、多命中报错、零命中报错。
- *
- * 仅将可能异步的操作（探针、链接列表获取）以 thunk 形式 yield，
- * 由 runFlowSync / runFlowAsync 双驱动器分别以同步调用或 await 方式执行。
- */
-export declare function resolveEntityFlow<V, R>(opts: ResolveEntityFlowOptions<V, R>): Generator<FlowThunk, R, any>;
-/**
- * 同步驱动器：逐个调用 thunk 并把结果回灌生成器，
- * thunk 抛出的异常经 it.throw 回灌生成器内部的 try/catch 处理。
- * 同步流程中误注入异步 thunk 时立即抛错，避免 Promise 被当作命中值静默错判。
- */
-export declare function runFlowSync<R>(flow: Generator<FlowThunk, R, any>): R;
-/**
- * 异步驱动器：await 每个 thunk 后回灌结果，拒绝原因经 it.throw 回灌。
- */
-export declare function runFlowAsync<R>(flow: Generator<FlowThunk, R, any>): Promise<R>;
-/**
- * Action 探针（同步）：manifest 声明优先，其次探测源码文件是否落盘。
- */
-export declare function probeActionSync(projectRoot: string, config: ActionDockManifest, actionId: string): true | undefined;
-/**
- * Action 探针（异步）：manifest 声明优先，其次加载源码模块；
- * 模块加载失败时回退同步探测，保证与同步路径判定一致。
- */
-export declare function probeActionAsync(projectRoot: string, config: ActionDockManifest, actionId: string): Promise<true | undefined>;
-/**
- * Playbook 探针：以 actiondock.json 的 playbooks 声明为唯一事实源，命中返回规程定义。
- */
-export declare function probePlaybook(projectRoot: string, config: ActionDockManifest, playbookId: string): PlaybookDefinition | undefined;
-export {};

package/dist/registry/resolve.js

@@ -1,195 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { findProjectRoot, loadActions, loadPlaybooks, loadProjectConfig } from "../project/loader.js";
-import { loadManifest } from "../project/manifest.js";
-import { getPackageSlug } from "../utils/index.js";
-/**
- * 实体解析唯一流程（生成器表达）：
- * 当前项目探测 → scoped 标识符拆分 → 注册表精确匹配 → 遍历链接包 →
- * 单命中返回、多命中报错、零命中报错。
- *
- * 仅将可能异步的操作（探针、链接列表获取）以 thunk 形式 yield，
- * 由 runFlowSync / runFlowAsync 双驱动器分别以同步调用或 await 方式执行。
- */
-export function* resolveEntityFlow(opts) {
-    const { identifier, entityNoun } = opts;
-    // 当前项目（或其父级项目）优先探测
-    const currentRoot = findProjectRoot(opts.cwd);
-    if (currentRoot) {
-        try {
-            const config = loadProjectConfig(currentRoot);
-            const hit = yield () => opts.probe(currentRoot, config, identifier);
-            if (hit !== undefined) {
-                return opts.buildResult(currentRoot, config.id, identifier, hit);
-            }
-        }
-        catch {
-            // 当前项目配置损坏或探测失败：忽略并继续注册表查找
-        }
-    }
-    // scoped 标识符拆分：<package-id>/<entity-id> 或 <package-id>:<entity-id>
-    let targetPackage;
-    let pureEntityId = identifier;
-    if (identifier.includes("/")) {
-        const slashIdx = identifier.lastIndexOf("/");
-        targetPackage = identifier.slice(0, slashIdx);
-        pureEntityId = identifier.slice(slashIdx + 1);
-    }
-    else if (identifier.includes(":")) {
-        const colonIdx = identifier.lastIndexOf(":");
-        targetPackage = identifier.slice(0, colonIdx);
-        pureEntityId = identifier.slice(colonIdx + 1);
-    }
-    const linkedList = yield () => opts.listLinkedPackages();
-    if (targetPackage) {
-        let targetRoot;
-        let targetPkgId = targetPackage;
-        if (currentRoot) {
-            try {
-                const config = loadProjectConfig(currentRoot);
-                if (config.id === targetPackage || getPackageSlug(config.id) === targetPackage) {
-                    targetRoot = currentRoot;
-                    targetPkgId = config.id;
-                }
-            }
-            catch {
-                // 当前项目配置损坏：忽略，回退注册表匹配
-            }
-        }
-        let pkg;
-        if (!targetRoot) {
-            pkg = linkedList.find((p) => p.id === targetPackage || getPackageSlug(p.id) === targetPackage);
-            if (pkg && existsSync(pkg.path)) {
-                targetRoot = pkg.path;
-                targetPkgId = pkg.id;
-            }
-        }
-        if (!targetRoot || !existsSync(targetRoot)) {
-            throw new Error(`Linked package '${targetPackage}' not found or path no longer exists (${pkg?.path || "unregistered"}). Run 'ad link' in the package directory.`);
-        }
-        const config = loadProjectConfig(targetRoot);
-        const hit = yield () => opts.probe(targetRoot, config, pureEntityId);
-        if (hit === undefined) {
-            throw new Error(`${entityNoun} '${pureEntityId}' not found in package '${targetPkgId}' (${targetRoot})`);
-        }
-        return opts.buildResult(targetRoot, targetPkgId, pureEntityId, hit);
-    }
-    // 遍历全部链接包搜索
-    const matches = [];
-    for (const pkg of linkedList) {
-        if (!existsSync(pkg.path))
-            continue;
-        try {
-            const config = loadProjectConfig(pkg.path);
-            const hit = yield () => opts.probe(pkg.path, config, identifier);
-            if (hit !== undefined) {
-                matches.push({ entry: pkg, entityId: identifier, value: hit });
-            }
-        }
-        catch {
-            // 忽略损坏的链接包：单个包配置或探测异常不应中断其余包的匹配
-        }
-    }
-    if (matches.length === 1) {
-        const m = matches[0];
-        return opts.buildResult(m.entry.path, m.entry.id, m.entityId, m.value);
-    }
-    if (matches.length > 1) {
-        const pkgList = matches.map((m) => `'${m.entry.id}'`).join(", ");
-        throw new Error(`${entityNoun} '${identifier}' is provided by multiple linked packages: ${pkgList}. Please specify using '<package-id>/${identifier}'.`);
-    }
-    if (currentRoot) {
-        throw new Error(`${entityNoun} '${identifier}' not found in current project or any linked packages`);
-    }
-    else {
-        throw new Error(`${entityNoun} '${identifier}' not found. You are not in an ActionDock project, and no linked package provides '${identifier}'. Use 'ad link' to register your package.`);
-    }
-}
-/**
- * 同步驱动器：逐个调用 thunk 并把结果回灌生成器，
- * thunk 抛出的异常经 it.throw 回灌生成器内部的 try/catch 处理。
- * 同步流程中误注入异步 thunk 时立即抛错，避免 Promise 被当作命中值静默错判。
- */
-export function runFlowSync(flow) {
-    let step = flow.next();
-    while (!step.done) {
-        const value = step.value();
-        if (value !== undefined && typeof value.then === "function") {
-            throw new Error("Synchronous resolution received an asynchronous effect; check the injected probe and linked-list loader");
-        }
-        let next;
-        try {
-            next = flow.next(value);
-        }
-        catch (err) {
-            next = flow.throw(err);
-        }
-        step = next;
-    }
-    return step.value;
-}
-/**
- * 异步驱动器：await 每个 thunk 后回灌结果，拒绝原因经 it.throw 回灌。
- */
-export async function runFlowAsync(flow) {
-    let step = flow.next();
-    while (!step.done) {
-        let next;
-        try {
-            next = flow.next(await step.value());
-        }
-        catch (err) {
-            next = flow.throw(err);
-        }
-        step = next;
-    }
-    return step.value;
-}
-/**
- * Action 探针（同步）：manifest 声明优先，其次探测源码文件是否落盘。
- */
-export function probeActionSync(projectRoot, config, actionId) {
-    const manifest = loadManifest(projectRoot);
-    if (manifest?.actions && actionId in manifest.actions) {
-        return true;
-    }
-    const dir = join(projectRoot, config.actionsDir || "actions");
-    if (!existsSync(dir)) {
-        return undefined;
-    }
-    if (actionId.includes("..") || actionId.startsWith("/") || actionId.startsWith("\\")) {
-        return undefined;
-    }
-    if (existsSync(join(dir, `${actionId}.ts`)) || existsSync(join(dir, `${actionId}.js`))) {
-        return true;
-    }
-    const relFile = actionId.replace(/\./g, "/");
-    if (existsSync(join(dir, `${relFile}.ts`)) || existsSync(join(dir, `${relFile}.js`))) {
-        return true;
-    }
-    return undefined;
-}
-/**
- * Action 探针（异步）：manifest 声明优先，其次加载源码模块；
- * 模块加载失败时回退同步探测，保证与同步路径判定一致。
- */
-export async function probeActionAsync(projectRoot, config, actionId) {
-    const manifest = loadManifest(projectRoot);
-    if (manifest?.actions && actionId in manifest.actions) {
-        return true;
-    }
-    try {
-        const actions = await loadActions(projectRoot, config.actionsDir);
-        return actions.has(actionId) ? true : undefined;
-    }
-    catch {
-        return probeActionSync(projectRoot, config, actionId);
-    }
-}
-/**
- * Playbook 探针：以 actiondock.json 的 playbooks 声明为唯一事实源，命中返回规程定义。
- */
-export function probePlaybook(projectRoot, config, playbookId) {
-    const playbooks = loadPlaybooks(projectRoot, config.playbooksDir);
-    return playbooks.get(playbookId);
-}

package/dist/runtime/execution-manager.d.ts

@@ -1,48 +0,0 @@
-import type { ExecutionHandle } from "./runner.js";
-/**
- * 内存中活跃执行句柄（In-flight Execution Handles）生命周期管理器。
- *
- * 职责：
- * 1. 集中追踪正在执行的异步 Action 任务句柄。
- * 2. 任务完成（无论成功或失败）后通过 Promise.finally 自动注销，防止内存泄漏。
- * 3. 支持依据 runId 查询、遍历或主动发送取消信号（cancel）。
- */
-export declare class ExecutionManager {
-    private active;
-    /**
-     * 注册一个活跃的执行句柄。
-     * 当底层 Promise 完成结算（resolve/reject）时，自动从活跃映射表中移除。
-     *
-     * @param handle 执行句柄对象
-     */
-    register(handle: ExecutionHandle): void;
-    /**
-     * 根据 runId 检索正在执行的任务句柄。
-     *
-     * @param runId 运行 ID
-     * @returns 匹配的 ExecutionHandle 或 undefined
-     */
-    get(runId: string): ExecutionHandle | undefined;
-    /**
-     * 向指定 runId 的在途执行任务发送取消信号。
-     *
-     * @param runId 目标运行 ID
-     * @param reason 取消原因描述
-     * @returns 若句柄存在且成功触发中断返回 true；若任务不存在或已完成返回 false
-     */
-    cancel(runId: string, reason?: string): boolean;
-    /**
-     * 手动从活跃集合中移除执行句柄。
-     *
-     * @param runId 运行 ID
-     */
-    remove(runId: string): void;
-    /**
-     * 获取当前系统中所有正在执行的活跃句柄列表。
-     */
-    list(): ExecutionHandle[];
-    /**
-     * 清空所有活跃执行句柄。
-     */
-    clear(): void;
-}