@actiondock/core 2.7.0 → 2.9.0

package/dist/host/host.js

@@ -1,15 +1,22 @@
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
-import { DefaultActionDockApp } from "../app/app.js";
+import { DefaultPackageRuntime } from "../package/runtime.js";
+import { applyActionSummaryFilters } from "../package/types.js";
+import { createRootInvocationContext, } from "../invocation/types.js";
 import { findProjectRoot, loadProjectConfig } from "../project/loader.js";
-import { ActionPackageResolver } from "../project/resolver.js";
 import { hasPendingTransactions, isProjectLockHeld, recoverPendingTransactions } from "../project/transactions.js";
 import { listLinkedPackages } from "../registry/registry.js";
 import { InMemoryEventSink } from "../runtime/events.js";
-import { ACTION_CALL_CYCLE, ACTION_MAX_DEPTH_EXCEEDED, ACTION_NOT_FOUND, ACTION_PACKAGE_VERSION_CONFLICT, ACTION_SUBRUN_LIMIT, INVALID_ACTION_REF, MAX_SUBRUNS_REACHED, PACKAGE_NOT_FOUND, PROJECT_BUSY, PROJECT_RECOVERY_REQUIRED, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
+import { ActionDockError, ACTION_NOT_FOUND, ACTION_PACKAGE_VERSION_CONFLICT, ACTION_SUBRUN_LIMIT, INVALID_ACTION_REF, PACKAGE_NOT_FOUND, PROJECT_BUSY, PROJECT_RECOVERY_REQUIRED, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
+import { InvocationPolicy } from "../invocation/policy.js";
 import { DataDirLock } from "../storage/data-dir-lock.js";
-import { ambiguousActionMessage, buildRuntimeError, collectPackageInfos, describeActionAcrossApps, describeVisiblePlaybook, isRootCallVisible, listVisiblePlaybooks, packageNotFoundMessage, parseRefLoose, resolveProjectRoot, resolveShortRef, } from "./routing.js";
-function isActionDockApp(item) {
+import { DefaultActionCatalog, DefaultPackageGraph, PackageGraphBuilder, resolveAction, } from "../catalog/index.js";
+import { buildRuntimeError, collectPackageInfos, describeActionAcrossRuntimes, describeVisiblePlaybook, isRootCallVisible, listVisiblePlaybooks, packageNotFoundMessage, parseRefLoose, resolveProjectRoot, } from "./routing.js";
+import { ServiceError } from "../service/types.js";
+import { CAPABILITY_UNAVAILABLE } from "../errors.js";
+import { createGlobalStorage, isSecretConfigKey } from "../storage/index.js";
+import { filterByIntent } from "../filter/index.js";
+function isPackageRuntime(item) {
     return (typeof item === "object" &&
         item !== null &&
         "info" in item &&
@@ -17,18 +24,12 @@ function isActionDockApp(item) {
         "runAction" in item &&
         typeof item.runAction === "function");
 }
-/**
- * ActionDock 统一多包宿主容器默认实现。
- * 负责聚合与调度多个 ActionDockApp 实例，提供跨包引用路由、依赖声明校验与资源配额控制。
- */
 export class DefaultActionDockHost {
     hostSessionId;
     options;
-    apps = new Map();
-    internallyCreatedApps = new Set();
-    activeSubRunsPerRoot = new Map();
+    runtimes = new Map();
+    policy;
     hostPublicPackageIds = new Set();
-    resolver;
     maxCallDepth;
     maxSubRuns;
     eventSink;
@@ -36,89 +37,167 @@ export class DefaultActionDockHost {
     dataDirLock;
     failedLinkedPackages = new Map();
     failedAutoLoad;
-    /** 透传给内部创建 App 的存储收割开关（Host 默认持有者身份，显式可关） */
+    /** 透传给内部创建 Runtime 的存储收割开关（Host 默认持有者身份，显式可关） */
     recoverOrphans;
-    constructor(options = {}) {
+    graph;
+    catalog;
+    globalStorage;
+    constructor(options = {}, internalOptions) {
         this.hostSessionId = randomUUID();
         this.options = options;
         this.maxCallDepth = options.maxCallDepth ?? 16;
         this.maxSubRuns = options.maxSubRuns ?? 64;
+        this.policy = new InvocationPolicy({
+            maxCallDepth: this.maxCallDepth,
+            maxSubRuns: this.maxSubRuns,
+        });
         this.eventSink = options.eventSink ?? options.platform?.eventSink ?? new InMemoryEventSink();
         // Host 默认声明数据目录持有者身份；查询旁观方（CLI 查询命令）显式置 false
         this.recoverOrphans = options.recoverOrphans !== false;
+        this.graph = new DefaultPackageGraph(new Map());
+        this.catalog = new DefaultActionCatalog(this.graph);
         // 当指定非内存 dataDir 时获取排他目录锁，防止并发冲突
         if (options.dataDir && !options.inMemory) {
             this.dataDirLock = DataDirLock.acquire(options.dataDir, {
                 hostSessionId: this.hostSessionId,
             });
         }
+        if (internalOptions?.deferInit) {
+            return;
+        }
         try {
-            // 阶段一：注册显式传入的 packages 列表
-            this.registerExplicitPackages(options);
-            // 阶段二：自动加载当前工程（若发现工程根目录且未显式禁用）
-            if (options.autoLoadCurrentProject !== false) {
-                this.loadCurrentProject(options);
-            }
-            // 阶段三：扫描已软链接的外部包并注册至 Host
-            if (options.scanLinkedPackages) {
-                this.registerLinkedPackages(options);
-            }
+            this.initializeSync();
         }
         catch (err) {
-            try {
-                this.dataDirLock?.release();
-            }
-            catch {
-                // 忽略排他锁释放异常
+            this.rollbackSync();
+            throw err;
+        }
+    }
+    initializeSync() {
+        // 阶段一：注册显式传入的 packages 列表
+        this.registerExplicitPackages(this.options);
+        // 阶段二：自动加载当前工程（若发现工程根目录且未显式禁用）
+        if (this.options.autoLoadCurrentProject !== false) {
+            this.loadCurrentProject(this.options);
+        }
+        // 阶段三：扫描已软链接的外部包并注册至 Host
+        if (this.options.scanLinkedPackages) {
+            this.registerLinkedPackages(this.options);
+        }
+        this.rebuildGraphAndCatalog();
+    }
+    async initializeAsync() {
+        // 阶段一：注册显式传入的 packages 列表
+        this.registerExplicitPackages(this.options);
+        // 阶段二：自动加载当前工程（若发现工程根目录且未显式禁用）
+        if (this.options.autoLoadCurrentProject !== false) {
+            const root = resolveProjectRoot(this.options, () => findProjectRoot());
+            if (root) {
+                if (isProjectLockHeld(root)) {
+                    throw new ActionDockError(PROJECT_BUSY, "PROJECT_BUSY: Project directory is locked by another active process holding project.lock");
+                }
+                // 依据事务日志恢复未完成提交的悬空事务（锁持有者存活时严禁判定为崩溃事务并禁止自动恢复）
+                if (hasPendingTransactions(root)) {
+                    await recoverPendingTransactions(root, { frozenInstall: true });
+                }
             }
-            this.dataDirLock = undefined;
-            // 仅安全关闭宿主内部创建的子 app，外部传入的 app 保持调用方生命周期与所有权
-            for (const app of this.internallyCreatedApps) {
+            this.loadCurrentProject(this.options);
+        }
+        // 阶段三：扫描已软链接的外部包并注册至 Host
+        if (this.options.scanLinkedPackages) {
+            this.registerLinkedPackages(this.options);
+        }
+        this.rebuildGraphAndCatalog();
+    }
+    /**
+     * 安全回滚初始化失败时所占用的资源。
+     *
+     * 同步语境（构造函数路径）下对 runtime.close() 采用 fire-and-forget：
+     * 仅附加吞没异常的 catch 处理器，不 await，避免构造链路引入异步;
+     * 异步语境下逐个 await 全部 runtime.close() 后再依次释放全局存储与目录锁。
+     */
+    async rollbackResources(sync) {
+        if (sync) {
+            // 安全关闭宿主管理的所有 Runtime 实例（同步语境 fire-and-forget）
+            for (const runtime of this.runtimes.values()) {
                 try {
-                    const closePromise = app.close();
+                    const closePromise = runtime.close();
                     if (closePromise && typeof closePromise.catch === "function") {
                         closePromise.catch(() => { });
                     }
                 }
                 catch {
-                    // 忽略 app 关闭异常
+                    // 忽略 runtime 关闭异常
                 }
             }
-            this.internallyCreatedApps.clear();
-            this.apps.clear();
-            throw err;
         }
+        else {
+            const allRuntimes = Array.from(this.runtimes.values());
+            await Promise.all(allRuntimes.map(async (runtime) => {
+                try {
+                    await runtime.close();
+                }
+                catch {
+                    // 忽略 Runtime 关闭异常
+                }
+            }));
+        }
+        this.runtimes.clear();
+        try {
+            this.globalStorage?.close();
+        }
+        catch {
+            // 忽略全局存储关闭异常
+        }
+        this.globalStorage = undefined;
+        try {
+            this.dataDirLock?.release();
+        }
+        catch {
+            // 忽略排他锁释放异常
+        }
+        this.dataDirLock = undefined;
+        this.isClosed = true;
     }
     /**
-     * 阶段函数：注册显式传入的 packages 列表（现成 App 实例或 AppOptions 配置）。
+     * 异步安全回滚初始化失败时所占用的资源。
+     */
+    async rollbackInitialization() {
+        await this.rollbackResources(false);
+    }
+    rollbackSync() {
+        void this.rollbackResources(true);
+    }
+    /**
+     * 阶段函数：注册显式传入的 packages 列表（PackageRuntimeOptions 配置或包目录物理路径）。
      */
     registerExplicitPackages(options) {
         if (!options.packages || !Array.isArray(options.packages)) {
             return;
         }
         for (const item of options.packages) {
-            if (isActionDockApp(item)) {
-                this.registerAppInternal(item, true);
+            if (isPackageRuntime(item)) {
+                this.registerRuntimeInternal(item, true);
             }
             else {
-                const app = new DefaultActionDockApp({
-                    ...item,
+                const packageOptions = typeof item === "string" ? { packageRoot: item } : item;
+                const runtime = new DefaultPackageRuntime({
+                    ...packageOptions,
                     hostSessionId: this.hostSessionId,
-                    platform: item.platform ?? options.platform,
-                    inMemory: item.inMemory ?? options.inMemory,
-                    customHome: item.customHome ?? options.customHome,
-                    dataDir: item.dataDir ?? options.dataDir,
-                    clock: item.clock ?? options.clock,
-                    process: item.process ?? options.process,
-                    logger: item.logger ?? options.logger,
-                    eventSink: item.eventSink ?? this.eventSink,
-                    maxCallDepth: item.maxCallDepth ?? this.maxCallDepth,
-                    maxSubRuns: item.maxSubRuns ?? this.maxSubRuns,
+                    globalStorage: packageOptions.globalStorage ?? this.getGlobalStorage(),
+                    platform: packageOptions.platform ?? options.platform,
+                    inMemory: packageOptions.inMemory ?? options.inMemory,
+                    customHome: packageOptions.customHome ?? options.customHome,
+                    dataDir: packageOptions.dataDir ?? options.dataDir,
+                    clock: packageOptions.clock ?? options.clock,
+                    process: packageOptions.process ?? options.process,
+                    logger: packageOptions.logger ?? options.logger,
+                    eventSink: packageOptions.eventSink ?? this.eventSink,
+                    maxCallDepth: packageOptions.maxCallDepth ?? this.maxCallDepth,
+                    maxSubRuns: packageOptions.maxSubRuns ?? this.maxSubRuns,
                     recoverOrphans: this.recoverOrphans,
-                    packageContextResolver: this.resolvePackageContext.bind(this),
                 });
-                this.internallyCreatedApps.add(app);
-                this.registerAppInternal(app, true);
+                this.registerRuntimeInternal(runtime, true);
             }
         }
     }
@@ -149,25 +228,28 @@ export class DefaultActionDockHost {
         }
         try {
             const config = loadProjectConfig(root);
-            this.hostPublicPackageIds.add(config.id);
-            this.resolver = new ActionPackageResolver({
+            const builder = new PackageGraphBuilder({
                 projectRoot: root,
                 manifest: config,
                 allowDevLinks: options.scanLinkedPackages,
                 customHome: options.customHome,
             });
-            const graph = this.resolver.resolveSync();
-            this.hostPublicPackageIds.add(graph.rootPackageId);
+            const graph = builder.buildSync();
+            if (graph.rootPackageId) {
+                this.hostPublicPackageIds.add(graph.rootPackageId);
+            }
             for (const depId of graph.directDependencyIds) {
                 this.hostPublicPackageIds.add(depId);
             }
             for (const pkg of graph.packages.values()) {
-                if (!this.apps.has(pkg.packageId)) {
+                if (!this.runtimes.has(pkg.packageId)) {
                     const isDirectOrRoot = this.hostPublicPackageIds.has(pkg.packageId);
-                    const app = new DefaultActionDockApp({
-                        packageRoot: pkg.packageRoot,
+                    const runtime = new DefaultPackageRuntime({
+                        packageRoot: pkg.root,
                         projectConfig: pkg.manifest,
+                        identity: pkg.identity,
                         hostSessionId: this.hostSessionId,
+                        globalStorage: this.getGlobalStorage(),
                         platform: options.platform,
                         inMemory: options.inMemory,
                         customHome: options.customHome,
@@ -179,10 +261,8 @@ export class DefaultActionDockHost {
                         maxCallDepth: this.maxCallDepth,
                         maxSubRuns: this.maxSubRuns,
                         recoverOrphans: this.recoverOrphans,
-                        packageContextResolver: this.resolvePackageContext.bind(this),
                     });
-                    this.internallyCreatedApps.add(app);
-                    this.registerAppInternal(app, isDirectOrRoot);
+                    this.registerRuntimeInternal(runtime, isDirectOrRoot);
                 }
             }
         }
@@ -208,7 +288,7 @@ export class DefaultActionDockHost {
      */
     registerLinkedPackages(options) {
         for (const linked of listLinkedPackages(options.customHome)) {
-            if (this.apps.has(linked.id)) {
+            if (this.runtimes.has(linked.id)) {
                 continue;
             }
             if (!existsSync(linked.path)) {
@@ -220,10 +300,11 @@ export class DefaultActionDockHost {
             try {
                 const config = loadProjectConfig(linked.path);
                 this.hostPublicPackageIds.add(linked.id);
-                const app = new DefaultActionDockApp({
+                const runtime = new DefaultPackageRuntime({
                     packageRoot: linked.path,
                     projectConfig: config,
                     hostSessionId: this.hostSessionId,
+                    globalStorage: this.getGlobalStorage(),
                     platform: options.platform,
                     inMemory: options.inMemory,
                     customHome: options.customHome,
@@ -235,10 +316,8 @@ export class DefaultActionDockHost {
                     maxCallDepth: this.maxCallDepth,
                     maxSubRuns: this.maxSubRuns,
                     recoverOrphans: this.recoverOrphans,
-                    packageContextResolver: this.resolvePackageContext.bind(this),
                 });
-                this.internallyCreatedApps.add(app);
-                this.registerAppInternal(app, true);
+                this.registerRuntimeInternal(runtime, true);
             }
             catch (err) {
                 const errDetail = err?.message || String(err);
@@ -247,119 +326,225 @@ export class DefaultActionDockHost {
             }
         }
     }
-    resolvePackageContext(packageId) {
-        const targetApp = this.getApp(packageId);
-        if (!targetApp)
-            return undefined;
-        return {
-            projectRoot: targetApp.packageRoot,
-            projectConfig: targetApp.projectConfig,
-            storage: targetApp.storage,
-            actions: targetApp.actionsMap,
-            packageInstanceId: targetApp.packageInstanceId,
-            generationId: targetApp.generationId,
-        };
-    }
-    bindApp(app) {
-        const runner = app.executionService?.runner;
-        if (runner && typeof runner.setPackageContextResolver === "function") {
-            runner.setPackageContextResolver(this.resolvePackageContext.bind(this));
+    bindRuntime(runtime) {
+        const invoker = this.createActionInvoker(runtime);
+        if ("setActionInvoker" in runtime && typeof runtime.setActionInvoker === "function") {
+            runtime.setActionInvoker(invoker);
         }
     }
-    /** 路由可见性上下文（公开包集合与依赖解析器） */
+    /**
+     * 构造应用专属动作调用委托器。
+     * 铁律 2：跨包调用改走 ActionInvoker 回到 Host 执行主链，经由唯一的 InvocationPolicy 授权后调用目标 Package 的 ExecutionService。
+     */
+    createActionInvoker(callerRuntime) {
+        return async (childAction, childInput, context) => {
+            const resolved = resolveAction(childAction, {
+                caller: callerRuntime.packageId,
+                graph: this.graph,
+                catalog: this.catalog,
+            });
+            const targetPackageId = resolved.package.id;
+            const targetActionId = resolved.ref.actionId;
+            const isSamePackage = targetPackageId === callerRuntime.packageId;
+            const targetRuntime = isSamePackage ? callerRuntime : this.getRuntime(targetPackageId);
+            if (!targetRuntime) {
+                throw new ActionDockError(PACKAGE_NOT_FOUND, packageNotFoundMessage(targetPackageId, this.failedLinkedPackages));
+            }
+            // 跨包 uses 依赖声明校验（统一委托 InvocationPolicy 单一事实源）
+            if (!isSamePackage) {
+                let declaredUses = context.caller?.declaredUses;
+                if (!declaredUses) {
+                    try {
+                        const callerSpec = await callerRuntime.describeAction(context.caller?.actionId || "");
+                        declaredUses = callerSpec.uses;
+                    }
+                    catch {
+                        // 忽略规范提取异常
+                    }
+                }
+                const authErr = this.policy.checkUsesAuthorization({
+                    packageId: callerRuntime.packageId,
+                    actionId: context.caller?.actionId || "",
+                    declaredUses,
+                }, { packageId: targetPackageId, actionId: targetActionId }, this.graph);
+                if (authErr) {
+                    throw new ActionDockError(authErr.code, authErr.message, authErr.details);
+                }
+            }
+            // 调用嵌套深度限制校验
+            const depthErr = this.policy.checkCallDepth(context.callStack, targetActionId, context.maxCallDepth);
+            if (depthErr) {
+                throw new ActionDockError(depthErr.code, depthErr.message, depthErr.details);
+            }
+            // 调用链环路死锁检测
+            const cycle = this.policy.checkCycle(context.callStack, targetActionId, targetPackageId, callerRuntime.packageId);
+            if (cycle.error) {
+                throw new ActionDockError(cycle.error.code, cycle.error.message, cycle.error.details);
+            }
+            // 针对根运行的并发子任务配额校验与申请
+            const rootRunId = context.rootRunId;
+            const quotaErr = this.policy.checkSubRunQuota(rootRunId);
+            if (quotaErr) {
+                throw new ActionDockError(quotaErr.code, quotaErr.message, quotaErr.details);
+            }
+            if (!this.policy.acquireSubRun(rootRunId)) {
+                throw new ActionDockError(ACTION_SUBRUN_LIMIT, `Maximum concurrent sub-runs (${this.policy.maxSubRuns}) reached`, { limit: this.policy.maxSubRuns });
+            }
+            try {
+                const nextCallStack = [...context.callStack, cycle.callKey];
+                const targetOwner = context.owner
+                    ? {
+                        tenantId: context.owner.tenantId,
+                        principalId: context.owner.principalId,
+                        packageInstanceId: isSamePackage
+                            ? (context.owner.packageInstanceId || callerRuntime.identity.instanceId)
+                            : targetRuntime.identity.instanceId,
+                        generationId: isSamePackage
+                            ? (context.owner.generationId || callerRuntime.identity.generation)
+                            : targetRuntime.identity.generation,
+                    }
+                    : undefined;
+                const subInvocationContext = {
+                    runId: context.runId,
+                    rootRunId: context.rootRunId,
+                    parentRunId: context.parentRunId,
+                    caller: context.caller,
+                    callStack: nextCallStack,
+                    package: targetRuntime.identity,
+                    signal: context.signal,
+                    timeoutMs: context.timeoutMs,
+                    config: context.config,
+                    requestId: context.requestId,
+                    tenantId: context.tenantId,
+                    principalId: context.principalId,
+                    hostSessionId: context.hostSessionId || this.hostSessionId,
+                    maxCallDepth: context.maxCallDepth ?? this.maxCallDepth,
+                    logger: context.logger,
+                    progress: context.progress,
+                    process: context.process,
+                    owner: targetOwner,
+                };
+                const ticket = await targetRuntime.startInvocation(targetActionId, childInput, subInvocationContext);
+                if (!ticket.result) {
+                    throw new Error(`Execution ticket for run '${ticket.runId}' has no result Promise`);
+                }
+                const result = await ticket.result;
+                if (!result.ok) {
+                    throw new ActionDockError(result.error.code, result.error.message, result.error.details);
+                }
+                return result.data;
+            }
+            finally {
+                this.policy.releaseSubRun(rootRunId);
+            }
+        };
+    }
+    /** 路由可见性上下文（公开包集合与包依赖图） */
     visibility() {
         return {
             hostPublicPackageIds: this.hostPublicPackageIds,
-            resolver: this.resolver,
+            graph: this.graph,
         };
     }
-    getApp(packageId) {
-        return this.apps.get(packageId);
+    rebuildGraphAndCatalog() {
+        const discovered = Array.from(this.runtimes.values()).map((runtime) => ({
+            id: runtime.packageId,
+            root: runtime.packageRoot || "",
+            manifest: runtime.projectConfig,
+            identity: runtime.identity,
+            isCurrentProject: this.hostPublicPackageIds.has(runtime.packageId),
+        }));
+        const rootRuntime = Array.from(this.runtimes.values()).find((runtime) => this.hostPublicPackageIds.has(runtime.packageId));
+        const builder = new PackageGraphBuilder({
+            packages: discovered,
+            root: rootRuntime?.packageRoot || rootRuntime?.packageId,
+        });
+        this.graph = builder.buildSync();
+        this.catalog = new DefaultActionCatalog(this.graph, (pkgId) => {
+            const runtime = this.getRuntime(pkgId);
+            if (!runtime)
+                return undefined;
+            return new Map(runtime.actionsMap);
+        });
+        this.policy.setVisibilityContext(this.visibility());
     }
-    listApps() {
-        return Array.from(this.apps.values());
+    getRuntime(packageId) {
+        return this.runtimes.get(packageId);
     }
-    /**
-     * 获取自动加载工程的失败诊断信息。
-     * 仅自动探测场景会记录此诊断；显式传入 projectRoot 的加载失败会直接抛出，不产生此诊断。
-     */
-    getAutoLoadFailure() {
-        return this.failedAutoLoad;
+    listRuntimes() {
+        return Array.from(this.runtimes.values());
     }
-    registerAppInternal(app, isPublic) {
-        if (this.apps.has(app.packageId)) {
-            const existing = this.apps.get(app.packageId);
-            if (existing === app) {
+    registerRuntimeInternal(runtime, isPublic) {
+        if (this.runtimes.has(runtime.packageId)) {
+            const existing = this.runtimes.get(runtime.packageId);
+            if (existing === runtime) {
                 return;
             }
-            throw new Error(`Package ID conflict: package '${app.packageId}' is already registered in host`);
+            throw new Error(`Package ID conflict: package '${runtime.packageId}' is already registered in host`);
         }
-        this.apps.set(app.packageId, app);
+        this.runtimes.set(runtime.packageId, runtime);
         if (isPublic) {
-            this.hostPublicPackageIds.add(app.packageId);
+            this.hostPublicPackageIds.add(runtime.packageId);
         }
-        this.bindApp(app);
+        this.bindRuntime(runtime);
+        this.rebuildGraphAndCatalog();
         // 接管与恢复：仅持有者身份的 Host 自动将死亡会话或遗留非终态运行收敛为 interrupted；
         // 旁观查询 Host（CLI state/runs/config 命令）跳过本步骤，不动其他进程的在途记录
         if (this.recoverOrphans) {
-            const st = app.storage;
-            if (st && typeof st.recoverDeadSessionRuns === "function") {
+            if (typeof runtime.recoverDeadSessionRuns === "function") {
                 try {
-                    st.recoverDeadSessionRuns(this.hostSessionId);
+                    runtime.recoverDeadSessionRuns(this.hostSessionId);
                 }
                 catch (err) {
                     // 单包恢复失败不阻断整体接管流程，但必须可观测
-                    console.warn(`[actiondock] recoverDeadSessionRuns failed for package '${app.packageId}': ${err instanceof Error ? err.message : String(err)}`);
+                    console.warn(`[actiondock] recoverDeadSessionRuns failed for package '${runtime.packageId}': ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
         }
     }
-    registerApp(app) {
-        this.registerAppInternal(app, true);
+    registerRuntime(runtime) {
+        this.registerRuntimeInternal(runtime, true);
     }
     async info() {
-        return collectPackageInfos(this.listApps());
+        return collectPackageInfos(this.listRuntimes());
     }
     async listActions(options) {
-        let results = [];
-        const apps = this.listApps();
-        for (const app of apps) {
-            const appSummaries = await app.listActions();
-            for (const item of appSummaries) {
-                if (!isRootCallVisible(app.packageId, item.id, this.hostPublicPackageIds, this.resolver)) {
+        // 外层完成可见性筛选与跨包限定名改写后，统一委托共享过滤函数完成检索
+        const results = [];
+        const runtimes = this.listRuntimes();
+        for (const runtime of runtimes) {
+            const runtimeSummaries = await runtime.listActions();
+            for (const item of runtimeSummaries) {
+                if (!isRootCallVisible(runtime.packageId, item.id, this.hostPublicPackageIds, this.graph)) {
                     continue;
                 }
-                const qualifiedId = apps.length > 1 && !item.id.includes("/")
-                    ? `${app.packageId}/${item.id}`
+                const qualifiedId = runtimes.length > 1 && !item.id.includes("/")
+                    ? `${runtime.packageId}/${item.id}`
                     : item.id;
                 results.push({
                     ...item,
                     id: qualifiedId,
-                    packageId: app.packageId,
+                    packageId: runtime.packageId,
                 });
             }
         }
-        if (options?.tags && options.tags.length > 0) {
-            results = results.filter((s) => options.tags.every((t) => s.tags?.includes(t)));
-        }
-        if (options?.query) {
-            const q = options.query.toLowerCase();
-            results = results.filter((s) => s.id.toLowerCase().includes(q) ||
-                (s.description && s.description.toLowerCase().includes(q)));
-        }
-        if (options?.prefix) {
-            results = results.filter((s) => s.id.startsWith(options.prefix));
-        }
-        return results;
+        return applyActionSummaryFilters(results, options);
     }
     async describeAction(ref) {
-        return describeActionAcrossApps(ref, this.listApps(), this.visibility(), this.failedLinkedPackages);
+        return describeActionAcrossRuntimes(ref, this.listRuntimes(), this.visibility(), this.failedLinkedPackages, this.catalog, this.graph);
     }
-    async listPlaybooks() {
-        return listVisiblePlaybooks(this.listApps(), this.visibility());
+    async listPlaybooks(options) {
+        let pbs = await listVisiblePlaybooks(this.listRuntimes(), this.visibility());
+        if (options?.package) {
+            pbs = pbs.filter((p) => p.packageId === options.package);
+        }
+        if (options?.intent) {
+            pbs = filterByIntent(pbs, options.intent, [(p) => p.id, (p) => p.description || "", (p) => p.packageId || "", (p) => (p.actions || []).join(" ")], false);
+        }
+        return pbs;
     }
     async describePlaybook(id) {
-        return describeVisiblePlaybook(this.listApps(), id, this.visibility());
+        return describeVisiblePlaybook(this.listRuntimes(), id, this.visibility());
     }
     async runAction(ref, input, options = {}) {
         const ticket = await this.startAction(ref, input, options);
@@ -372,185 +557,136 @@ export class DefaultActionDockHost {
         if (this.isClosed) {
             throw new Error("ActionDockHost is closed: new tasks rejected");
         }
-        // - 解析目标包与 Action 动作标识
-        const parsed = parseRefLoose(ref);
-        let targetApp;
-        let targetActionId = parsed.actionId;
-        let targetPackageId = parsed.packageId;
-        if (targetPackageId) {
-            targetApp = this.getApp(targetPackageId);
-            if (!targetApp) {
-                const runId = randomUUID();
-                const error = buildRuntimeError(PACKAGE_NOT_FOUND, packageNotFoundMessage(targetPackageId, this.failedLinkedPackages));
-                return {
-                    runId,
-                    status: "failed",
-                    result: Promise.resolve({ ok: false, runId, error }),
-                };
-            }
+        // - 统一基于纯领域 resolveAction 解析目标包与 Action 动作标识
+        let resolved;
+        try {
+            resolved = resolveAction(ref, {
+                graph: this.graph,
+                catalog: this.catalog,
+            });
         }
-        else {
-            const resolution = await resolveShortRef(this.listApps(), targetActionId, this.visibility());
-            if (resolution.kind === "unique") {
-                targetApp = resolution.app;
-                targetPackageId = targetApp.packageId;
-            }
-            else if (resolution.kind === "ambiguous") {
-                const runId = randomUUID();
-                const error = buildRuntimeError(INVALID_ACTION_REF, ambiguousActionMessage(targetActionId, resolution.candidates), { alias: "AMBIGUOUS_ACTION_REF", candidates: resolution.candidates });
-                return {
-                    runId,
-                    status: "failed",
-                    result: Promise.resolve({ ok: false, runId, error }),
-                };
+        catch (err) {
+            const runId = randomUUID();
+            let code = err.code || ACTION_NOT_FOUND;
+            let message = err.message || String(err);
+            if (code === PACKAGE_NOT_FOUND) {
+                code = PACKAGE_NOT_FOUND;
+                const parsed = parseRefLoose(ref);
+                if (parsed.packageId) {
+                    message = packageNotFoundMessage(parsed.packageId, this.failedLinkedPackages);
+                }
             }
-            else {
-                const runId = randomUUID();
-                const error = buildRuntimeError(ACTION_NOT_FOUND, `Action '${targetActionId}' not found in any registered package`);
+            else if (code === INVALID_ACTION_REF && err.details?.alias === "AMBIGUOUS_ACTION_REF") {
                 return {
                     runId,
                     status: "failed",
-                    result: Promise.resolve({ ok: false, runId, error }),
+                    result: Promise.resolve({
+                        ok: false,
+                        runId,
+                        error: buildRuntimeError(INVALID_ACTION_REF, message, err.details),
+                    }),
                 };
             }
-        }
-        // 根调用可见性鉴权
-        const parentRunId = options.parentRunId;
-        if (!parentRunId && targetPackageId) {
-            if (!isRootCallVisible(targetPackageId, targetActionId, this.hostPublicPackageIds, this.resolver)) {
-                const runId = randomUUID();
-                const error = buildRuntimeError(UNDECLARED_ACTION_DEPENDENCY, `Root call to action '${targetPackageId}/${targetActionId}' is not allowed: package '${targetPackageId}' is not declared as a direct dependency in actiondock.json and is not delegated by a visible playbook`, { target: `${targetPackageId}/${targetActionId}` });
-                return {
+            return {
+                runId,
+                status: "failed",
+                result: Promise.resolve({
+                    ok: false,
                     runId,
-                    status: "failed",
-                    result: Promise.resolve({ ok: false, runId, error }),
-                };
-            }
-        }
-        // - 父子任务血缘关系、调用配额与跨包 uses 声明依赖校验
-        let effectiveRootRunId = options.rootRunId;
-        if (parentRunId) {
-            const parentRun = await this.getRun(parentRunId);
-            if (parentRun) {
-                effectiveRootRunId = effectiveRootRunId || parentRun.rootRunId || parentRunId;
-                // 跨包 uses 依赖声明校验
-                const callerPackageId = parentRun.packageId;
-                const callerActionId = parentRun.actionId;
-                if (callerPackageId && callerPackageId !== targetPackageId) {
-                    const callerApp = this.getApp(callerPackageId);
-                    if (callerApp) {
-                        try {
-                            const callerSpec = await callerApp.describeAction(callerActionId);
-                            const usesList = callerSpec.uses || [];
-                            const targetRef = `${targetPackageId}/${targetActionId}`;
-                            const isAllowed = this.resolver
-                                ? this.resolver.canCascadeCall(callerPackageId, callerActionId, targetPackageId, targetActionId)
-                                : usesList.some((u) => u === targetRef || u === `${targetPackageId}/*` || u === targetPackageId);
-                            if (!isAllowed) {
-                                const runId = randomUUID();
-                                const error = buildRuntimeError(UNDECLARED_ACTION_DEPENDENCY, `Action '${callerPackageId}/${callerActionId}' does not declare dependency on '${targetRef}' in 'uses'`, {
-                                    caller: `${callerPackageId}/${callerActionId}`,
-                                    target: targetRef,
-                                    declaredUses: usesList,
-                                });
-                                return {
-                                    runId,
-                                    status: "failed",
-                                    result: Promise.resolve({ ok: false, runId, error }),
-                                };
-                            }
-                        }
-                        catch {
-                            // 忽略规范提取异常，交由执行服务执行
-                        }
-                    }
-                }
-                // 调用嵌套深度限制校验
-                let depth = 1;
-                let cur = parentRun;
-                while (cur && cur.parentRunId) {
-                    depth++;
-                    if (depth > this.maxCallDepth)
-                        break;
-                    cur = await this.getRun(cur.parentRunId);
-                }
-                if (depth >= this.maxCallDepth) {
-                    const runId = randomUUID();
-                    const error = buildRuntimeError(ACTION_CALL_CYCLE, `Maximum call depth of ${this.maxCallDepth} exceeded`, { alias: ACTION_MAX_DEPTH_EXCEEDED, reason: "depth_exceeded", maxDepth: this.maxCallDepth });
-                    return {
-                        runId,
-                        status: "failed",
-                        result: Promise.resolve({ ok: false, runId, error }),
-                    };
-                }
-                // 针对根运行的并发子任务数限制校验
-                if (effectiveRootRunId) {
-                    const currentSubRuns = this.activeSubRunsPerRoot.get(effectiveRootRunId) || 0;
-                    if (currentSubRuns >= this.maxSubRuns) {
-                        const runId = randomUUID();
-                        const error = buildRuntimeError(ACTION_SUBRUN_LIMIT, `Maximum concurrent sub-runs (${this.maxSubRuns}) reached for root run '${effectiveRootRunId}'`, { alias: MAX_SUBRUNS_REACHED, limit: this.maxSubRuns });
-                        return {
-                            runId,
-                            status: "failed",
-                            result: Promise.resolve({ ok: false, runId, error }),
-                        };
-                    }
-                }
-            }
-        }
-        // - 构造子运行参数并调度至目标 App 执行
-        const execOptions = {
-            ...options,
-            rootRunId: effectiveRootRunId,
-            parentRunId,
-            hostSessionId: this.hostSessionId,
-            maxCallDepth: options.maxCallDepth ?? this.maxCallDepth,
-        };
-        if (parentRunId && effectiveRootRunId) {
-            this.activeSubRunsPerRoot.set(effectiveRootRunId, (this.activeSubRunsPerRoot.get(effectiveRootRunId) || 0) + 1);
-        }
-        let ticket;
+                    error: buildRuntimeError(code, message),
+                }),
+            };
+        }
+        const targetPackageId = resolved.package.id;
+        const targetActionId = resolved.ref.actionId;
+        const targetRuntime = this.getRuntime(targetPackageId);
+        if (!targetRuntime) {
+            const runId = randomUUID();
+            const error = buildRuntimeError(PACKAGE_NOT_FOUND, packageNotFoundMessage(targetPackageId, this.failedLinkedPackages));
+            return {
+                runId,
+                status: "failed",
+                result: Promise.resolve({ ok: false, runId, error }),
+            };
+        }
+        // 根调用可见性鉴权（统一委托 InvocationPolicy 单一事实源断言）
         try {
-            ticket = await targetApp.startAction(targetActionId, input, execOptions);
+            this.policy.assertRootVisibility(resolved, this.visibility());
         }
         catch (err) {
-            // 启动失败（并发上限、仓储不可用、幂等冲突等）时必须回滚配额计数，避免泄漏后误拒后续合法子任务
-            if (parentRunId && effectiveRootRunId) {
-                const cnt = this.activeSubRunsPerRoot.get(effectiveRootRunId) || 1;
-                if (cnt <= 1) {
-                    this.activeSubRunsPerRoot.delete(effectiveRootRunId);
-                }
-                else {
-                    this.activeSubRunsPerRoot.set(effectiveRootRunId, cnt - 1);
-                }
-            }
-            throw err;
-        }
-        if (parentRunId && effectiveRootRunId && ticket.result) {
-            const rootId = effectiveRootRunId;
-            ticket.result = ticket.result.finally(() => {
-                const cnt = this.activeSubRunsPerRoot.get(rootId) || 1;
-                if (cnt <= 1) {
-                    this.activeSubRunsPerRoot.delete(rootId);
-                }
-                else {
-                    this.activeSubRunsPerRoot.set(rootId, cnt - 1);
-                }
-            });
-        }
-        return ticket;
+            const runId = randomUUID();
+            return {
+                runId,
+                status: "failed",
+                result: Promise.resolve({
+                    ok: false,
+                    runId,
+                    error: buildRuntimeError(err.code || UNDECLARED_ACTION_DEPENDENCY, err.message, err.details),
+                }),
+            };
+        }
+        // 在边界安全组装受信任的根调用上下文（纯 Root Call，无父级血缘）
+        const rootKey = `${targetPackageId}/${targetActionId}`;
+        const rootContext = createRootInvocationContext({
+            targetPackage: targetRuntime.identity,
+            callStack: [rootKey],
+            signal: options.signal,
+            timeoutMs: options.timeoutMs,
+            config: options.config,
+            requestId: options.requestId,
+            hostSessionId: this.hostSessionId,
+            maxCallDepth: this.maxCallDepth,
+            process: this.options.process,
+        });
+        // 调度目标包执行服务
+        return targetRuntime.startInvocation(targetActionId, input, rootContext);
     }
     async getRun(runId) {
-        for (const app of this.listApps()) {
-            const record = await app.getRun(runId);
+        for (const runtime of this.listRuntimes()) {
+            const record = await runtime.getRun(runId);
             if (record)
                 return record;
         }
         return undefined;
     }
+    async listRuns(query) {
+        const runtimes = query?.packageId
+            ? [this.getRuntime(query.packageId)].filter(Boolean)
+            : this.listRuntimes();
+        const records = [];
+        for (const runtime of runtimes) {
+            const recs = await runtime.listRuns(query);
+            for (const r of recs) {
+                records.push({
+                    ...r,
+                    packageId: r.packageId || runtime.packageId,
+                });
+            }
+        }
+        records.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+        let result = records;
+        if (query?.intent) {
+            result = filterByIntent(result, query.intent, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
+        }
+        if (query?.limit && result.length > query.limit) {
+            result.length = query.limit;
+        }
+        return result;
+    }
+    async clearRuns(options) {
+        const runtimes = options?.packageId
+            ? [this.getRuntime(options.packageId)].filter(Boolean)
+            : this.listRuntimes();
+        let total = 0;
+        for (const runtime of runtimes) {
+            const res = await runtime.clearRuns(options);
+            total += res;
+        }
+        return total;
+    }
     async cancelRun(runId, reason) {
-        for (const app of this.listApps()) {
-            const res = await app.cancelRun(runId, reason);
+        for (const runtime of this.listRuntimes()) {
+            const res = await runtime.cancelRun(runId, reason);
             if (res.outcome !== "not_found") {
                 return res;
             }
@@ -558,43 +694,169 @@ export class DefaultActionDockHost {
         return { outcome: "not_found", runId };
     }
     events(runId, options) {
-        for (const app of this.listApps()) {
-            if (app.executionService?.getActiveHandle?.(runId)) {
-                return app.events(runId, options);
+        for (const runtime of this.listRuntimes()) {
+            const storageRecord = runtime.storage?.getRun?.(runId);
+            if (storageRecord) {
+                return runtime.events(runId, options);
             }
         }
-        for (const app of this.listApps()) {
-            const storageRecord = app.storage?.getRun?.(runId);
-            if (storageRecord) {
-                return app.events(runId, options);
+        const firstRuntime = this.listRuntimes()[0];
+        if (firstRuntime) {
+            return firstRuntime.events(runId, options);
+        }
+        return this.eventSink.subscribe(runId, options);
+    }
+    getGlobalStorage() {
+        if (!this.globalStorage) {
+            const hasInMemoryPackage = this.options.packages?.some((item) => typeof item !== "string" && !isPackageRuntime(item) && item.inMemory);
+            const inMemory = Boolean(this.options.inMemory || hasInMemoryPackage);
+            this.globalStorage =
+                this.options.platform?.storage?.createGlobalStorage?.({
+                    dataDir: this.options.dataDir,
+                    customHome: this.options.customHome,
+                }) ??
+                    createGlobalStorage({
+                        dataDir: this.options.dataDir,
+                        customHome: this.options.customHome,
+                        inMemory,
+                    });
+        }
+        return this.globalStorage;
+    }
+    findDeclaredConfigItem(key) {
+        let foundItem;
+        for (const runtime of this.listRuntimes()) {
+            const item = runtime.projectConfig?.config?.[key];
+            if (item) {
+                if (item.secret)
+                    return item;
+                foundItem = item;
             }
         }
-        const firstApp = this.listApps()[0];
-        if (firstApp) {
-            return firstApp.events(runId, options);
+        return foundItem;
+    }
+    resolveRuntime(packageId) {
+        if (packageId) {
+            return this.getRuntime(packageId);
         }
-        return (async function* () { })();
+        const runtimes = this.listRuntimes();
+        return runtimes.length === 1 ? runtimes[0] : undefined;
+    }
+    /**
+     * 解析目标包运行时：未命中时抛出统一的包未找到错误。
+     */
+    requireRuntime(packageId) {
+        const runtime = this.resolveRuntime(packageId);
+        if (!runtime) {
+            throw new Error(`Package '${packageId}' not found in host`);
+        }
+        return runtime;
+    }
+    async getConfig(packageId, key) {
+        if (packageId === "global") {
+            const globalStorage = this.getGlobalStorage();
+            const val = globalStorage.getConfig(key);
+            const configured = val !== undefined;
+            const declaredItem = this.findDeclaredConfigItem(key);
+            const isSecret = isSecretConfigKey(key, declaredItem);
+            return {
+                key,
+                configured,
+                secret: isSecret,
+                source: configured ? "global" : "default",
+                value: !isSecret && configured ? val : undefined,
+            };
+        }
+        return this.requireRuntime(packageId).getConfig(key);
+    }
+    async setConfig(packageId, key, value) {
+        if (packageId === "global") {
+            await this.getGlobalStorage().setConfig(key, value);
+            return;
+        }
+        await this.requireRuntime(packageId).setConfig(key, value);
+    }
+    async deleteConfig(packageId, key) {
+        if (packageId === "global") {
+            return await this.getGlobalStorage().deleteConfig(key);
+        }
+        return await this.requireRuntime(packageId).deleteConfig(key);
+    }
+    async listConfig(packageId) {
+        if (packageId === "global") {
+            const globalStorage = this.getGlobalStorage();
+            const all = globalStorage.listConfig();
+            return Object.entries(all).map(([key, val]) => {
+                const declaredItem = this.findDeclaredConfigItem(key);
+                const isSecret = isSecretConfigKey(key, declaredItem);
+                return {
+                    key,
+                    configured: true,
+                    secret: isSecret,
+                    source: "global",
+                    value: isSecret ? undefined : val,
+                };
+            });
+        }
+        return this.requireRuntime(packageId).listConfig();
+    }
+    async getState(packageId, actionId, key, options) {
+        return this.requireRuntime(packageId).getState(actionId, key, options);
+    }
+    async setState(packageId, actionId, key, value, options) {
+        const runtime = this.requireRuntime(packageId);
+        if (actionId) {
+            await runtime.setActionState(actionId, key, value, options);
+        }
+        else {
+            await runtime.setState(key, value, options);
+        }
+    }
+    async deleteState(packageId, actionId, key, options) {
+        return this.requireRuntime(packageId).deleteState(actionId, key, options);
+    }
+    async listStateKeys(packageId, actionId, options) {
+        return this.requireRuntime(packageId).listStateKeys(actionId, options);
+    }
+    async clearState(packageId, actionId, options) {
+        return this.requireRuntime(packageId).clearState(actionId, options);
+    }
+    async listStateEntries(packageId, options) {
+        const runtime = this.resolveRuntime(packageId);
+        if (!runtime) {
+            throw new ServiceError(CAPABILITY_UNAVAILABLE, `CAPABILITY_UNAVAILABLE: Package '${packageId}' not found in host`);
+        }
+        if (!runtime.listStateEntries) {
+            return [];
+        }
+        return runtime.listStateEntries(options);
     }
     /**
      * 优雅关闭宿主容器。
-     * 仅对内部创建的 App 实例执行 close 并安全释放底层资源；
-     * 外部传入借用的 App 实例生命周期完全由调用方负责管理，Host 关闭时仅解绑引用并清理自身内部实例。
+     * 仅对内部创建的 Runtime 实例执行 close 并安全释放底层资源；
+     * 外部传入借用的 Runtime 实例生命周期完全由调用方负责管理，Host 关闭时仅解绑引用并清理自身内部实例。
      */
     async close(options) {
         if (this.isClosed)
             return;
         this.isClosed = true;
-        const internalApps = Array.from(this.internallyCreatedApps);
-        await Promise.all(internalApps.map(async (app) => {
+        const allRuntimes = Array.from(this.runtimes.values());
+        await Promise.all(allRuntimes.map(async (runtime) => {
             try {
-                await app.close(options);
+                await runtime.close(options);
             }
             catch {
-                // 忽略内部 App 关闭异常，确保全部安全释放
+                // 忽略 Runtime 关闭异常，确保全部安全释放
             }
         }));
-        this.internallyCreatedApps.clear();
-        this.apps.clear();
+        this.runtimes.clear();
+        try {
+            this.globalStorage?.close();
+        }
+        catch {
+            // 忽略全局存储关闭异常
+        }
+        this.globalStorage = undefined;
         try {
             this.dataDirLock?.release();
         }
@@ -610,30 +872,17 @@ export class DefaultActionDockHost {
 export async function createActionDockHost(options = {}) {
     let createdHost;
     try {
-        if (options.autoLoadCurrentProject !== false) {
-            const root = resolveProjectRoot(options, () => findProjectRoot());
-            if (root) {
-                if (isProjectLockHeld(root)) {
-                    const err = new Error("PROJECT_BUSY: Project directory is locked by another active process holding project.lock");
-                    err.code = PROJECT_BUSY;
-                    throw err;
-                }
-                // 依据事务日志恢复未完成提交的悬空事务（锁持有者存活时严禁判定为崩溃事务并禁止自动恢复）
-                if (hasPendingTransactions(root)) {
-                    await recoverPendingTransactions(root, { frozenInstall: true });
-                }
-            }
-        }
-        createdHost = new DefaultActionDockHost(options);
+        createdHost = new DefaultActionDockHost(options, { deferInit: true });
+        await createdHost.initializeAsync();
         return createdHost;
     }
     catch (err) {
         if (createdHost) {
             try {
-                await createdHost.close();
+                await createdHost.rollbackInitialization();
             }
             catch {
-                // 忽略宿主关闭异常
+                // 忽略宿主回滚异常，确保抛出原始异常
             }
         }
         throw err;