@actiondock/core 2.19.0 → 2.21.0

package/dist/host/host.js

@@ -8,16 +8,20 @@ import { hasPendingTransactions, isProjectLockHeld, recoverPendingTransactions }
 import { listLinkedPackages } from "../registry/registry.js";
 import { InMemoryEventSink } from "../runtime/events.js";
 import { snapshotRunOrigin } from "../runtime/run-origin.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 { ActionDockError, ACTION_CANCELLED, ACTION_NOT_FOUND, ACTION_PACKAGE_VERSION_CONFLICT, ACTION_SUBRUN_LIMIT, ACTION_TIMEOUT, 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 { loadActionBindings, resolveActionBinding, validateActionBindings, } from "../invocation/bindings.js";
+import { RemoteInvocationExecutor } from "../invocation/remote.js";
+import { resolveTarget } from "../profile/manager.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 { CAPABILITY_UNAVAILABLE } from "../errors.js";
-import { createGlobalStorage, isSecretConfigKey } from "../storage/index.js";
+import { createGlobalStorage, redactConfigValueAtPaths, redactConfigValueForDeclarations, readConfigWithProtection, redactConfigValueWithProtection } from "../storage/index.js";
 import { filterByIntent } from "../utils/intent.js";
+import { assertConcreteConfigKey, isConfigTemplate, resolveConfigDeclaration, validateConfigValue, } from "../project/config-declarations.js";
 function isPackageRuntime(item) {
     return (typeof item === "object" &&
         item !== null &&
@@ -56,16 +60,33 @@ function withAbortSignal(op, signal) {
         });
     });
 }
+function isActionTimeoutReason(reason) {
+    if (!reason)
+        return false;
+    const code = reason?.code;
+    if (code === ACTION_TIMEOUT)
+        return true;
+    if (reason?.details?.code === ACTION_TIMEOUT)
+        return true;
+    return false;
+}
 export class DefaultActionDockHost {
     hostSessionId;
     options;
+    allowInstall;
     runtimes = new Map();
+    extraRuntimes = new Set();
+    extraRuntimeScopes = new Map();
     policy;
     hostPublicPackageIds = new Set();
     maxCallDepth;
     maxSubRuns;
     eventSink;
     isClosed = false;
+    prepareLocalPackage;
+    closeController = new AbortController();
+    activePreparations = new Set();
+    closePromise;
     dataDirLock;
     failedLinkedPackages = new Map();
     failedAutoLoad;
@@ -76,6 +97,9 @@ export class DefaultActionDockHost {
     globalStorage;
     initPromise;
     isInitialized = false;
+    actionBindings = new Map();
+    remoteTargets = new Map();
+    remoteInvoker;
     discovery;
     execution;
     runs;
@@ -100,6 +124,9 @@ export class DefaultActionDockHost {
         }
         this.hostSessionId = randomUUID();
         this.options = options;
+        this.allowInstall = options.allowInstall;
+        this.prepareLocalPackage = options.prepareLocalPackage;
+        this.remoteInvoker = new RemoteInvocationExecutor({ logger: options.logger });
         this.maxCallDepth = options.maxCallDepth ?? 16;
         this.maxSubRuns = options.maxSubRuns ?? 64;
         this.policy = new InvocationPolicy({
@@ -348,6 +375,21 @@ export class DefaultActionDockHost {
         // 持有者在返回前打开共享全局存储，保留对全局库存储错误的提前发现能力
         this.getGlobalStorage();
     }
+    /** 返回的 Runtime 由 Host 统一接管，端口只清理自身缓存和附属资源。 */
+    async closeInvocationTargets() {
+        const extras = Array.from(this.extraRuntimes).filter((runtime) => this.runtimes.get(runtime.packageId) !== runtime);
+        this.extraRuntimes.clear();
+        this.extraRuntimeScopes.clear();
+        const results = await Promise.allSettled(extras.map((runtime) => runtime.close()));
+        const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        try {
+            await this.options.platform?.invocationTargets?.close?.();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        return errors;
+    }
     /**
      * 异步安全回滚初始化失败时所占用的资源。
      */
@@ -363,7 +405,11 @@ export class DefaultActionDockHost {
                 // 忽略 Runtime 关闭异常
             }
         }));
+        const invocationCloseErrors = await this.closeInvocationTargets();
         this.runtimes.clear();
+        this.actionBindings.clear();
+        this.remoteTargets.clear();
+        await this.remoteInvoker.close();
         try {
             this.globalStorage?.close();
         }
@@ -379,6 +425,8 @@ export class DefaultActionDockHost {
         }
         this.dataDirLock = undefined;
         this.isClosed = true;
+        if (invocationCloseErrors.length)
+            throw new AggregateError(invocationCloseErrors, "Invocation target cleanup failed");
     }
     /**
      * 阶段函数：注册显式传入的 packages 列表（PackageRuntimeOptions 配置或包目录物理路径）。
@@ -438,7 +486,10 @@ export class DefaultActionDockHost {
             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 });
+            if (this.allowInstall === false || process.env.ACTIONDOCK_AUTO_INSTALL === "false") {
+                throw new ActionDockError(PROJECT_RECOVERY_REQUIRED, `PROJECT_RECOVERY_REQUIRED: Project at '${root}' has pending transactions requiring recovery install, but installation is disabled (--no-install or ACTIONDOCK_AUTO_INSTALL=false).`);
+            }
+            await recoverPendingTransactions(root, { frozenInstall: true, allowInstall: this.allowInstall });
         }
         try {
             const config = loadProjectConfig(root);
@@ -551,21 +602,75 @@ export class DefaultActionDockHost {
      * 铁律 2：跨包调用改走 ActionInvoker 回到 Host 执行主链，经由唯一的 InvocationPolicy 授权后调用目标 Package 的 ExecutionService。
      */
     createActionInvoker(callerRuntime) {
-        return async (childAction, childInput, context) => {
-            const resolved = resolveAction(childAction, {
+        return async (childAction, childInput, context, options) => {
+            if (this.isClosed)
+                throw new ActionDockError(SERVICE_CLOSED, "ActionDockHost is closed");
+            if (context.signal.aborted)
+                throw new ActionDockError(ACTION_CANCELLED, "Caller invocation is cancelled");
+            const parsed = parseActionRef(childAction);
+            // 裸引用仍由既有解析器消歧；远端专属依赖须使用完全限定引用。
+            const localResolved = parsed.packageId ? undefined : 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));
+            const targetPackageId = parsed.packageId ?? localResolved.package.id;
+            const targetActionId = parsed.actionId;
+            const canonicalRef = `${targetPackageId}/${targetActionId}`;
+            const canonicalActionRef = { packageId: targetPackageId, actionId: targetActionId };
+            const callerBindings = this.actionBindings.get(callerRuntime.packageId) ?? {};
+            const isNamedTarget = Boolean(options?.binding && options.binding !== "default");
+            // 目标装配是同步解析，不在此引入另一条执行或网络调用链。
+            const targetOverride = this.options.platform?.invocationTargets?.resolve(canonicalActionRef, options, {
+                packageId: callerRuntime.packageId,
+                actionId: context.caller?.actionId,
+            });
+            let targetRuntime;
+            let targetScope;
+            let isRemote = false;
+            let remoteProfile;
+            if (targetOverride) {
+                if (targetOverride.runtime.packageId !== targetPackageId) {
+                    throw new ActionDockError(INVALID_ACTION_REF, `Invocation target packageId mismatch: expected '${targetPackageId}', got '${targetOverride.runtime.packageId}'`);
+                }
+                targetRuntime = targetOverride.runtime;
+                this.extraRuntimes.add(targetRuntime);
+                this.bindRuntime(targetRuntime);
+                targetScope = targetOverride.scope ?? (isNamedTarget ? `binding:${options?.binding}` : undefined);
+                if (targetScope)
+                    this.extraRuntimeScopes.set(targetRuntime, targetScope);
             }
+            else {
+                // 没有绑定的旧调用不引入额外的清单命名约束，保持编程式 Runtime 兼容。
+                const binding = options?.binding !== undefined || Object.hasOwn(callerBindings, canonicalRef)
+                    ? resolveActionBinding(callerBindings, canonicalRef, options?.binding)
+                    : undefined;
+                if (binding?.type === "remote") {
+                    isRemote = true;
+                    remoteProfile = binding.profile;
+                    targetScope = `profile:${binding.profile}`;
+                }
+                else {
+                    isRemote = false;
+                    if (!localResolved) {
+                        resolveAction(childAction, { caller: callerRuntime.packageId, graph: this.graph, catalog: this.catalog });
+                    }
+                    const isLogicalSamePackage = targetPackageId === callerRuntime.packageId;
+                    targetRuntime = isLogicalSamePackage ? callerRuntime : this.getRuntime(targetPackageId);
+                    if (targetRuntime)
+                        targetScope = this.extraRuntimeScopes.get(targetRuntime);
+                    if (!targetRuntime) {
+                        throw new ActionDockError(PACKAGE_NOT_FOUND, packageNotFoundMessage(targetPackageId, this.failedLinkedPackages));
+                    }
+                }
+            }
+            const isLogicalSamePackage = targetPackageId === callerRuntime.packageId;
+            const isPhysicalSameRuntime = Boolean(targetRuntime && targetRuntime === callerRuntime);
+            const requiresExplicitUses = Boolean(isRemote ||
+                targetOverride?.requiresExplicitUses ||
+                (isNamedTarget && targetOverride !== undefined));
             // 跨包 uses 依赖声明校验（统一委托 InvocationPolicy 单一事实源）
-            if (!isSamePackage) {
+            if (!isLogicalSamePackage || requiresExplicitUses) {
                 let declaredUses = context.caller?.declaredUses;
                 if (!declaredUses) {
                     try {
@@ -580,7 +685,11 @@ export class DefaultActionDockHost {
                     packageId: callerRuntime.packageId,
                     actionId: context.caller?.actionId || "",
                     declaredUses,
-                }, { packageId: targetPackageId, actionId: targetActionId }, this.graph);
+                }, {
+                    packageId: targetPackageId,
+                    actionId: targetActionId,
+                    requiresExplicitUses,
+                }, this.graph);
                 if (authErr) {
                     const hint = authErr.details?.hint;
                     const msg = hint ? `${authErr.message}\n${hint}` : authErr.message;
@@ -593,7 +702,7 @@ export class DefaultActionDockHost {
                 throw new ActionDockError(depthErr.code, depthErr.message, depthErr.details);
             }
             // 调用链环路死锁检测
-            const cycle = this.policy.checkCycle(context.callStack, targetActionId, targetPackageId, callerRuntime.packageId);
+            const cycle = this.policy.checkCycle(context.callStack, targetActionId, targetPackageId, callerRuntime.packageId, targetScope);
             if (cycle.error) {
                 throw new ActionDockError(cycle.error.code, cycle.error.message, cycle.error.details);
             }
@@ -608,14 +717,18 @@ export class DefaultActionDockHost {
             }
             try {
                 const nextCallStack = [...context.callStack, cycle.callKey];
+                if (isRemote) {
+                    const candidate = this.catalog.find({ packageId: targetPackageId, actionId: targetActionId })[0];
+                    return await this.remoteInvoker.invoke(this.remoteTargets.get(remoteProfile), { packageId: targetPackageId, actionId: targetActionId }, childInput, { ...context, callStack: nextCallStack }, { binding: options?.binding ?? "default", profile: remoteProfile }, candidate?.contract);
+                }
                 const targetOwner = context.owner
                     ? {
                         tenantId: context.owner.tenantId,
                         principalId: context.owner.principalId,
-                        packageInstanceId: isSamePackage
+                        packageInstanceId: isPhysicalSameRuntime
                             ? (context.owner.packageInstanceId || callerRuntime.identity.instanceId)
                             : targetRuntime.identity.instanceId,
-                        generationId: isSamePackage
+                        generationId: isPhysicalSameRuntime
                             ? (context.owner.generationId || callerRuntime.identity.generation)
                             : targetRuntime.identity.generation,
                     }
@@ -626,6 +739,7 @@ export class DefaultActionDockHost {
                     parentRunId: context.parentRunId,
                     caller: context.caller,
                     callStack: nextCallStack,
+                    targetScope,
                     package: targetRuntime.identity,
                     signal: context.signal,
                     timeoutMs: context.timeoutMs,
@@ -641,7 +755,7 @@ export class DefaultActionDockHost {
                     owner: targetOwner,
                     origin: context.origin,
                 };
-                const ticket = await targetRuntime.startInvocation(targetActionId, childInput, subInvocationContext);
+                const ticket = await this.dispatchLocalInvocation(targetRuntime, targetActionId, childInput, subInvocationContext);
                 if (!ticket.result) {
                     throw new ActionDockError(EXECUTION_FAILED, `Execution ticket for run '${ticket.runId}' has no result Promise`);
                 }
@@ -699,6 +813,27 @@ export class DefaultActionDockHost {
             }
             throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${runtime.packageId}' is already registered in host`);
         }
+        const explicitBindings = this.options.actionBindings;
+        const bindings = explicitBindings && Object.hasOwn(explicitBindings, runtime.packageId)
+            ? validateActionBindings(explicitBindings[runtime.packageId])
+            : runtime.packageRoot ? loadActionBindings(runtime.packageRoot) : validateActionBindings({});
+        for (const group of Object.values(bindings)) {
+            for (const target of Object.values(group)) {
+                if (target.type !== "remote" || this.remoteTargets.has(target.profile))
+                    continue;
+                const resolved = resolveTarget({ profile: target.profile }, this.options.customHome);
+                if (resolved.type !== "remote" || !resolved.serverUrl) {
+                    throw new ActionDockError(INVALID_ACTION_REF, `Binding profile '${target.profile}' must identify a remote service`);
+                }
+                this.remoteTargets.set(target.profile, Object.freeze({
+                    serverUrl: resolved.serverUrl,
+                    token: resolved.token,
+                    insecure: resolved.insecure,
+                    allowInsecureHttp: resolved.allowInsecureHttp,
+                }));
+            }
+        }
+        this.actionBindings.set(runtime.packageId, bindings);
         this.runtimes.set(runtime.packageId, runtime);
         if (isPublic) {
             this.hostPublicPackageIds.add(runtime.packageId);
@@ -856,8 +991,182 @@ export class DefaultActionDockHost {
             process: this.options.process,
             origin: effectiveOptions.origin,
         });
-        // 调度目标包执行服务
-        return targetRuntime.startInvocation(targetActionId, input, rootContext);
+        // 调度目标包执行服务（经由本地分发中枢统一准备与复核）
+        return this.dispatchLocalInvocation(targetRuntime, targetActionId, input, rootContext);
+    }
+    /**
+     * 私有本地 Action 调度中枢。
+     * 统一处理本地已授权目标的准备（若已注入 prepareLocalPackage 且存在物理包根路径）、
+     * 中断与关闭复核，并分发至目标 Runtime 的 startInvocation。
+     */
+    async dispatchLocalInvocation(targetRuntime, targetActionId, input, context) {
+        if (this.isClosed) {
+            const runId = context.runId;
+            const error = buildRuntimeError(SERVICE_CLOSED, "ActionDockHost is closed: new tasks rejected", { package: targetRuntime.packageId, action: targetActionId, phase: "dispatch" });
+            return {
+                runId,
+                status: "failed",
+                result: Promise.resolve({ ok: false, runId, error }),
+            };
+        }
+        const isRootCall = !context.caller;
+        const initialTimeoutMs = context.initialTimeoutMs ?? (typeof context.timeoutMs === "number" && context.timeoutMs > 0 ? context.timeoutMs : undefined);
+        const deadline = context.deadline ?? (initialTimeoutMs !== undefined ? Date.now() + initialTimeoutMs : undefined);
+        if (context.signal.aborted) {
+            const runId = context.runId;
+            const isTimeout = isActionTimeoutReason(context.signal.reason);
+            const error = buildRuntimeError(isTimeout ? ACTION_TIMEOUT : ACTION_CANCELLED, isTimeout
+                ? `Action exceeded timeout of ${initialTimeoutMs ?? context.timeoutMs}ms`
+                : "Action execution was cancelled before starting", { package: targetRuntime.packageId, action: targetActionId, phase: "dispatch" });
+            return {
+                runId,
+                status: "failed",
+                result: Promise.resolve({ ok: false, runId, error }),
+            };
+        }
+        let timeoutController;
+        let prepTimeoutTimer;
+        if (isRootCall && typeof context.timeoutMs === "number" && context.timeoutMs > 0) {
+            timeoutController = new AbortController();
+            const remaining = deadline ? Math.max(0, deadline - Date.now()) : context.timeoutMs;
+            const timeoutReason = new ActionDockError(ACTION_TIMEOUT, `Action exceeded timeout of ${initialTimeoutMs ?? context.timeoutMs}ms`, { package: targetRuntime.packageId, action: targetActionId, phase: "preparation" });
+            if (remaining <= 0) {
+                timeoutController.abort(timeoutReason);
+            }
+            else {
+                prepTimeoutTimer = setTimeout(() => {
+                    timeoutController?.abort(timeoutReason);
+                }, remaining);
+            }
+        }
+        const signalSources = [context.signal, this.closeController.signal];
+        if (timeoutController) {
+            signalSources.push(timeoutController.signal);
+        }
+        const mergedSignal = AbortSignal.any(signalSources);
+        if (this.prepareLocalPackage && targetRuntime.packageRoot) {
+            const prepPromise = Promise.resolve().then(() => this.prepareLocalPackage({
+                identity: targetRuntime.identity,
+                packageRoot: targetRuntime.packageRoot,
+            }, {
+                signal: mergedSignal,
+                rootRunId: context.rootRunId,
+            }));
+            this.activePreparations.add(prepPromise);
+            try {
+                await prepPromise;
+            }
+            catch (err) {
+                if (prepTimeoutTimer !== undefined) {
+                    clearTimeout(prepTimeoutTimer);
+                    prepTimeoutTimer = undefined;
+                }
+                const errCode = err?.code;
+                const isClosed = this.closeController.signal.aborted;
+                const isExternalCancelled = context.signal.aborted;
+                const isTimeout = timeoutController?.signal.aborted ||
+                    isActionTimeoutReason(context.signal.reason) ||
+                    errCode === ACTION_TIMEOUT ||
+                    (err?.details && err.details.code === ACTION_TIMEOUT);
+                let code;
+                let message = err?.message || "Package preparation failed";
+                if (isTimeout) {
+                    code = ACTION_TIMEOUT;
+                    message = (err?.message && err.message.includes("exceeded timeout"))
+                        ? err.message
+                        : `Action exceeded timeout of ${initialTimeoutMs ?? context.timeoutMs}ms`;
+                }
+                else if (err instanceof ActionDockError) {
+                    code = err.code;
+                }
+                else if (isClosed) {
+                    code = SERVICE_CLOSED;
+                    message = "ActionDockHost is closed: new tasks rejected";
+                }
+                else if (isExternalCancelled) {
+                    code = ACTION_CANCELLED;
+                    message = "Action execution was cancelled";
+                }
+                else if (err?.code && typeof err.code === "string") {
+                    code = err.code;
+                }
+                else {
+                    code = EXECUTION_FAILED;
+                }
+                const hint = err?.details?.hint ?? err?.hint;
+                const details = {
+                    ...(err?.details || {}),
+                    package: targetRuntime.packageId,
+                    action: targetActionId,
+                    phase: "preparation",
+                    ...(hint ? { hint } : {}),
+                };
+                const runId = context.runId;
+                const error = buildRuntimeError(code, message, details);
+                return {
+                    runId,
+                    status: "failed",
+                    result: Promise.resolve({ ok: false, runId, error }),
+                };
+            }
+            finally {
+                this.activePreparations.delete(prepPromise);
+            }
+        }
+        if (prepTimeoutTimer !== undefined) {
+            clearTimeout(prepTimeoutTimer);
+            prepTimeoutTimer = undefined;
+        }
+        // 准备后再次复核取消与 Host 关闭状态
+        if (this.isClosed || this.closeController.signal.aborted) {
+            const runId = context.runId;
+            const error = buildRuntimeError(SERVICE_CLOSED, "ActionDockHost is closed: new tasks rejected", { package: targetRuntime.packageId, action: targetActionId, phase: "post-preparation" });
+            return {
+                runId,
+                status: "failed",
+                result: Promise.resolve({ ok: false, runId, error }),
+            };
+        }
+        if (context.signal.aborted) {
+            const runId = context.runId;
+            const isTimeout = isActionTimeoutReason(context.signal.reason);
+            const error = buildRuntimeError(isTimeout ? ACTION_TIMEOUT : ACTION_CANCELLED, isTimeout
+                ? `Action exceeded timeout of ${initialTimeoutMs ?? context.timeoutMs}ms`
+                : "Action execution was cancelled after preparation", { package: targetRuntime.packageId, action: targetActionId, phase: "post-preparation" });
+            return {
+                runId,
+                status: "failed",
+                result: Promise.resolve({ ok: false, runId, error }),
+            };
+        }
+        const remainingBudget = deadline !== undefined
+            ? Math.max(0, deadline - Date.now())
+            : context.timeoutMs;
+        if (deadline !== undefined && typeof remainingBudget === "number" && remainingBudget <= 0) {
+            const runId = context.runId;
+            const error = buildRuntimeError(ACTION_TIMEOUT, `Action exceeded timeout of ${initialTimeoutMs ?? context.timeoutMs}ms`, { package: targetRuntime.packageId, action: targetActionId, phase: "post-preparation" });
+            return {
+                runId,
+                status: "failed",
+                result: Promise.resolve({ ok: false, runId, error }),
+            };
+        }
+        const effectiveContext = {
+            ...context,
+            signal: mergedSignal,
+            initialTimeoutMs,
+            deadline,
+            timeoutMs: remainingBudget,
+        };
+        const ticket = await targetRuntime.startInvocation(targetActionId, input, effectiveContext);
+        if (ticket.result) {
+            ticket.result.finally(() => {
+                if (prepTimeoutTimer !== undefined) {
+                    clearTimeout(prepTimeoutTimer);
+                }
+            });
+        }
+        return ticket;
     }
     async getRun(runId, signal) {
         await this.ensureInitialized();
@@ -1227,31 +1536,47 @@ export class DefaultActionDockHost {
             }) ||
                 Array.from(this.runtimes.values()).some((rt) => Boolean(rt.inMemory || rt.options?.inMemory));
             const inMemory = Boolean(this.options.inMemory || hasInMemoryPackage);
+            // 旧版本全局库迁移的声明并集：取首次打开时已加载包的声明字典；
+            // 后续 registerRuntime 带来的新声明属当前版本正常写入，不重跑历史迁移
+            const configDeclarations = this.listRuntimes()
+                .map((runtime) => runtime.projectConfig?.config)
+                .filter((config) => Boolean(config && Object.keys(config).length > 0));
             this.globalStorage =
                 this.options.platform?.storage?.createGlobalStorage?.({
                     dataDir: this.options.dataDir,
                     customHome: this.options.customHome,
                     ...(inMemory ? { inMemory: true } : {}),
+                    configDeclarations,
                 }) ??
                     createGlobalStorage({
                         dataDir: this.options.dataDir,
                         customHome: this.options.customHome,
                         inMemory,
+                        configDeclarations,
                     });
         }
         return this.globalStorage;
     }
-    findDeclaredConfigItem(key) {
-        let foundItem;
+    findAllDeclaredConfigItems(key) {
+        const items = [];
         for (const runtime of this.listRuntimes()) {
-            const item = runtime.projectConfig?.config?.[key];
-            if (item) {
-                if (item.secret)
-                    return item;
-                foundItem = item;
+            const decl = resolveConfigDeclaration(runtime.projectConfig?.config, key);
+            if (decl?.item) {
+                items.push(decl.item);
             }
         }
-        return foundItem;
+        return items;
+    }
+    protectGlobalConfigView(view) {
+        if (view.source !== "global")
+            return view;
+        const items = this.findAllDeclaredConfigItems(view.key);
+        if (items.length === 0)
+            return view;
+        // 外部注入的运行时可能持有独立全局库；只能加强它返回的安全值，不能换读 Host 的库。
+        const merged = redactConfigValueForDeclarations(view.value, items);
+        const safe = redactConfigValueAtPaths(merged.value, [...view.redactedPaths, ...merged.redactedPaths]);
+        return { ...view, ...safe, secret: view.secret || merged.secret };
     }
     resolveRuntime(packageId) {
         if (packageId) {
@@ -1272,32 +1597,43 @@ export class DefaultActionDockHost {
     }
     async getConfig(packageId, key) {
         await this.ensureInitialized();
+        assertConcreteConfigKey(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);
+            // 原子快照配对读取值与历史保护声明，消除并发删除造成的值与规则错配
+            const snapshot = readConfigWithProtection(globalStorage, key);
+            const configured = snapshot !== undefined;
+            const items = this.findAllDeclaredConfigItems(key);
+            const redacted = redactConfigValueWithProtection(snapshot?.value, items, snapshot?.protection);
             return {
                 key,
                 configured,
-                secret: isSecret,
-                source: configured ? "global" : "default",
-                value: !isSecret && configured ? val : undefined,
+                secret: redacted.secret,
+                source: configured ? "global" : null,
+                value: redacted.value,
+                redactedPaths: redacted.redactedPaths,
             };
         }
-        return this.requireRuntime(packageId).getConfig(key);
+        return this.protectGlobalConfigView(await this.requireRuntime(packageId).getConfig(key));
     }
     async setConfig(packageId, key, value) {
         await this.ensureInitialized();
+        assertConcreteConfigKey(key);
         if (packageId === "global") {
-            await this.getGlobalStorage().setConfig(key, value);
+            const items = this.findAllDeclaredConfigItems(key);
+            for (const item of items) {
+                validateConfigValue(key, value, item);
+            }
+            // 传递全部已加载包各自解析出的有效声明并集（各包内具体键优先于模板），
+            // 由存储统一判定整键加密并合并历史保护
+            await this.getGlobalStorage().setConfig(key, value, items.length > 0 ? { declarations: items } : undefined);
             return;
         }
         await this.requireRuntime(packageId).setConfig(key, value);
     }
     async deleteConfig(packageId, key) {
         await this.ensureInitialized();
+        assertConcreteConfigKey(key);
         if (packageId === "global") {
             return await this.getGlobalStorage().deleteConfig(key);
         }
@@ -1308,19 +1644,32 @@ export class DefaultActionDockHost {
         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 {
+            const views = [];
+            for (const key of Object.keys(all)) {
+                if (isConfigTemplate(key)) {
+                    continue;
+                }
+                // 同源原子重读：值与历史保护声明取自同一次读取；
+                // 行在列键之后又被并发删除时跳过该项，不回退旧值
+                const snapshot = readConfigWithProtection(globalStorage, key);
+                if (snapshot === undefined) {
+                    continue;
+                }
+                const items = this.findAllDeclaredConfigItems(key);
+                const redacted = redactConfigValueWithProtection(snapshot.value, items, snapshot.protection);
+                views.push({
                     key,
                     configured: true,
-                    secret: isSecret,
+                    secret: redacted.secret,
                     source: "global",
-                    value: isSecret ? undefined : val,
-                };
-            });
+                    value: redacted.value,
+                    redactedPaths: redacted.redactedPaths,
+                });
+            }
+            return views;
         }
-        return this.requireRuntime(packageId).listConfig();
+        const views = await this.requireRuntime(packageId).listConfig();
+        return views.map((view) => this.protectGlobalConfigView(view));
     }
     async getState(packageId, actionId, key, options) {
         await this.ensureInitialized();
@@ -1365,33 +1714,48 @@ export class DefaultActionDockHost {
      * 外部传入借用的 Runtime 实例生命周期完全由调用方负责管理，Host 关闭时仅解绑引用并清理自身内部实例。
      */
     async close(options) {
+        if (this.closePromise)
+            return this.closePromise;
         if (this.isClosed)
             return;
-        this.isClosed = true;
-        const allRuntimes = Array.from(this.runtimes.values());
-        await Promise.all(allRuntimes.map(async (runtime) => {
+        this.closePromise = (async () => {
+            this.isClosed = true;
+            this.closeController.abort(new ActionDockError(SERVICE_CLOSED, "ActionDockHost is closing"));
+            if (this.activePreparations.size > 0) {
+                await Promise.allSettled(Array.from(this.activePreparations));
+            }
+            const allRuntimes = Array.from(this.runtimes.values());
+            await Promise.all(allRuntimes.map(async (runtime) => {
+                try {
+                    await runtime.close(options);
+                }
+                catch {
+                    // 忽略 Runtime 关闭异常，确保全部安全释放
+                }
+            }));
+            const invocationCloseErrors = await this.closeInvocationTargets();
+            this.runtimes.clear();
+            this.actionBindings.clear();
+            this.remoteTargets.clear();
+            await this.remoteInvoker.close();
             try {
-                await runtime.close(options);
+                this.globalStorage?.close();
             }
             catch {
-                // 忽略 Runtime 关闭异常，确保全部安全释放
+                // 忽略全局存储关闭异常
             }
-        }));
-        this.runtimes.clear();
-        try {
-            this.globalStorage?.close();
-        }
-        catch {
-            // 忽略全局存储关闭异常
-        }
-        this.globalStorage = undefined;
-        try {
-            this.dataDirLock?.release();
-        }
-        catch {
-            // 忽略目录排他锁释放异常
-        }
-        this.dataDirLock = undefined;
+            this.globalStorage = undefined;
+            try {
+                this.dataDirLock?.release();
+            }
+            catch {
+                // 忽略目录排他锁释放异常
+            }
+            this.dataDirLock = undefined;
+            if (invocationCloseErrors.length)
+                throw new AggregateError(invocationCloseErrors, "Invocation target cleanup failed");
+        })();
+        return this.closePromise;
     }
 }
 /**