@actiondock/core 2.6.0 → 2.8.0

package/dist/runtime/runner.js

@@ -1,79 +1,47 @@
-import { existsSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { ActionResolver } from "../catalog/action-resolver.js";
-import { loadActions, loadProjectConfig } from "../project/loader.js";
-import { resolveActionProject } from "../registry/registry.js";
-import { ACTION_CALL_CYCLE, ACTION_CYCLE_DETECTED, ACTION_FAILED, ACTION_MAX_DEPTH_EXCEEDED, ACTION_NOT_FOUND, ACTION_SUBRUN_LIMIT, ACTION_TIMEOUT, describeActionLoadFailure, INPUT_NOT_JSON, MAX_SUBRUNS_REACHED, OUTPUT_NOT_JSON, ACTION_CANCELLED, PACKAGE_NOT_FOUND, INPUT_VALIDATION_FAILED, OUTPUT_VALIDATION_FAILED, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
-import { validateSchema } from "../schema/validator.js";
+import { parseActionRef } from "../catalog/resolve-action.js";
+import { ACTION_FAILED, ACTION_NOT_FOUND, ACTION_TIMEOUT, INPUT_NOT_JSON, OUTPUT_NOT_JSON, ACTION_CANCELLED, INPUT_VALIDATION_FAILED, OUTPUT_VALIDATION_FAILED, INVOCATION_UNSUPPORTED, ActionDockError, } from "../errors.js";
+import { validateSchemaOnly } from "../schema/validator.js";
+import { validateActionInputValue } from "../json/value-validator.js";
 import { createActionContext, StderrLogger } from "./context.js";
-import { ActionRegistry, findLocalAction, isActionDefinitionObject, parseActionRef, resolveAnonymousActionId, } from "./action-registry.js";
+import { createDefaultProcessOwner } from "../invocation/types.js";
+import { ActionRegistry, findLocalAction, isActionDefinitionObject, resolveAnonymousActionId, } from "./action-registry.js";
 import { buildInitialRunRecord, createRunFinalizer, createRunOrThrow, tryCreateRun, } from "./run-persistence.js";
-import { PackageRunnerFactory } from "./package-runner-factory.js";
-// 错误码常量已收敛至 src/errors.ts 单一事实源，此处保留 re-export 以维持既有导入路径兼容。
-export { RUN_REPOSITORY_UNAVAILABLE, RUN_PERSISTENCE_FAILED, INPUT_NOT_JSON, OUTPUT_NOT_JSON, ACTION_SUBRUN_LIMIT, MAX_SUBRUNS_REACHED, ACTION_CALL_CYCLE, ACTION_CYCLE_DETECTED, ACTION_MAX_DEPTH_EXCEEDED, } from "../errors.js";
+import { validateJsonValue } from "../json/value-validator.js";
 /**
- * 校验值是否为合法的 JSON 兼容结构，严禁 NaN、Infinity、循环引用及不可序列化类型。
+ * 将输入值校验结果映射为标准运行时错误（单一事实源）。
  *
- * 环路检测采用「当前递归路径栈」语义：对象仅在自身子树遍历期间保持标记，
- * 子树遍历完成后立即移除，从而正确放行共享子对象的有向无环结构（如 {a: shared, b: shared}）。
+ * json-value 分支映射 INPUT_NOT_JSON（非 JSON 类型值），input-policy 分支映射
+ * INPUT_VALIDATION_FAILED（策略违规）并携带 details 数组；start 同步路径与
+ * raceExecutionAndAbort 延迟解析路径共用，确保错误码与 details 结构一致。
  */
-export function validateJsonValue(val, stack = new WeakSet()) {
-    if (val === null || typeof val === "boolean" || typeof val === "string") {
-        return { valid: true };
-    }
-    if (typeof val === "number") {
-        if (!Number.isFinite(val) || Number.isNaN(val)) {
-            return { valid: false, reason: `Number is non-finite or NaN (${val})` };
-        }
-        return { valid: true };
-    }
-    if (typeof val === "undefined" || typeof val === "function" || typeof val === "symbol" || typeof val === "bigint") {
-        return { valid: false, reason: `Unsupported JSON type '${typeof val}'` };
-    }
-    if (typeof val === "object") {
-        if (stack.has(val)) {
-            return { valid: false, reason: "Circular reference detected in object structure" };
-        }
-        stack.add(val);
-        try {
-            if (Array.isArray(val)) {
-                for (const item of val) {
-                    const res = validateJsonValue(item, stack);
-                    if (!res.valid)
-                        return res;
-                }
-                return { valid: true };
-            }
-            for (const v of Object.values(val)) {
-                if (v !== undefined) {
-                    const res = validateJsonValue(v, stack);
-                    if (!res.valid)
-                        return res;
-                }
-            }
-            return { valid: true };
-        }
-        finally {
-            // 无论正常返回还是提前返回，均须将当前对象移出路径栈，避免祖先对象被误判为环路
-            stack.delete(val);
-        }
+function buildInputValidationError(targetActionId, check) {
+    if (check.kind === "json-value") {
+        return {
+            code: INPUT_NOT_JSON,
+            message: `Input validation failed for action '${targetActionId}': ${check.reason}`,
+        };
     }
-    return { valid: true };
+    return {
+        code: INPUT_VALIDATION_FAILED,
+        message: `Input validation failed for action '${targetActionId}': ${check.reason}`,
+        details: [check.reason],
+    };
 }
 /**
  * ActionDock 核心执行引擎（ActionRunner）。
  *
  * 本类为执行编排壳：负责 Action 执行的全生命周期编排（校验、深度与环路检测、
  * 超时与取消竞态、子调用 uses 授权与错误分类），并将单一职责域委托至独立模块：
- * - Action 注册与检索委托 `ActionRegistry`（action-registry.ts）
+ * - Action 注册与检索委托 ActionRegistry（action-registry.ts）
  * - RunRecord 构造与落库委托 run-persistence.ts
- * - 跨包 Runner 构建与缓存委托 `PackageRunnerFactory`（package-runner-factory.ts）
+ * - 跨包动作调用委托注入的 ActionInvoker 并重返目标包执行服务
  *
  * 入参 (inputSchema) 与出参 (outputSchema) 的 JSON Schema 严格校验、嵌套 Action
  * 相互调用的环路检测（Cycle Detection）、超时 (Timeout) 与中断信号 (AbortSignal)
  * 竞态控制与运行记录持久化编排仍由本类承担。
  */
 export class ActionRunner {
+    identity;
     packageId;
     packageInstanceId;
     generationId;
@@ -85,76 +53,41 @@ export class ActionRunner {
     registry;
     clock;
     process;
-    platform;
-    maxCallDepth;
-    maxSubRuns;
-    activeSubRuns = 0;
-    packageFactory;
-    actionResolver;
-    getStorageForPackage;
     customHome;
+    actionResolver;
     hostSessionId;
+    actionInvoker;
     constructor(options) {
-        this.packageId = options.packageId;
-        this.packageInstanceId = options.packageInstanceId || options.packageId;
-        this.generationId = options.generationId || "1";
+        if (!options.identity) {
+            throw new Error("ActionRunner requires 'identity' PackageIdentity option");
+        }
+        this.identity = options.identity;
+        this.packageId = this.identity.id;
+        this.packageInstanceId = this.identity.instanceId;
+        this.generationId = this.identity.generation;
         this.hostSessionId = options.hostSessionId;
         this.projectRoot = options.projectRoot;
         this.projectConfig = options.projectConfig;
         this.configOverrides = options.configOverrides || {};
         this.registry = new ActionRegistry(options.actions);
         this.customHome = options.customHome;
-        this.platform = options.platform;
-        if (options.platform) {
-            this.clock = options.platform.clock;
-            this.process = options.platform.process;
-            this.storage = options.storage ?? options.platform.storage.createStorage(this.packageId, {
-                projectRoot: this.projectRoot,
-                customHome: this.customHome,
-                // Runner 作为执行宿主组件属于持有者路径，打开时收割遗留孤儿运行
-                recoverOrphans: true,
-            });
-            this.globalStorage = options.globalStorage ?? options.platform.storage.createGlobalStorage({
-                customHome: this.customHome,
-            });
-        }
-        else {
-            if (!options.storage) {
-                throw new Error("ActionRunner requires either 'storage' or 'platform' option");
-            }
-            this.storage = options.storage;
-            this.globalStorage = options.globalStorage;
-            this.process = options.process;
-            this.clock = options.clock;
-        }
-        this.maxCallDepth = options.maxCallDepth ?? 16;
-        this.maxSubRuns = options.maxSubRuns ?? 64;
+        this.actionInvoker = options.actionInvoker;
         this.actionResolver = options.actionResolver;
-        this.getStorageForPackage = options.getStorageForPackage;
-        this.packageFactory = new PackageRunnerFactory({
-            globalStorage: this.globalStorage,
-            projectRoot: this.projectRoot,
-            process: this.process,
-            clock: this.clock,
-            platform: this.platform,
-            maxCallDepth: this.maxCallDepth,
-            maxSubRuns: this.maxSubRuns,
-            actionResolver: this.actionResolver,
-            getStorageForPackage: this.getStorageForPackage,
-            packageContextResolver: options.packageContextResolver,
-            customHome: this.customHome,
-        }, (opts) => new ActionRunner(opts));
+        if (!options.storage) {
+            throw new Error("ActionRunner requires 'storage' option");
+        }
+        this.storage = options.storage;
+        this.globalStorage = options.globalStorage;
+        this.clock = options.clock;
+        this.process = options.process;
     }
-    /** 本地 Action 注册表底层映射（仅内部与跨包工厂委托使用） */
+    /** 本地 Action 注册表底层映射 */
     get actions() {
         return this.registry.map;
     }
     getStorage() {
         return this.storage;
     }
-    getPackageRunners() {
-        return this.packageFactory.runners;
-    }
     registerAction(idOrAction, actionDef) {
         this.registry.registerAction(idOrAction, actionDef);
     }
@@ -164,11 +97,17 @@ export class ActionRunner {
     getAction(id) {
         return this.registry.getAction(id);
     }
+    /**
+     * 设置子任务动作调用委托器。
+     */
+    setActionInvoker(invoker) {
+        this.actionInvoker = invoker;
+    }
     /**
      * 动态解析 Action（支持本地注册表、自定义解析器委托与已链接包目录索引检索）。
      *
      * @param actionOrRef Action 定义对象、引用或标识符
-     * @returns 解析判别联合结果（found | not_found | load_failed）
+     * @returns 解析判别联合结果（found | not_found）
      */
     async resolveAction(actionOrRef) {
         if (isActionDefinitionObject(actionOrRef)) {
@@ -184,24 +123,26 @@ export class ActionRunner {
         }
         const targetActionId = parsed.actionId;
         const targetPackageId = parsed.packageId;
+        // 铁律：ActionRunner 仅限执行当前包局部 Action，任何跨包请求直接拒绝，禁止跨包解析和执行
+        if (targetPackageId && targetPackageId !== this.packageId) {
+            return {
+                status: "not_found",
+                reason: `Cross-package action '${targetPackageId}/${targetActionId}' cannot be resolved by ActionRunner of package '${this.packageId}'`,
+            };
+        }
         // 本地 actions 映射表优先检索
         const localMatched = findLocalAction(this.actions, parsed, this.packageId);
         if (localMatched) {
             return { status: "found", action: localMatched };
         }
-        // 外部注入的自定义 actionResolver 调度
+        // 外部注入的局部 actionResolver 调度
         if (this.actionResolver) {
             try {
-                const customResolved = await this.actionResolver(ref, this.packageId);
+                const customResolved = await this.actionResolver(targetActionId);
                 if (customResolved) {
-                    if (targetPackageId && targetPackageId !== this.packageId) {
-                        this.actions.set(`${targetPackageId}/${targetActionId}`, customResolved);
-                    }
-                    else {
-                        this.actions.set(targetActionId, customResolved);
-                        if (this.packageId) {
-                            this.actions.set(`${this.packageId}/${targetActionId}`, customResolved);
-                        }
+                    this.actions.set(targetActionId, customResolved);
+                    if (this.packageId) {
+                        this.actions.set(`${this.packageId}/${targetActionId}`, customResolved);
                     }
                     return { status: "found", action: customResolved };
                 }
@@ -210,61 +151,10 @@ export class ActionRunner {
                 return { status: "not_found", reason: err.message };
             }
         }
-        // 基于全局链接注册表与目录索引的动态寻址与按需加载
-        const identifier = targetPackageId
-            ? `${targetPackageId}/${targetActionId}`
-            : targetActionId;
-        let resolved;
-        try {
-            resolved = await resolveActionProject(identifier, this.projectRoot, this.customHome);
-        }
-        catch (err) {
-            return { status: "not_found", reason: err.message };
-        }
-        if (!resolved || !existsSync(resolved.projectRoot)) {
-            return {
-                status: "not_found",
-                reason: `Project root not found for action '${identifier}'`,
-            };
-        }
-        let config;
-        try {
-            config = loadProjectConfig(resolved.projectRoot);
-        }
-        catch (err) {
-            return {
-                status: "load_failed",
-                error: err instanceof Error ? err : new Error(String(err)),
-                packageId: resolved.packageId,
-                projectRoot: resolved.projectRoot,
-            };
-        }
-        let actionsMap;
-        try {
-            actionsMap = await loadActions(resolved.projectRoot, config.actionsDir, {
-                loader: this.platform?.modules,
-            });
-        }
-        catch (err) {
-            return {
-                status: "load_failed",
-                error: err instanceof Error ? err : new Error(String(err)),
-                packageId: resolved.packageId,
-                projectRoot: resolved.projectRoot,
-            };
-        }
-        const matched = actionsMap.get(resolved.actionId);
-        if (matched) {
-            this.actions.set(`${resolved.packageId}/${resolved.actionId}`, matched);
-            // 仅当目标包就是当前项目时才注册短标识符，避免跨包动态载入污染全局短标识符
-            if (!targetPackageId || resolved.packageId === this.packageId) {
-                this.actions.set(resolved.actionId, matched);
-            }
-            return { status: "found", action: matched };
-        }
+        // 铁律 4：Runner 不找 Package：只能执行自己所属 Package 的 Action
         return {
             status: "not_found",
-            reason: `Action '${resolved.actionId}' not found in package '${resolved.packageId}' (${resolved.projectRoot})`,
+            reason: `Action '${targetActionId}' not found in package '${this.packageId}'`,
         };
     }
     /**
@@ -273,22 +163,6 @@ export class ActionRunner {
     listActions() {
         return this.registry.listActions();
     }
-    /**
-     * 注入或更新跨包运行上下文解析委托。
-     */
-    setPackageContextResolver(resolver) {
-        this.packageFactory.setPackageContextResolver(resolver);
-    }
-    /**
-     * 跨包运行时解析与获取（确保跨包执行具备独立的配置、存储、状态与 Action 注册表）。
-     *
-     * 缓存 miss 后存在长异步窗口（加载配置、扫描 Action、打开存储），并发调用会重复构建
-     * Runner、重复打开 SQLite 连接且子任务限流计数分裂；故以 in-flight Promise 去重，
-     * 并发方 await 同一构建任务，构建失败时移除该 Promise 以便后续重试。
-     */
-    async resolveTargetPackageRunner(targetPackageId) {
-        return this.packageFactory.resolveTargetPackageRunner(targetPackageId);
-    }
     /**
      * 异步启动 Action 的执行并立即返回 ExecutionHandle 句柄。
      *
@@ -300,14 +174,11 @@ export class ActionRunner {
     start(actionOrId, input = {}, options = {}) {
         const runCtx = this.prepareRunContext(actionOrId, input, options);
         const { runId, targetActionId, targetPackageId } = runCtx;
-        // 输入参数 JSON 格式与合法性防御校验（拦截 NaN/Infinity/循环引用等非 JSON 类型）
-        const inputCheck = validateJsonValue(input);
+        // 输入参数 JSON 格式与合法性防御校验（拦截 NaN/Infinity/循环引用等非 JSON 类型及非法原型键策略违规）
+        const inputCheck = validateActionInputValue(input);
         if (!inputCheck.valid) {
-            const error = {
-                code: INPUT_NOT_JSON,
-                message: `Input validation failed for action '${targetActionId}': ${inputCheck.reason}`,
-            };
-            // 安全记录 failed 状态（不可序列化的非法 input 严禁直接写入持久化存储）
+            const error = buildInputValidationError(targetActionId, inputCheck);
+            // 安全记录 failed 状态（不可序列化或策略违规的非法 input 严禁直接写入持久化存储）
             tryCreateRun(this.storage, buildInitialRunRecord(this.buildRunPersistenceInput(runCtx), "failed", error));
             return {
                 runId,
@@ -318,27 +189,15 @@ export class ActionRunner {
         // 始终优先将执行尝试持久化到存储中（确保任意异常与终态都可追溯）
         createRunOrThrow(this.storage, buildInitialRunRecord(this.buildRunPersistenceInput(runCtx), "running"));
         const finalizer = createRunFinalizer(this.storage, runCtx.runId);
-        // 调用嵌套深度限制检测 (Max Call Depth Check)
-        const depthError = this.checkCallDepth(runCtx.callStack, targetActionId, runCtx.options);
-        if (depthError) {
-            finalizer.finalize("failed", undefined, depthError);
-            return {
-                runId,
-                result: Promise.resolve({ ok: false, runId, error: depthError }),
-                cancel: () => false,
-            };
-        }
-        // 环路死锁检测 (Cycle Detection)
-        const cycle = this.computeCallKey(runCtx.callStack, targetActionId, targetPackageId);
-        if (cycle.error) {
-            finalizer.finalize("failed", undefined, cycle.error);
-            return {
-                runId,
-                result: Promise.resolve({ ok: false, runId, error: cycle.error }),
-                cancel: () => false,
-            };
+        // 记录调用栈快照（供子任务追溯，若已处于调用栈顶则不重复追加）
+        const callKey = targetPackageId ? `${targetPackageId}/${targetActionId}` : targetActionId;
+        const lastStackItem = runCtx.callStack[runCtx.callStack.length - 1];
+        const isAlreadyAtTop = lastStackItem === callKey ||
+            (targetActionId && lastStackItem === targetActionId) ||
+            (targetPackageId && lastStackItem === `${targetPackageId}/${targetActionId}`);
+        if (!isAlreadyAtTop) {
+            runCtx.callStack.push(callKey);
         }
-        runCtx.callStack.push(cycle.callKey);
         // 输入参数 JSON Schema 校验（若 action 已就绪）
         const schemaError = this.checkActionInputSchema(runCtx.action, targetActionId, input);
         if (schemaError) {
@@ -408,9 +267,9 @@ export class ActionRunner {
      * 预解析执行目标并装配运行期共享上下文对象（runId、目标标识、时钟源与调用栈快照）。
      */
     prepareRunContext(actionOrId, input, options) {
-        const runId = options.runId || randomUUID();
-        const effectiveClock = options.platform?.clock ?? this.clock;
-        const effectiveProcess = options.process || options.platform?.process || this.process;
+        const runId = options.runId || crypto.randomUUID();
+        const effectiveClock = options.clock ?? this.clock;
+        const effectiveProcess = options.process || this.process;
         const startedAt = effectiveClock?.now().toISOString() ||
             (typeof this.storage.clock?.now === "function"
                 ? this.storage.clock.now().toISOString()
@@ -474,51 +333,15 @@ export class ActionRunner {
             runnerHostSessionId: this.hostSessionId,
         };
     }
-    /**
-     * 调用嵌套深度限制检测（超限时返回 ACTION_CALL_CYCLE 错误）。
-     */
-    checkCallDepth(callStack, targetActionId, options) {
-        // 执行级 options.maxCallDepth 可覆盖构造级默认值，保留原覆盖契约
-        const maxDepth = options.maxCallDepth ?? this.maxCallDepth;
-        if (callStack.length >= maxDepth) {
-            return {
-                code: ACTION_CALL_CYCLE,
-                message: `Maximum call depth of ${maxDepth} exceeded: ${callStack.join(" -> ")} -> ${targetActionId}`,
-                details: { alias: ACTION_MAX_DEPTH_EXCEEDED, reason: "depth_exceeded", maxDepth, callStack: [...callStack] },
-            };
-        }
-        return undefined;
-    }
-    /**
-     * 计算调用键并执行环路死锁检测（命中时返回携带错误的调用键结果）。
-     */
-    computeCallKey(callStack, targetActionId, targetPackageId) {
-        const isExternal = Boolean(targetPackageId && targetPackageId !== this.packageId);
-        const callKey = isExternal
-            ? `${targetPackageId}/${targetActionId}`
-            : targetActionId;
-        const hasCycle = isExternal
-            ? callStack.includes(callKey)
-            : (callStack.includes(callKey) || (this.packageId ? callStack.includes(`${this.packageId}/${targetActionId}`) : false));
-        if (hasCycle) {
-            return {
-                callKey,
-                error: {
-                    code: ACTION_CALL_CYCLE,
-                    message: `Cycle detected in action invocation: ${callStack.join(" -> ")} -> ${callKey}`,
-                    details: { alias: ACTION_CYCLE_DETECTED, reason: "cycle_detected", callStack: [...callStack], target: callKey },
-                },
-            };
-        }
-        return { callKey };
-    }
     /**
      * 输入参数 JSON Schema 校验（若 action 已就绪，返回校验错误或 undefined）。
      */
     checkActionInputSchema(action, targetActionId, input) {
-        const targetInputSchema = action?.inputSchema ?? this.projectConfig?.actions?.[targetActionId]?.inputSchema;
-        if (targetInputSchema) {
-            const val = validateSchema(targetInputSchema, input);
+        const targetInputSchema = action?.inputSchema !== undefined
+            ? action.inputSchema
+            : this.projectConfig?.actions?.[targetActionId]?.inputSchema;
+        if (targetInputSchema !== undefined) {
+            const val = validateSchemaOnly(targetInputSchema, input);
             if (!val.valid) {
                 return {
                     code: INPUT_VALIDATION_FAILED,
@@ -535,12 +358,13 @@ export class ActionRunner {
     buildActionContext(args) {
         const { runCtx, controller, rootRunId } = args;
         const { options, targetPackageId, targetActionId, effectiveProcess } = runCtx;
-        const effectiveOwner = options.owner || {
-            tenantId: options.tenantId || "default",
-            principalId: options.principalId || options.ownerId || "default",
-            packageInstanceId: options.packageInstanceId || (this.packageId === targetPackageId ? this.packageInstanceId : targetPackageId),
-            generationId: options.generationId || (this.packageId === targetPackageId ? this.generationId : "1"),
-        };
+        const effectiveOwner = options.owner ||
+            createDefaultProcessOwner({
+                tenantId: options.tenantId,
+                principalId: options.principalId || options.ownerId,
+                packageInstanceId: options.packageInstanceId || this.packageInstanceId,
+                generationId: options.generationId || this.generationId,
+            });
         return createActionContext({
             actionId: targetActionId,
             storage: this.storage,
@@ -566,121 +390,51 @@ export class ActionRunner {
         });
     }
     /**
-     * 子 Action 调用委托：并发上限守卫、uses 跨包声明校验与子执行派发。
+     * 子 Action 调用委托：
+     * 必须委托 Host 动作调用器（走 Host 执行主链与 InvocationPolicy 鉴权）；
+     * 缺少 actionInvoker 时直接抛出 INVOCATION_UNSUPPORTED，严禁跨包或同包无约束执行逃逸。
      */
     async invokeChildAction(args) {
         const { runCtx, controller, rootRunId, childAction, childInput, parentRunId } = args;
-        const { options, targetActionId, effectiveProcess, callStack } = runCtx;
-        if (this.activeSubRuns >= this.maxSubRuns) {
-            const err = new Error(`Maximum concurrent sub-runs (${this.maxSubRuns}) reached`);
-            err.code = ACTION_SUBRUN_LIMIT;
-            err.details = { alias: MAX_SUBRUNS_REACHED, limit: this.maxSubRuns };
-            throw err;
-        }
-        let childPackageId = this.packageId;
-        const parsed = ActionResolver.parseRef(childAction);
-        if (parsed.packageId) {
-            childPackageId = parsed.packageId;
-        }
-        const childActionId = parsed.actionId;
-        const effectiveParentOwner = options.owner || {
-            tenantId: options.tenantId || "default",
-            principalId: options.principalId || options.ownerId || "default",
-            packageInstanceId: options.packageInstanceId || this.packageInstanceId || this.packageId,
-            generationId: options.generationId || this.generationId || "1",
-        };
-        const isSamePackage = !childPackageId || childPackageId === this.packageId;
-        this.activeSubRuns++;
-        try {
-            const runnerToUse = await this.resolveChildRunner(childPackageId, childActionId);
-            if (runnerToUse !== this) {
-                this.assertDeclaredUses(runCtx.action, targetActionId, childPackageId, childActionId);
-            }
-            const childPackageInstanceId = isSamePackage
-                ? effectiveParentOwner.packageInstanceId
-                : (runnerToUse !== this ? runnerToUse.packageInstanceId : childPackageId);
-            const childGenerationId = isSamePackage
-                ? effectiveParentOwner.generationId
-                : (runnerToUse !== this ? runnerToUse.generationId : "1");
-            const childOwner = {
-                tenantId: effectiveParentOwner.tenantId,
-                principalId: effectiveParentOwner.principalId,
-                packageInstanceId: childPackageInstanceId,
-                generationId: childGenerationId,
-            };
-            const childResult = await runnerToUse.execute(childAction, childInput, {
-                rootRunId,
-                parentRunId,
-                callStack,
-                signal: controller.signal,
-                process: effectiveProcess,
-                platform: options.platform || this.platform,
-                progress: options.progress,
-                logger: options.logger,
-                configOverrides: options.configOverrides,
-                maxCallDepth: options.maxCallDepth ?? this.maxCallDepth,
-                tenantId: childOwner.tenantId,
-                principalId: childOwner.principalId,
-                ownerId: childOwner.principalId,
-                packageInstanceId: childOwner.packageInstanceId,
-                generationId: childOwner.generationId,
-                owner: childOwner,
-                hostSessionId: options.hostSessionId ?? this.hostSessionId,
+        const { options, effectiveProcess, callStack } = runCtx;
+        const invoker = options.actionInvoker || this.actionInvoker;
+        if (!invoker) {
+            throw new ActionDockError(INVOCATION_UNSUPPORTED, "Nested action invocation requires a Host ActionInvoker");
+        }
+        const effectiveParentOwner = options.owner ||
+            createDefaultProcessOwner({
+                tenantId: options.tenantId,
+                principalId: options.principalId || options.ownerId,
+                packageInstanceId: this.packageInstanceId,
+                generationId: this.generationId,
             });
-            if (!childResult.ok) {
-                const err = new Error(childResult.error.message);
-                err.code = childResult.error.code;
-                err.details = childResult.error.details;
-                throw err;
-            }
-            return childResult.data;
-        }
-        finally {
-            this.activeSubRuns--;
-        }
-    }
-    /**
-     * 校验跨包子调用是否已在 uses 声明中授权（未声明时抛出 UNDECLARED_ACTION_DEPENDENCY）。
-     */
-    assertDeclaredUses(action, targetActionId, childPackageId, childActionId) {
-        if (!childPackageId || childPackageId === this.packageId) {
-            return;
-        }
-        const actionConfig = this.projectConfig?.actions?.[targetActionId];
-        const rawUses = actionConfig?.uses ?? action?.uses;
-        const declaredUses = Array.isArray(rawUses) ? rawUses : [];
-        const targetRef = `${childPackageId}/${childActionId}`;
-        const isAllowed = declaredUses.some((u) => u === targetRef || u === `${childPackageId}/*` || u === childPackageId);
-        if (!isAllowed) {
-            const err = new Error(`Undeclared cross-package dependency: Action '${this.packageId}/${targetActionId}' does not declare '${targetRef}' in 'uses'`);
-            err.code = UNDECLARED_ACTION_DEPENDENCY;
-            err.details = {
-                caller: `${this.packageId}/${targetActionId}`,
-                target: targetRef,
-                declaredUses: rawUses,
-            };
-            throw err;
-        }
-    }
-    /**
-     * 解析子调用应使用的 Runner（本包或已解析的目标包 Runner）。
-     */
-    async resolveChildRunner(childPackageId, childActionId) {
-        if (childPackageId && childPackageId !== this.packageId) {
-            const targetRunner = await this.resolveTargetPackageRunner(childPackageId);
-            if (targetRunner) {
-                return targetRunner;
-            }
-            if (this.actions.has(`${childPackageId}/${childActionId}`)) {
-                return this;
-            }
-            if (!this.actionResolver) {
-                const err = new Error(`Package '${childPackageId}' could not be resolved`);
-                err.code = PACKAGE_NOT_FOUND;
-                throw err;
-            }
-        }
-        return this;
+        const childRunId = crypto.randomUUID();
+        const invocationContext = {
+            runId: childRunId,
+            rootRunId,
+            parentRunId: parentRunId || runCtx.runId,
+            caller: {
+                packageId: this.packageId,
+                actionId: runCtx.targetActionId,
+                runId: runCtx.runId,
+                declaredUses: runCtx.action?.uses ||
+                    this.projectConfig?.actions?.[runCtx.targetActionId]?.uses,
+            },
+            callStack: [...callStack],
+            package: this.identity,
+            signal: controller.signal,
+            timeoutMs: options.timeoutMs,
+            maxCallDepth: options.maxCallDepth,
+            config: options.configOverrides,
+            tenantId: effectiveParentOwner.tenantId,
+            principalId: effectiveParentOwner.principalId,
+            hostSessionId: options.hostSessionId || this.hostSessionId,
+            logger: options.logger,
+            progress: options.progress,
+            process: effectiveProcess,
+            owner: effectiveParentOwner,
+        };
+        return await invoker(childAction, childInput, invocationContext);
     }
     /**
      * 执行 Action 业务逻辑并与取消/超时信号进行竞态，返回执行结果信封 Promise。
@@ -710,16 +464,6 @@ export class ActionRunner {
                         currentAction = resolution.action;
                         runCtx.action = currentAction;
                     }
-                    else if (resolution.status === "load_failed") {
-                        const cause = resolution.error;
-                        const error = describeActionLoadFailure(cause, {
-                            actionId: targetActionId,
-                            packageId: resolution.packageId,
-                            projectRoot: resolution.projectRoot,
-                        });
-                        finalizer.finalize("failed", undefined, error);
-                        return { ok: false, runId, error };
-                    }
                     else {
                         const error = {
                             code: ACTION_NOT_FOUND,
@@ -729,12 +473,9 @@ export class ActionRunner {
                         finalizer.finalize("failed", undefined, error);
                         return { ok: false, runId, error };
                     }
-                    const inputCheck = validateJsonValue(input);
+                    const inputCheck = validateActionInputValue(input);
                     if (!inputCheck.valid) {
-                        const error = {
-                            code: INPUT_NOT_JSON,
-                            message: `Input validation failed for action '${targetActionId}': ${inputCheck.reason}`,
-                        };
+                        const error = buildInputValidationError(targetActionId, inputCheck);
                         finalizer.finalize("failed", undefined, error);
                         return { ok: false, runId, error };
                     }
@@ -795,9 +536,11 @@ export class ActionRunner {
      * 输出结果 Schema 校验（返回校验错误或 undefined）。
      */
     checkActionOutputSchema(action, targetActionId, rawOutput) {
-        const targetOutputSchema = action?.outputSchema ?? this.projectConfig?.actions?.[targetActionId]?.outputSchema;
-        if (targetOutputSchema) {
-            const outVal = validateSchema(targetOutputSchema, rawOutput);
+        const targetOutputSchema = action?.outputSchema !== undefined
+            ? action.outputSchema
+            : this.projectConfig?.actions?.[targetActionId]?.outputSchema;
+        if (targetOutputSchema !== undefined) {
+            const outVal = validateSchemaOnly(targetOutputSchema, rawOutput);
             if (!outVal.valid) {
                 return {
                     code: OUTPUT_VALIDATION_FAILED,
@@ -849,15 +592,10 @@ export class ActionRunner {
         };
     }
     /**
-     * 释放 Runner 持有的跨包资源：遍历关闭全部子包 Runner 及其独立创建的存储连接。
-     *
-     * 幂等且并发安全：重复调用直接复用首次 Promise；子包存储异常不阻断其余释放；
-     * 仅关闭由本 Runner 构建子包 Runner 时独立创建的存储，外部注入的存储（如经
-     * packageContextResolver 传入的目标包自身存储）生命周期归所有者管理，不在此误关。
+     * 释放 Runner 持有的资源。
+     * 铁律 4：Runner 仅执行自己所属 Package 的 Action，不管理外部包生命周期。
      */
-    async dispose() {
-        return this.packageFactory.dispose();
-    }
+    async dispose() { }
     /**
      * 同步等待方式执行指定 Action，直接返回 ExecutionResult 信封结果。
      *