@actiondock/core 2.9.1 → 2.11.0

package/dist/host/host.js

@@ -7,15 +7,16 @@ import { findProjectRoot, loadProjectConfig } from "../project/loader.js";
 import { hasPendingTransactions, isProjectLockHeld, recoverPendingTransactions } from "../project/transactions.js";
 import { listLinkedPackages } from "../registry/registry.js";
 import { InMemoryEventSink } from "../runtime/events.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 { ActionDockError, ACTION_NOT_FOUND, ACTION_PACKAGE_VERSION_CONFLICT, ACTION_SUBRUN_LIMIT, EXECUTION_FAILED, INVALID_ACTION_REF, PACKAGE_ID_CONFLICT, PACKAGE_NOT_FOUND, PROJECT_BUSY, PROJECT_RECOVERY_REQUIRED, SERVICE_CLOSED, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
 import { InvocationPolicy } from "../invocation/policy.js";
+import { createAbortError } from "../ipc/service.js";
 import { DataDirLock } from "../storage/data-dir-lock.js";
 import { DefaultActionCatalog, DefaultPackageGraph, PackageGraphBuilder, resolveAction, } from "../catalog/index.js";
+import { parseActionRef } from "../catalog/resolve-action.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";
+import { filterByIntent } from "../utils/intent.js";
 function isPackageRuntime(item) {
     return (typeof item === "object" &&
         item !== null &&
@@ -24,6 +25,36 @@ function isPackageRuntime(item) {
         "runAction" in item &&
         typeof item.runAction === "function");
 }
+/** 并发解析运行记录归属包（公共端口查询，不新建执行服务） */
+async function findRunOwnerRuntime(runtimes, runId) {
+    const results = await Promise.all(runtimes.map(async (rt) => ({ rt, record: await rt.getRun(runId).catch(() => undefined) })));
+    return results.find((r) => r.record !== undefined)?.rt;
+}
+/**
+ * 包装异步操作以响应 AbortSignal 取消信号。
+ * 若信号已中止立即抛出 AbortError，否则挂载一次性中止监听并在操作完成时注销。
+ */
+function withAbortSignal(op, signal) {
+    if (signal?.aborted) {
+        throw createAbortError(signal.reason);
+    }
+    if (!signal) {
+        return op();
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            reject(createAbortError(signal.reason));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        op().then((res) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(res);
+        }, (err) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(err);
+        });
+    });
+}
 export class DefaultActionDockHost {
     hostSessionId;
     options;
@@ -42,7 +73,30 @@ export class DefaultActionDockHost {
     graph;
     catalog;
     globalStorage;
+    initPromise;
+    isInitialized = false;
+    discovery;
+    execution;
+    runs;
+    events;
+    management;
+    /** 自引用 host 属性，向后兼容服务实例字段访问 */
+    get host() {
+        return this;
+    }
+    /**
+     * @deprecated 直接使用 new DefaultActionDockHost() 构造已弃用，请迁移至 createActionDockHost() 异步工厂函数以完成完整的生命周期初始化。
+     */
     constructor(options = {}, internalOptions) {
+        if (!internalOptions?.fromFactory) {
+            const warnMsg = "[Host] Direct instantiation via new DefaultActionDockHost() is @deprecated and only performs minimal object assembly. Use createActionDockHost() for full lifecycle initialization.";
+            if (options.logger?.warn) {
+                options.logger.warn(warnMsg);
+            }
+            else {
+                console.warn(warnMsg);
+            }
+        }
         this.hostSessionId = randomUUID();
         this.options = options;
         this.maxCallDepth = options.maxCallDepth ?? 16;
@@ -56,92 +110,254 @@ export class DefaultActionDockHost {
         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;
+        const self = this;
+        this.discovery = {
+            async listPackages() {
+                await self.ensureInitialized();
+                return self.info();
+            },
+            async listActions(opts) {
+                await self.ensureInitialized();
+                return self.listActions(opts);
+            },
+            async describeAction(ref) {
+                await self.ensureInitialized();
+                return self.describeAction(ref);
+            },
+            async listPlaybooks(opts) {
+                await self.ensureInitialized();
+                return self.listPlaybooks(opts);
+            },
+            async describePlaybook(id) {
+                await self.ensureInitialized();
+                return self.describePlaybook(id);
+            },
+        };
+        this.execution = {
+            async run(ref, input, opts) {
+                await self.ensureInitialized();
+                const actionRef = typeof ref === "string" ? parseActionRef(ref) : ref;
+                const cleanOpts = {
+                    signal: opts?.signal,
+                    timeoutMs: opts?.timeoutMs,
+                    config: opts?.config,
+                    requestId: opts?.requestId,
+                };
+                return self.runAction(actionRef, (input ?? {}), cleanOpts);
+            },
+            async start(ref, input, opts) {
+                await self.ensureInitialized();
+                const actionRef = typeof ref === "string" ? parseActionRef(ref) : ref;
+                const cleanOpts = {
+                    signal: opts?.signal,
+                    timeoutMs: opts?.timeoutMs,
+                    config: opts?.config,
+                    requestId: opts?.requestId,
+                };
+                return self.startAction(actionRef, (input ?? {}), cleanOpts);
+            },
+        };
+        this.runs = {
+            async list(query, options) {
+                await self.ensureInitialized();
+                const effectiveSignal = options?.signal ?? query?.signal;
+                return withAbortSignal(() => self.listRuns(query, effectiveSignal), effectiveSignal);
+            },
+            async count(query, options) {
+                await self.ensureInitialized();
+                const effectiveSignal = options?.signal ?? query?.signal;
+                return withAbortSignal(() => self.countRuns(query, effectiveSignal), effectiveSignal);
+            },
+            async get(runId, options) {
+                await self.ensureInitialized();
+                const effectiveSignal = options?.signal;
+                return withAbortSignal(() => self.getRun(runId, effectiveSignal), effectiveSignal);
+            },
+            async cancel(runId, reason) {
+                await self.ensureInitialized();
+                return self.cancelRun(runId, reason);
+            },
+            async clear(opts) {
+                await self.ensureInitialized();
+                return self.clearRuns(opts);
+            },
+            async cleanExpired(policy) {
+                await self.ensureInitialized();
+                return self.cleanExpiredRuns(policy);
+            },
+        };
+        const eventsFn = ((runId, opts) => {
+            return (async function* () {
+                await self.ensureInitialized();
+                yield* self.subscribeEvents(runId, opts);
+            })();
+        });
+        eventsFn.events = (runId, opts) => {
+            return (async function* () {
+                await self.ensureInitialized();
+                yield* self.subscribeEvents(runId, opts);
+            })();
+        };
+        this.events = eventsFn;
+        if (options.enableManagement !== false) {
+            this.management = {
+                config: {
+                    async get(packageId, key) {
+                        await self.ensureInitialized();
+                        return self.getConfig(packageId, key);
+                    },
+                    async set(packageId, key, value) {
+                        await self.ensureInitialized();
+                        return self.setConfig(packageId, key, value);
+                    },
+                    async delete(packageId, key) {
+                        await self.ensureInitialized();
+                        return self.deleteConfig(packageId, key);
+                    },
+                    async list(packageId) {
+                        await self.ensureInitialized();
+                        return self.listConfig(packageId);
+                    },
+                },
+                state: {
+                    async get(packageId, actionId, key, opts) {
+                        await self.ensureInitialized();
+                        return self.getState(packageId, actionId, key, opts);
+                    },
+                    async set(packageId, actionId, key, value, opts) {
+                        await self.ensureInitialized();
+                        return self.setState(packageId, actionId, key, value, opts);
+                    },
+                    async delete(packageId, actionId, key, opts) {
+                        await self.ensureInitialized();
+                        return self.deleteState(packageId, actionId, key, opts);
+                    },
+                    async list(packageId, actionId, opts) {
+                        await self.ensureInitialized();
+                        return self.listStateKeys(packageId, actionId, opts);
+                    },
+                    async clear(packageId, actionId, opts) {
+                        await self.ensureInitialized();
+                        return self.clearState(packageId, actionId, opts);
+                    },
+                    async listEntries(packageId, opts) {
+                        await self.ensureInitialized();
+                        return self.listStateEntries(packageId, opts);
+                    },
+                },
+            };
         }
+    }
+    /**
+     * 静态工厂方法：创建并初始化 ActionDockHost 宿主容器。
+     */
+    static async create(options = {}) {
+        let createdHost;
         try {
-            this.initializeSync();
+            createdHost = new DefaultActionDockHost(options, { fromFactory: true });
+            await createdHost.ensureInitialized();
+            return createdHost;
         }
         catch (err) {
-            this.rollbackSync();
+            if (createdHost) {
+                try {
+                    await createdHost.rollbackInitialization();
+                }
+                catch {
+                    // 忽略宿主回滚异常，确保抛出原始异常
+                }
+            }
             throw err;
         }
     }
-    initializeSync() {
-        // 阶段一：注册显式传入的 packages 列表
-        this.registerExplicitPackages(this.options);
-        // 阶段二：自动加载当前工程（若发现工程根目录且未显式禁用）
-        if (this.options.autoLoadCurrentProject !== false) {
-            this.loadCurrentProject(this.options);
+    /**
+     * 确保宿主容器已完成异步生命周期初始化。
+     * 当通过 ActionDockHost.create() / createActionDockHost() 创建时在工厂阶段预先就绪；
+     * 当直接通过 new DefaultActionDockHost() 构造时，在首次异步调用时惰性触发加载。
+     */
+    async ensureInitialized() {
+        if (this.isInitialized) {
+            return;
         }
-        // 阶段三：扫描已软链接的外部包并注册至 Host
-        if (this.options.scanLinkedPackages) {
-            this.registerLinkedPackages(this.options);
+        if (this.isClosed) {
+            throw new ActionDockError(SERVICE_CLOSED, "ActionDockHost is closed");
         }
-        this.rebuildGraphAndCatalog();
+        if (!this.initPromise) {
+            this.initPromise = this.performInitialization();
+        }
+        await this.initPromise;
     }
-    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 });
-                }
+    async performInitialization() {
+        try {
+            // 当指定非内存 dataDir 且以持有者身份打开时获取排他目录锁，防止并发冲突；
+            // 旁观 Host（recoverOrphans: false）不获取执行宿主的排他锁，也不创建数据目录
+            if (this.options.dataDir &&
+                !this.options.inMemory &&
+                this.recoverOrphans &&
+                !this.dataDirLock) {
+                this.dataDirLock = DataDirLock.acquire(this.options.dataDir, {
+                    hostSessionId: this.hostSessionId,
+                });
+            }
+            // 阶段一：注册显式传入的 packages 列表（仅建立身份与路由，不打开资源）
+            this.registerExplicitPackages(this.options);
+            // 阶段二：自动加载当前工程（若发现工程根目录且未显式禁用）
+            if (this.options.autoLoadCurrentProject !== false) {
+                await this.loadCurrentProject(this.options);
+            }
+            // 阶段三：扫描已软链接的外部包并注册至 Host（仅建立身份与路由）
+            if (this.options.scanLinkedPackages) {
+                this.registerLinkedPackages(this.options);
             }
-            this.loadCurrentProject(this.options);
+            this.rebuildGraphAndCatalog();
+            // 阶段四：持有者身份在工厂返回前显式预热全部内部包的存储与运行记录恢复；
+            // 旁观身份（recoverOrphans: false）跳过预热，首次持久化调用时才按需打开
+            if (this.recoverOrphans) {
+                await this.prewarmManagedRuntimes();
+            }
+            this.isInitialized = true;
         }
-        // 阶段三：扫描已软链接的外部包并注册至 Host
-        if (this.options.scanLinkedPackages) {
-            this.registerLinkedPackages(this.options);
+        catch (err) {
+            this.initPromise = undefined;
+            try {
+                await this.rollbackInitialization();
+            }
+            catch {
+                // 吞没回滚自身的副错误以确保向上抛出原始的初始化异常
+            }
+            throw err;
         }
-        this.rebuildGraphAndCatalog();
     }
     /**
-     * 安全回滚初始化失败时所占用的资源。
-     *
-     * 同步语境（构造函数路径）下对 runtime.close() 采用 fire-and-forget：
-     * 仅附加吞没异常的 catch 处理器，不 await，避免构造链路引入异步;
-     * 异步语境下逐个 await 全部 runtime.close() 后再依次释放全局存储与目录锁。
+     * 持有者预热：等待内部创建的全部包完成存储准备（含运行记录恢复），
+     * 并打开共享全局存储。预热的是存储，不是执行服务、进程接口或业务模块；
+     * 任一包准备失败按既有初始化失败时机整体回滚。
+     * 外部注入的 Runtime 保持既有生命周期约定，不在此预热。
      */
-    async rollbackResources(sync) {
-        if (sync) {
-            // 安全关闭宿主管理的所有 Runtime 实例（同步语境 fire-and-forget）
-            for (const runtime of this.runtimes.values()) {
-                try {
-                    const closePromise = runtime.close();
-                    if (closePromise && typeof closePromise.catch === "function") {
-                        closePromise.catch(() => { });
-                    }
-                }
-                catch {
-                    // 忽略 runtime 关闭异常
-                }
-            }
-        }
-        else {
-            const allRuntimes = Array.from(this.runtimes.values());
-            await Promise.all(allRuntimes.map(async (runtime) => {
-                try {
-                    await runtime.close();
-                }
-                catch {
-                    // 忽略 Runtime 关闭异常
-                }
-            }));
+    async prewarmManagedRuntimes() {
+        const managed = Array.from(this.runtimes.values()).filter((rt) => rt instanceof DefaultPackageRuntime);
+        if (managed.length === 0) {
+            return;
         }
+        await Promise.all(managed.map((rt) => rt.prepareResources()));
+        // 持有者在返回前打开共享全局存储，保留对全局库存储错误的提前发现能力
+        this.getGlobalStorage();
+    }
+    /**
+     * 异步安全回滚初始化失败时所占用的资源。
+     */
+    async rollbackInitialization() {
+        this.isInitialized = false;
+        this.initPromise = undefined;
+        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();
@@ -159,15 +375,6 @@ export class DefaultActionDockHost {
         this.dataDirLock = undefined;
         this.isClosed = true;
     }
-    /**
-     * 异步安全回滚初始化失败时所占用的资源。
-     */
-    async rollbackInitialization() {
-        await this.rollbackResources(false);
-    }
-    rollbackSync() {
-        void this.rollbackResources(true);
-    }
     /**
      * 阶段函数：注册显式传入的 packages 列表（PackageRuntimeOptions 配置或包目录物理路径）。
      */
@@ -184,7 +391,8 @@ export class DefaultActionDockHost {
                 const runtime = new DefaultPackageRuntime({
                     ...packageOptions,
                     hostSessionId: this.hostSessionId,
-                    globalStorage: packageOptions.globalStorage ?? this.getGlobalStorage(),
+                    globalStorage: packageOptions.globalStorage,
+                    globalStorageProvider: () => this.getGlobalStorage(),
                     platform: packageOptions.platform ?? options.platform,
                     inMemory: packageOptions.inMemory ?? options.inMemory,
                     customHome: packageOptions.customHome ?? options.customHome,
@@ -210,21 +418,22 @@ export class DefaultActionDockHost {
      * - 自动探测场景（未传 projectRoot，由 findProjectRoot 发现）失败时记录实例诊断
      *   failedAutoLoad 并在创建时输出单行告警，保持宿主其余能力可用但绝不无声。
      */
-    loadCurrentProject(options) {
+    async loadCurrentProject(options) {
         const explicitRoot = options.projectRoot;
         const root = resolveProjectRoot(options, () => findProjectRoot());
         if (!root) {
             return;
         }
         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;
+            throw new ActionDockError(PROJECT_BUSY, "PROJECT_BUSY: Project directory is locked by another active process holding project.lock");
         }
         if (hasPendingTransactions(root)) {
-            const err = new Error(`PROJECT_RECOVERY_REQUIRED: Project directory '${root}' has pending transactions requiring recovery; use async createActionDockHost() to recover automatically`);
-            err.code = PROJECT_RECOVERY_REQUIRED;
-            throw err;
+            // 旁观路径（recoverOrphans: false）不自动恢复待恢复事务：
+            // 不触发依赖安装或清单回滚，直接报告恢复需求，由持有者入口完成恢复
+            if (!this.recoverOrphans) {
+                throw new ActionDockError(PROJECT_RECOVERY_REQUIRED, `PROJECT_RECOVERY_REQUIRED: Project at '${root}' has pending transactions requiring recovery. Run an owner command (e.g. 'ad add' or 'ad run') to complete recovery before querying.`);
+            }
+            await recoverPendingTransactions(root, { frozenInstall: true });
         }
         try {
             const config = loadProjectConfig(root);
@@ -249,7 +458,7 @@ export class DefaultActionDockHost {
                         projectConfig: pkg.manifest,
                         identity: pkg.identity,
                         hostSessionId: this.hostSessionId,
-                        globalStorage: this.getGlobalStorage(),
+                        globalStorageProvider: () => this.getGlobalStorage(),
                         platform: options.platform,
                         inMemory: options.inMemory,
                         customHome: options.customHome,
@@ -304,7 +513,7 @@ export class DefaultActionDockHost {
                     packageRoot: linked.path,
                     projectConfig: config,
                     hostSessionId: this.hostSessionId,
-                    globalStorage: this.getGlobalStorage(),
+                    globalStorageProvider: () => this.getGlobalStorage(),
                     platform: options.platform,
                     inMemory: options.inMemory,
                     customHome: options.customHome,
@@ -368,7 +577,9 @@ export class DefaultActionDockHost {
                     declaredUses,
                 }, { packageId: targetPackageId, actionId: targetActionId }, this.graph);
                 if (authErr) {
-                    throw new ActionDockError(authErr.code, authErr.message, authErr.details);
+                    const hint = authErr.details?.hint;
+                    const msg = hint ? `${authErr.message}\n${hint}` : authErr.message;
+                    throw new ActionDockError(authErr.code, msg, authErr.details, undefined, hint);
                 }
             }
             // 调用嵌套深度限制校验
@@ -426,7 +637,7 @@ export class DefaultActionDockHost {
                 };
                 const ticket = await targetRuntime.startInvocation(targetActionId, childInput, subInvocationContext);
                 if (!ticket.result) {
-                    throw new Error(`Execution ticket for run '${ticket.runId}' has no result Promise`);
+                    throw new ActionDockError(EXECUTION_FAILED, `Execution ticket for run '${ticket.runId}' has no result Promise`);
                 }
                 const result = await ticket.result;
                 if (!result.ok) {
@@ -480,7 +691,7 @@ export class DefaultActionDockHost {
             if (existing === runtime) {
                 return;
             }
-            throw new Error(`Package ID conflict: package '${runtime.packageId}' is already registered in host`);
+            throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${runtime.packageId}' is already registered in host`);
         }
         this.runtimes.set(runtime.packageId, runtime);
         if (isPublic) {
@@ -488,27 +699,18 @@ export class DefaultActionDockHost {
         }
         this.bindRuntime(runtime);
         this.rebuildGraphAndCatalog();
-        // 接管与恢复：仅持有者身份的 Host 自动将死亡会话或遗留非终态运行收敛为 interrupted；
-        // 旁观查询 Host（CLI state/runs/config 命令）跳过本步骤，不动其他进程的在途记录
-        if (this.recoverOrphans) {
-            if (typeof runtime.recoverDeadSessionRuns === "function") {
-                try {
-                    runtime.recoverDeadSessionRuns(this.hostSessionId);
-                }
-                catch (err) {
-                    // 单包恢复失败不阻断整体接管流程，但必须可观测
-                    console.warn(`[actiondock] recoverDeadSessionRuns failed for package '${runtime.packageId}': ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-        }
+        // 注册阶段只建立身份与路由；运行记录恢复收敛到包存储准备路径（持有者工厂预热时统一执行），
+        // 旁观 Host 注册不触碰其他进程的在途记录
     }
     registerRuntime(runtime) {
         this.registerRuntimeInternal(runtime, true);
     }
     async info() {
+        await this.ensureInitialized();
         return collectPackageInfos(this.listRuntimes());
     }
     async listActions(options) {
+        await this.ensureInitialized();
         // 外层完成可见性筛选与跨包限定名改写后，统一委托共享过滤函数完成检索
         const results = [];
         const runtimes = this.listRuntimes();
@@ -531,9 +733,11 @@ export class DefaultActionDockHost {
         return applyActionSummaryFilters(results, options);
     }
     async describeAction(ref) {
+        await this.ensureInitialized();
         return describeActionAcrossRuntimes(ref, this.listRuntimes(), this.visibility(), this.failedLinkedPackages, this.catalog, this.graph);
     }
     async listPlaybooks(options) {
+        await this.ensureInitialized();
         let pbs = await listVisiblePlaybooks(this.listRuntimes(), this.visibility());
         if (options?.package) {
             pbs = pbs.filter((p) => p.packageId === options.package);
@@ -544,18 +748,21 @@ export class DefaultActionDockHost {
         return pbs;
     }
     async describePlaybook(id) {
+        await this.ensureInitialized();
         return describeVisiblePlaybook(this.listRuntimes(), id, this.visibility());
     }
     async runAction(ref, input, options = {}) {
+        await this.ensureInitialized();
         const ticket = await this.startAction(ref, input, options);
         if (!ticket.result) {
-            throw new Error(`Execution ticket for run '${ticket.runId}' has no result Promise`);
+            throw new ActionDockError(EXECUTION_FAILED, `Execution ticket for run '${ticket.runId}' has no result Promise`);
         }
         return ticket.result;
     }
     async startAction(ref, input, options = {}) {
+        await this.ensureInitialized();
         if (this.isClosed) {
-            throw new Error("ActionDockHost is closed: new tasks rejected");
+            throw new ActionDockError(SERVICE_CLOSED, "ActionDockHost is closed: new tasks rejected");
         }
         // - 统一基于纯领域 resolveAction 解析目标包与 Action 动作标识
         let resolved;
@@ -641,21 +848,151 @@ export class DefaultActionDockHost {
         // 调度目标包执行服务
         return targetRuntime.startInvocation(targetActionId, input, rootContext);
     }
-    async getRun(runId) {
+    async getRun(runId, signal) {
+        await this.ensureInitialized();
+        if (signal?.aborted) {
+            throw createAbortError(signal.reason);
+        }
         for (const runtime of this.listRuntimes()) {
+            if (signal?.aborted) {
+                throw createAbortError(signal.reason);
+            }
             const record = await runtime.getRun(runId);
+            if (signal?.aborted) {
+                throw createAbortError(signal.reason);
+            }
             if (record)
                 return record;
         }
         return undefined;
     }
-    async listRuns(query) {
+    async listRuns(query, signal) {
+        await this.ensureInitialized();
+        const effectiveSignal = signal ?? query?.signal;
+        if (effectiveSignal?.aborted) {
+            throw createAbortError(effectiveSignal.reason);
+        }
         const runtimes = query?.packageId
             ? [this.getRuntime(query.packageId)].filter(Boolean)
-            : this.listRuntimes();
+            : query?.packageAllowlist && query.packageAllowlist.length > 0
+                ? query.packageAllowlist.map((id) => this.getRuntime(id)).filter(Boolean)
+                : this.listRuntimes();
+        // 当存在 intent 过滤时：分批读取并在内存中累积命中记录，先过滤后分页
+        if (query?.intent) {
+            const intentStr = query.intent;
+            const matchedRecords = [];
+            const BATCH_SIZE = 100;
+            const targetLimit = query.limit;
+            const targetOffset = query.offset ?? 0;
+            const neededCount = targetLimit !== undefined ? targetOffset + targetLimit : Infinity;
+            if (runtimes.length === 1) {
+                const runtime = runtimes[0];
+                let batchOffset = 0;
+                while (true) {
+                    if (effectiveSignal?.aborted) {
+                        throw createAbortError(effectiveSignal.reason);
+                    }
+                    const batch = await runtime.listRuns({
+                        actionId: query.actionId,
+                        status: query.status,
+                        requestIds: query.requestIds,
+                        limit: BATCH_SIZE,
+                        offset: batchOffset,
+                        signal: effectiveSignal,
+                    });
+                    if (effectiveSignal?.aborted) {
+                        throw createAbortError(effectiveSignal.reason);
+                    }
+                    if (batch.length === 0)
+                        break;
+                    batchOffset += batch.length;
+                    const normalized = batch.map((r) => ({
+                        ...r,
+                        packageId: r.packageId || runtime.packageId,
+                    }));
+                    const filtered = filterByIntent(normalized, intentStr, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
+                    matchedRecords.push(...filtered);
+                    if (matchedRecords.length >= neededCount) {
+                        break;
+                    }
+                    if (batch.length < BATCH_SIZE) {
+                        break;
+                    }
+                }
+            }
+            else {
+                for (const runtime of runtimes) {
+                    if (effectiveSignal?.aborted) {
+                        throw createAbortError(effectiveSignal.reason);
+                    }
+                    let batchOffset = 0;
+                    while (true) {
+                        if (effectiveSignal?.aborted) {
+                            throw createAbortError(effectiveSignal.reason);
+                        }
+                        const batch = await runtime.listRuns({
+                            actionId: query.actionId,
+                            status: query.status,
+                            requestIds: query.requestIds,
+                            limit: BATCH_SIZE,
+                            offset: batchOffset,
+                            signal: effectiveSignal,
+                        });
+                        if (effectiveSignal?.aborted) {
+                            throw createAbortError(effectiveSignal.reason);
+                        }
+                        if (batch.length === 0)
+                            break;
+                        batchOffset += batch.length;
+                        const normalized = batch.map((r) => ({
+                            ...r,
+                            packageId: r.packageId || runtime.packageId,
+                        }));
+                        const filtered = filterByIntent(normalized, intentStr, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
+                        matchedRecords.push(...filtered);
+                        if (batch.length < BATCH_SIZE) {
+                            break;
+                        }
+                    }
+                }
+                matchedRecords.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+            }
+            const end = targetLimit !== undefined ? targetOffset + targetLimit : undefined;
+            return matchedRecords.slice(targetOffset, end);
+        }
+        // 当不存在 intent 过滤时：
+        if (runtimes.length === 1) {
+            if (effectiveSignal?.aborted) {
+                throw createAbortError(effectiveSignal.reason);
+            }
+            const runtime = runtimes[0];
+            const recs = await runtime.listRuns(query ? { ...query, signal: effectiveSignal } : { signal: effectiveSignal });
+            if (effectiveSignal?.aborted) {
+                throw createAbortError(effectiveSignal.reason);
+            }
+            return recs.map((r) => ({
+                ...r,
+                packageId: r.packageId || runtime.packageId,
+            }));
+        }
+        // 跨包联合查询：下推 limit/offset 或合并排序
         const records = [];
+        const fetchLimit = query?.limit !== undefined
+            ? (query.offset ?? 0) + query.limit
+            : undefined;
         for (const runtime of runtimes) {
-            const recs = await runtime.listRuns(query);
+            if (effectiveSignal?.aborted) {
+                throw createAbortError(effectiveSignal.reason);
+            }
+            const recs = await runtime.listRuns({
+                ...query,
+                offset: 0,
+                limit: fetchLimit,
+                signal: effectiveSignal,
+            });
+            if (effectiveSignal?.aborted) {
+                throw createAbortError(effectiveSignal.reason);
+            }
             for (const r of recs) {
                 records.push({
                     ...r,
@@ -664,16 +1001,87 @@ export class DefaultActionDockHost {
             }
         }
         records.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
-        let result = records;
+        const start = query?.offset ?? 0;
+        const end = query?.limit !== undefined ? start + query.limit : undefined;
+        return records.slice(start, end);
+    }
+    async countRuns(query, signal) {
+        await this.ensureInitialized();
+        const effectiveSignal = signal ?? query?.signal;
+        if (effectiveSignal?.aborted) {
+            throw createAbortError(effectiveSignal.reason);
+        }
+        const runtimes = query?.packageId
+            ? [this.getRuntime(query.packageId)].filter(Boolean)
+            : query?.packageAllowlist && query.packageAllowlist.length > 0
+                ? query.packageAllowlist.map((id) => this.getRuntime(id)).filter(Boolean)
+                : this.listRuntimes();
         if (query?.intent) {
-            result = filterByIntent(result, query.intent, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
+            const intentStr = query.intent;
+            let count = 0;
+            const BATCH_SIZE = 100;
+            for (const runtime of runtimes) {
+                if (effectiveSignal?.aborted) {
+                    throw createAbortError(effectiveSignal.reason);
+                }
+                let batchOffset = 0;
+                while (true) {
+                    if (effectiveSignal?.aborted) {
+                        throw createAbortError(effectiveSignal.reason);
+                    }
+                    const batch = await runtime.listRuns({
+                        actionId: query.actionId,
+                        status: query.status,
+                        requestIds: query.requestIds,
+                        limit: BATCH_SIZE,
+                        offset: batchOffset,
+                        signal: effectiveSignal,
+                    });
+                    if (effectiveSignal?.aborted) {
+                        throw createAbortError(effectiveSignal.reason);
+                    }
+                    if (batch.length === 0)
+                        break;
+                    batchOffset += batch.length;
+                    const normalized = batch.map((r) => ({
+                        ...r,
+                        packageId: r.packageId || runtime.packageId,
+                    }));
+                    const filtered = filterByIntent(normalized, intentStr, [(r) => r.id, (r) => r.actionId, (r) => r.status, (r) => r.packageId], false);
+                    count += filtered.length;
+                    if (batch.length < BATCH_SIZE) {
+                        break;
+                    }
+                }
+            }
+            return count;
         }
-        if (query?.limit && result.length > query.limit) {
-            result.length = query.limit;
+        let total = 0;
+        for (const runtime of runtimes) {
+            if (effectiveSignal?.aborted) {
+                throw createAbortError(effectiveSignal.reason);
+            }
+            if (typeof runtime.countRuns === "function") {
+                total += await runtime.countRuns(query ? { ...query, signal: effectiveSignal } : { signal: effectiveSignal });
+            }
+            else {
+                const all = await runtime.listRuns({
+                    actionId: query?.actionId,
+                    status: query?.status,
+                    requestIds: query?.requestIds,
+                    limit: 100_000,
+                    signal: effectiveSignal,
+                });
+                if (effectiveSignal?.aborted) {
+                    throw createAbortError(effectiveSignal.reason);
+                }
+                total += all.length;
+            }
         }
-        return result;
+        return total;
     }
     async clearRuns(options) {
+        await this.ensureInitialized();
         const runtimes = options?.packageId
             ? [this.getRuntime(options.packageId)].filter(Boolean)
             : this.listRuntimes();
@@ -685,6 +1093,7 @@ export class DefaultActionDockHost {
         return total;
     }
     async cleanExpiredRuns(policy) {
+        await this.ensureInitialized();
         let total = 0;
         for (const runtime of this.listRuntimes()) {
             if (typeof runtime.cleanExpiredRuns === "function") {
@@ -695,6 +1104,7 @@ export class DefaultActionDockHost {
         return total;
     }
     async cancelRun(runId, reason) {
+        await this.ensureInitialized();
         for (const runtime of this.listRuntimes()) {
             const res = await runtime.cancelRun(runId, reason);
             if (res.outcome !== "not_found") {
@@ -703,27 +1113,38 @@ export class DefaultActionDockHost {
         }
         return { outcome: "not_found", runId };
     }
-    events(runId, options) {
-        for (const runtime of this.listRuntimes()) {
-            const storageRecord = runtime.storage?.getRun?.(runId);
-            if (storageRecord) {
-                return runtime.events(runId, options);
+    subscribeEvents(runId, options) {
+        const self = this;
+        // 事件订阅可异步解析包归属：逐包并发查询运行记录（公共端口，不新建执行服务），
+        // 命中则使用该包事件源，全部未命中回退 Host 事件源
+        return (async function* () {
+            const runtimes = self.listRuntimes();
+            const owner = await findRunOwnerRuntime(runtimes, runId);
+            if (owner) {
+                yield* owner.events(runId, options);
+                return;
             }
-        }
-        const firstRuntime = this.listRuntimes()[0];
-        if (firstRuntime) {
-            return firstRuntime.events(runId, options);
-        }
-        return this.eventSink.subscribe(runId, options);
+            // Host 共享事件源作为统一回退（与执行服务装配使用同一 sink，完成事件不丢失）
+            yield* self.eventSink.subscribe(runId, options);
+        })();
     }
     getGlobalStorage() {
         if (!this.globalStorage) {
-            const hasInMemoryPackage = this.options.packages?.some((item) => typeof item !== "string" && !isPackageRuntime(item) && item.inMemory);
+            const hasInMemoryPackage = this.options.packages?.some((item) => {
+                if (typeof item === "string")
+                    return false;
+                if (isPackageRuntime(item)) {
+                    return Boolean(item.inMemory || item.options?.inMemory);
+                }
+                return Boolean(item.inMemory);
+            }) ||
+                Array.from(this.runtimes.values()).some((rt) => Boolean(rt.inMemory || rt.options?.inMemory));
             const inMemory = Boolean(this.options.inMemory || hasInMemoryPackage);
             this.globalStorage =
                 this.options.platform?.storage?.createGlobalStorage?.({
                     dataDir: this.options.dataDir,
                     customHome: this.options.customHome,
+                    ...(inMemory ? { inMemory: true } : {}),
                 }) ??
                     createGlobalStorage({
                         dataDir: this.options.dataDir,
@@ -758,11 +1179,12 @@ export class DefaultActionDockHost {
     requireRuntime(packageId) {
         const runtime = this.resolveRuntime(packageId);
         if (!runtime) {
-            throw new Error(`Package '${packageId}' not found in host`);
+            throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${packageId}' not found in host`);
         }
         return runtime;
     }
     async getConfig(packageId, key) {
+        await this.ensureInitialized();
         if (packageId === "global") {
             const globalStorage = this.getGlobalStorage();
             const val = globalStorage.getConfig(key);
@@ -780,6 +1202,7 @@ export class DefaultActionDockHost {
         return this.requireRuntime(packageId).getConfig(key);
     }
     async setConfig(packageId, key, value) {
+        await this.ensureInitialized();
         if (packageId === "global") {
             await this.getGlobalStorage().setConfig(key, value);
             return;
@@ -787,12 +1210,14 @@ export class DefaultActionDockHost {
         await this.requireRuntime(packageId).setConfig(key, value);
     }
     async deleteConfig(packageId, key) {
+        await this.ensureInitialized();
         if (packageId === "global") {
             return await this.getGlobalStorage().deleteConfig(key);
         }
         return await this.requireRuntime(packageId).deleteConfig(key);
     }
     async listConfig(packageId) {
+        await this.ensureInitialized();
         if (packageId === "global") {
             const globalStorage = this.getGlobalStorage();
             const all = globalStorage.listConfig();
@@ -811,11 +1236,13 @@ export class DefaultActionDockHost {
         return this.requireRuntime(packageId).listConfig();
     }
     async getState(packageId, actionId, key, options) {
+        await this.ensureInitialized();
         return this.requireRuntime(packageId).getState(actionId, key, options);
     }
     async setState(packageId, actionId, key, value, options) {
+        await this.ensureInitialized();
         const runtime = this.requireRuntime(packageId);
-        if (actionId) {
+        if (actionId !== undefined) {
             await runtime.setActionState(actionId, key, value, options);
         }
         else {
@@ -823,18 +1250,22 @@ export class DefaultActionDockHost {
         }
     }
     async deleteState(packageId, actionId, key, options) {
+        await this.ensureInitialized();
         return this.requireRuntime(packageId).deleteState(actionId, key, options);
     }
     async listStateKeys(packageId, actionId, options) {
+        await this.ensureInitialized();
         return this.requireRuntime(packageId).listStateKeys(actionId, options);
     }
     async clearState(packageId, actionId, options) {
+        await this.ensureInitialized();
         return this.requireRuntime(packageId).clearState(actionId, options);
     }
     async listStateEntries(packageId, options) {
+        await this.ensureInitialized();
         const runtime = this.resolveRuntime(packageId);
         if (!runtime) {
-            throw new ServiceError(CAPABILITY_UNAVAILABLE, `CAPABILITY_UNAVAILABLE: Package '${packageId}' not found in host`);
+            throw new ActionDockError(CAPABILITY_UNAVAILABLE, `CAPABILITY_UNAVAILABLE: Package '${packageId}' not found in host`);
         }
         if (!runtime.listStateEntries) {
             return [];
@@ -880,21 +1311,5 @@ export class DefaultActionDockHost {
  * 工厂函数：创建并初始化 ActionDockHost 宿主容器。
  */
 export async function createActionDockHost(options = {}) {
-    let createdHost;
-    try {
-        createdHost = new DefaultActionDockHost(options, { deferInit: true });
-        await createdHost.initializeAsync();
-        return createdHost;
-    }
-    catch (err) {
-        if (createdHost) {
-            try {
-                await createdHost.rollbackInitialization();
-            }
-            catch {
-                // 忽略宿主回滚异常，确保抛出原始异常
-            }
-        }
-        throw err;
-    }
+    return DefaultActionDockHost.create(options);
 }