@actiondock/core 2.10.0 → 2.11.0

package/dist/execution/service.js

@@ -2,50 +2,88 @@ import { existsSync } from "node:fs";
 import { parseActionRef } from "../catalog/resolve-action.js";
 import { computeDigest } from "../project/digest.js";
 import { loadActions, loadProjectConfig } from "../project/loader.js";
+import { SystemClock } from "../storage/clock.js";
 import { InMemoryEventSink } from "../runtime/events.js";
-import { ActionRunner } from "../runtime/runner.js";
-import { ActionDockError, ACTION_NOT_FOUND, EXECUTION_FAILED, IDEMPOTENCY_CONFLICT, RUN_REPOSITORY_UNAVAILABLE, UNHANDLED_EXECUTION_ERROR, describeActionLoadFailure, } from "../errors.js";
+import { ActionDockError, ACTION_CANCELLED, ACTION_FAILED, ACTION_NOT_FOUND, ACTION_TIMEOUT, EXECUTION_CONCURRENCY_LIMIT, EXECUTION_FAILED, IDEMPOTENCY_CONFLICT, INPUT_NOT_JSON, INPUT_VALIDATION_FAILED, INVALID_ARGUMENT, INVOCATION_UNSUPPORTED, OUTPUT_NOT_JSON, OUTPUT_VALIDATION_FAILED, RUN_REPOSITORY_UNAVAILABLE, SERVICE_CLOSED, UNHANDLED_EXECUTION_ERROR, describeActionLoadFailure, } from "../errors.js";
 import { resultStatusToRunStatus } from "../storage/types.js";
+import { createDefaultProcessOwner, } from "../invocation/types.js";
+import { ActionRegistry, isActionDefinitionObject, resolveAnonymousActionId, } from "../runtime/action-registry.js";
+import { buildInitialRunRecord, createRunFinalizer, createRunOrThrow, tryCreateRun, } from "../runtime/run-persistence.js";
+import { createActionContext } from "../runtime/context.js";
+import { validateActionInputValue, validateJsonValue } from "../value-validator.js";
+import { validateSchemaOnly } from "../schema/validator.js";
 /**
- * 统一执行协调服务实现。
+ * 在途运行心跳刷新间隔（毫秒）。
+ *
+ * 必须显著小于存活判定的宽限期（见 run-liveness 的 RUN_LIVENESS_GRACE_MS），
+ * 保证心跳正常的宿主绝不被误判过期；间隔内崩溃由进程探测兜底，
+ * 心跳只服务无进程标识的遗留记录收敛判定。
+ */
+export const RUN_HEARTBEAT_INTERVAL_MS = 30_000;
+/**
+ * 将输入值校验结果映射为标准运行时错误（单一事实源）。
+ */
+function buildInputValidationError(targetActionId, check) {
+    if (check.kind === "json-value") {
+        return {
+            code: INPUT_NOT_JSON,
+            message: `Input validation failed for action '${targetActionId}': ${check.reason}`,
+        };
+    }
+    return {
+        code: INPUT_VALIDATION_FAILED,
+        message: `Input validation failed for action '${targetActionId}': ${check.reason}`,
+        details: [check.reason],
+    };
+}
+/**
+ * 统一执行引擎（融合原协调服务与运行器）。
+ * 消除双层 AbortController 与重复参数透传，收敛唯一生命周期与存储落库。
  */
 export class DefaultExecutionService {
     identity;
     packageId;
+    packageInstanceId;
+    generationId;
+    hostSessionId;
+    /** 宿主进程标识：落库到运行记录供跨进程存活判定（并发打开同一数据目录时不误收割） */
+    hostPid;
+    eventSink;
     storage;
+    globalStorage;
     projectConfig;
     projectRoot;
+    configOverrides;
     moduleLoader;
-    eventSink;
-    packageInstanceId;
-    generationId;
     maxActiveRuns;
     ownerId;
-    hostSessionId;
-    _runner;
+    actionResolver;
     logger;
     clock;
     process;
-    actionResolver;
-    activeRuns = new Map();
-    globalStorage;
     actionInvoker;
+    registry;
+    activeRuns = new Map();
+    /** 在途运行心跳定时器：周期性刷新心跳时间戳，支撑无进程标识判定路径的兜底收敛 */
+    heartbeatTimer;
     isClosing = false;
     reservedSlots = 0;
     constructor(options) {
         if (!options.identity) {
-            throw new Error("DefaultExecutionService requires 'identity' PackageIdentity option");
+            throw new ActionDockError(INVALID_ARGUMENT, "DefaultExecutionService requires 'identity' PackageIdentity option");
         }
         if (!options.storage) {
-            throw new Error("DefaultExecutionService requires 'storage' option");
+            throw new ActionDockError(INVALID_ARGUMENT, "DefaultExecutionService requires 'storage' 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.hostPid = process.pid;
         this.projectConfig = options.projectConfig;
         this.projectRoot = options.projectRoot;
+        this.configOverrides = options.configOverrides || {};
         this.moduleLoader = options.moduleLoader;
         this.eventSink = options.eventSink || new InMemoryEventSink();
         this.maxActiveRuns = options.maxActiveRuns || 32;
@@ -55,65 +93,58 @@ export class DefaultExecutionService {
         this.actionInvoker = options.actionInvoker;
         this.storage = options.storage;
         this.globalStorage = options.globalStorage;
-        this.clock = options.clock;
+        this.clock = options.clock ?? new SystemClock();
         this.process = options.process;
-        this._runner = new ActionRunner({
-            identity: this.identity,
-            hostSessionId: this.hostSessionId,
-            storage: this.storage,
-            globalStorage: this.globalStorage,
-            projectRoot: options.projectRoot,
-            projectConfig: this.projectConfig,
-            configOverrides: options.configOverrides,
-            actions: options.actions,
-            process: this.process,
-            clock: this.clock,
-            actionResolver: this.actionResolver,
-            customHome: options.customHome,
-            actionInvoker: this.actionInvoker,
-        });
+        this.registry = new ActionRegistry(options.actions);
+    }
+    /** 获取运行底层存储实例 */
+    getStorage() {
+        return this.storage;
+    }
+    /** 兼容性引用，执行引擎即执行器自身 */
+    get _runner() {
+        return this;
+    }
+    get activeRunsCount() {
+        return this.activeRuns.size + this.reservedSlots;
     }
     setActionInvoker(invoker) {
         this.actionInvoker = invoker;
-        this._runner.setActionInvoker(invoker);
     }
     registerAction(idOrAction, actionDef) {
         if (typeof idOrAction === "string") {
-            this._runner.registerAction(idOrAction, actionDef);
+            this.registry.registerAction(idOrAction, actionDef);
         }
         else {
-            this._runner.registerAction(idOrAction);
+            this.registry.registerAction(idOrAction);
         }
     }
     getAction(id) {
-        return this._runner.getAction(id);
+        return this.registry.getAction(id);
     }
     listActions() {
-        return this._runner.listActions();
+        return this.registry.listActions();
     }
     getActiveHandle(runId) {
-        return this.activeRuns.get(runId)?.handle;
+        return this.activeRuns.get(runId)?.ticket;
     }
-    async execute(ref, input, context) {
-        const ticket = await this.start(ref, input, context);
+    async execute(ref, input = {}, contextOrOptions) {
+        const ticket = await this.start(ref, input, contextOrOptions);
         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 run(ref, input, context) {
-        return this.execute(ref, input, context);
-    }
-    get activeRunsCount() {
-        return this.activeRuns.size + this.reservedSlots;
+    async run(ref, input = {}, contextOrOptions) {
+        return this.execute(ref, input, contextOrOptions);
     }
-    async start(ref, input, context) {
+    async start(ref, input = {}, contextOrOptions) {
         if (this.isClosing) {
-            throw new Error("ExecutionService is closing: new tasks rejected");
+            throw new ActionDockError(SERVICE_CLOSED, "ExecutionService is closing: new tasks rejected");
         }
         const currentTotal = this.activeRuns.size + this.reservedSlots;
         if (currentTotal >= this.maxActiveRuns) {
-            throw new Error(`Concurrency limit reached: ${currentTotal}/${this.maxActiveRuns} active runs`);
+            throw new ActionDockError(EXECUTION_CONCURRENCY_LIMIT, `Concurrency limit reached: ${currentTotal}/${this.maxActiveRuns} active runs`);
         }
         this.reservedSlots++;
         let hasReservedSlot = true;
@@ -125,16 +156,27 @@ export class DefaultExecutionService {
         };
         try {
             let parsedRef;
-            try {
-                parsedRef = parseActionRef(ref);
+            let targetActionDef;
+            if (isActionDefinitionObject(ref)) {
+                targetActionDef = ref;
+                const actObj = ref;
+                const targetActionId = actObj.id || resolveAnonymousActionId(this.registry.map, ref);
+                this.registry.registerAction(targetActionId, ref);
+                parsedRef = { packageId: this.packageId, actionId: targetActionId };
             }
-            catch {
-                parsedRef = typeof ref === "object" ? ref : { actionId: ref };
+            else {
+                try {
+                    parsedRef = parseActionRef(ref);
+                }
+                catch {
+                    parsedRef = typeof ref === "object" ? ref : { actionId: ref };
+                }
             }
             const targetActionId = parsedRef.actionId;
             const targetPackageId = parsedRef.packageId || this.packageId;
             const actionRef = `${targetPackageId}/${targetActionId}`;
             const effectiveClock = this.clock;
+            const context = this.normalizeContext(contextOrOptions);
             // requestId 幂等检查与去重处理
             const gateResult = await this.checkIdempotencyGate(input, context, actionRef, effectiveClock);
             if (gateResult.ticket) {
@@ -142,7 +184,9 @@ export class DefaultExecutionService {
                 return gateResult.ticket;
             }
             const designatedRunId = gateResult.designatedRunId;
-            const target = await this.resolveExecutionTarget(parsedRef, targetPackageId, targetActionId);
+            const target = targetActionDef
+                ? { action: targetActionDef }
+                : await this.resolveExecutionTarget(parsedRef, targetPackageId, targetActionId);
             if (!target.action) {
                 releaseSlot();
                 return this.failTicketForMissingAction({
@@ -155,77 +199,358 @@ export class DefaultExecutionService {
                     effectiveClock,
                 });
             }
+            const currentAction = target.action;
             if (this.isClosing) {
-                throw new Error("ExecutionService is closing: new tasks rejected");
+                throw new ActionDockError(SERVICE_CLOSED, "ExecutionService is closing: new tasks rejected");
+            }
+            const runId = designatedRunId || context.runId || crypto.randomUUID();
+            const rootRunId = context.rootRunId || context.parentRunId || runId;
+            const bridge = this.createEventBridge({ runId, context, effectiveClock });
+            // 输入参数 JSON 格式与合法性校验
+            const inputCheck = validateActionInputValue(input);
+            if (!inputCheck.valid) {
+                releaseSlot();
+                const error = buildInputValidationError(targetActionId, inputCheck);
+                tryCreateRun(this.storage, buildInitialRunRecord(this.buildPersistenceInput({
+                    runId,
+                    rootRunId,
+                    context,
+                    targetPackageId,
+                    targetActionId,
+                    input,
+                    effectiveClock,
+                }), "failed", error));
+                bridge.emitEvent({ type: "status", status: "failed" });
+                bridge.emitEvent({ type: "finish", result: { ok: false, runId, error } });
+                return {
+                    runId,
+                    status: "failed",
+                    result: Promise.resolve({ ok: false, runId, error }),
+                    cancel: () => false,
+                };
             }
+            // 输入 Schema 校验
+            const schemaError = this.checkActionInputSchema(currentAction, targetActionId, input);
+            if (schemaError) {
+                releaseSlot();
+                tryCreateRun(this.storage, buildInitialRunRecord(this.buildPersistenceInput({
+                    runId,
+                    rootRunId,
+                    context,
+                    targetPackageId,
+                    targetActionId,
+                    input,
+                    effectiveClock,
+                }), "failed", schemaError));
+                bridge.emitEvent({ type: "status", status: "failed" });
+                bridge.emitEvent({ type: "finish", result: { ok: false, runId, error: schemaError } });
+                return {
+                    runId,
+                    status: "failed",
+                    result: Promise.resolve({ ok: false, runId, error: schemaError }),
+                    cancel: () => false,
+                };
+            }
+            // 持久化 running 初始记录
+            createRunOrThrow(this.storage, buildInitialRunRecord(this.buildPersistenceInput({
+                runId,
+                rootRunId,
+                context,
+                targetPackageId,
+                targetActionId,
+                input,
+                effectiveClock,
+            }), "running"));
+            const finalizer = createRunFinalizer(this.storage, runId);
+            // 调用栈快照跟踪
+            const callStack = context.callStack ? [...context.callStack] : [];
+            const callKey = targetPackageId ? `${targetPackageId}/${targetActionId}` : targetActionId;
+            const lastStackItem = callStack[callStack.length - 1];
+            const isAlreadyAtTop = lastStackItem === callKey ||
+                (targetActionId && lastStackItem === targetActionId) ||
+                (targetPackageId && lastStackItem === `${targetPackageId}/${targetActionId}`);
+            if (!isAlreadyAtTop) {
+                callStack.push(callKey);
+            }
+            // 单一 AbortController 控制器
             const controller = new AbortController();
             let onAbort;
-            if (context.signal && typeof context.signal.addEventListener === "function") {
+            if (context.signal) {
                 if (context.signal.aborted) {
                     controller.abort(context.signal.reason);
                 }
                 else {
                     onAbort = () => controller.abort(context.signal?.reason);
                     context.signal.addEventListener("abort", onAbort, { once: true });
+                    finalizer.signal = context.signal;
+                    finalizer.onAbort = onAbort;
                 }
             }
-            const runId = designatedRunId || context.runId || crypto.randomUUID();
-            const bridge = this.createEventBridge({ runId, context, effectiveClock });
-            target.runner.registerAction(targetActionId, target.action);
-            const handle = target.runner.start(targetActionId, input, {
+            if (typeof context.timeoutMs === "number" && context.timeoutMs > 0) {
+                finalizer.startTimeout(controller, context.timeoutMs);
+            }
+            const effectiveOwner = context.owner ||
+                createDefaultProcessOwner({
+                    tenantId: context.tenantId,
+                    principalId: context.principalId,
+                    packageInstanceId: this.packageInstanceId,
+                    generationId: this.generationId,
+                });
+            const effectiveProcess = context.process || this.process;
+            const actionCtx = createActionContext({
+                actionId: targetActionId,
+                storage: this.storage,
+                globalStorage: this.globalStorage,
+                overrides: { ...this.configOverrides, ...(context.config || {}) },
+                projectConfig: this.projectConfig,
                 runId,
-                rootRunId: context.rootRunId,
+                rootRunId,
                 parentRunId: context.parentRunId,
-                callStack: context.callStack ? [...context.callStack] : undefined,
-                hostSessionId: context.hostSessionId || this.hostSessionId,
-                maxCallDepth: context.maxCallDepth,
-                configOverrides: context.config,
                 signal: controller.signal,
-                timeoutMs: context.timeoutMs,
+                process: effectiveProcess,
+                owner: effectiveOwner,
                 progress: bridge.progressReporter,
                 logger: bridge.executionLogger,
-                process: context.process || this.process,
-                packageInstanceId: context.package.instanceId,
-                generationId: context.package.generation,
-                tenantId: context.owner?.tenantId || context.tenantId,
-                principalId: context.owner?.principalId || context.principalId,
-                owner: context.owner
-                    ? {
-                        tenantId: context.owner.tenantId,
-                        principalId: context.owner.principalId,
-                        packageInstanceId: context.owner.packageInstanceId || context.package.instanceId,
-                        generationId: context.owner.generationId || context.package.generation,
-                    }
-                    : undefined,
-                actionInvoker: this.actionInvoker,
+                onActionInvoke: (childAction, childInput, parentRunId) => this.invokeChildAction({
+                    controller,
+                    rootRunId,
+                    childAction,
+                    childInput,
+                    parentRunId: parentRunId || runId,
+                    currentActionId: targetActionId,
+                    currentAction,
+                    callStack,
+                    context,
+                    effectiveProcess,
+                    effectiveOwner,
+                }),
+            });
+            const executionPromise = this.raceExecution({
+                currentAction,
+                targetActionId,
+                input,
+                actionCtx,
+                controller,
+                finalizer,
+                runId,
+                context,
             });
+            const cancelFn = (reason) => {
+                if (finalizer.finalized || controller.signal.aborted) {
+                    return false;
+                }
+                if (context.signal && onAbort) {
+                    context.signal.removeEventListener("abort", onAbort);
+                    finalizer.onAbort = undefined;
+                }
+                controller.abort(new Error(reason || "Action execution was cancelled"));
+                return true;
+            };
+            const ticket = {
+                runId,
+                status: "running",
+                result: executionPromise,
+                cancel: cancelFn,
+            };
             const activeItem = {
-                runId: handle.runId,
-                handle,
+                runId,
                 controller,
                 status: "running",
-                startedAt: (effectiveClock?.now() ?? new Date()).toISOString(),
+                startedAt: (effectiveClock?.now() ?? this.clock.now()).toISOString(),
                 signal: context.signal,
                 onAbort,
+                ticket,
             };
-            this.activeRuns.set(handle.runId, activeItem);
+            this.activeRuns.set(runId, activeItem);
             releaseSlot();
+            this.ensureHeartbeatTimer();
             bridge.emitEvent({ type: "status", status: "running" });
-            this.watchHandleCompletion(handle, activeItem, bridge);
-            return {
-                runId: handle.runId,
-                status: "running",
-                result: handle.result,
-            };
+            executionPromise
+                .then((result) => {
+                const finalStatus = resultStatusToRunStatus(result.ok, result.ok ? undefined : result.error?.code);
+                activeItem.status = finalStatus;
+                bridge.emitEvent({ type: "status", status: finalStatus });
+                bridge.emitEvent({ type: "finish", result });
+            })
+                .catch((err) => {
+                activeItem.status = "failed";
+                bridge.emitEvent({ type: "status", status: "failed" });
+                bridge.emitEvent({
+                    type: "finish",
+                    result: {
+                        ok: false,
+                        runId,
+                        error: {
+                            code: UNHANDLED_EXECUTION_ERROR,
+                            message: err?.message || String(err),
+                        },
+                    },
+                });
+            })
+                .finally(async () => {
+                if (activeItem.signal && activeItem.onAbort) {
+                    activeItem.signal.removeEventListener("abort", activeItem.onAbort);
+                    activeItem.onAbort = undefined;
+                }
+                this.activeRuns.delete(runId);
+                if (actionCtx &&
+                    actionCtx.process?.runScoped === true &&
+                    typeof actionCtx.process.dispose === "function") {
+                    try {
+                        await actionCtx.process.dispose();
+                    }
+                    catch { }
+                }
+            });
+            return ticket;
         }
         catch (err) {
             releaseSlot();
             throw err;
         }
     }
-    /**
-     * 幂等门检查：digest 计算与冲突/重复分流（重复命中时直接返回已有票据）。
-     */
+    normalizeContext(contextOrOptions) {
+        if (contextOrOptions && contextOrOptions.package) {
+            return contextOrOptions;
+        }
+        const opts = (contextOrOptions || {});
+        return {
+            runId: opts.runId,
+            rootRunId: opts.rootRunId,
+            parentRunId: opts.parentRunId,
+            callStack: opts.callStack ? [...opts.callStack] : [],
+            package: opts.package || this.identity,
+            signal: opts.signal,
+            timeoutMs: opts.timeoutMs,
+            maxCallDepth: opts.maxCallDepth,
+            config: opts.config || opts.configOverrides,
+            tenantId: opts.tenantId || opts.owner?.tenantId,
+            principalId: opts.principalId || opts.ownerId || opts.owner?.principalId,
+            hostSessionId: opts.hostSessionId || this.hostSessionId,
+            logger: opts.logger,
+            progress: opts.progress,
+            process: opts.process || this.process,
+            owner: opts.owner,
+            requestId: opts.requestId,
+        };
+    }
+    async raceExecution(args) {
+        const { currentAction, targetActionId, input, actionCtx, controller, finalizer, runId, context } = args;
+        const abortPromise = new Promise((_, reject) => {
+            const rejectWithReason = () => reject(controller.signal.reason || new Error("Action execution was cancelled"));
+            if (controller.signal.aborted) {
+                rejectWithReason();
+            }
+            else {
+                controller.signal.addEventListener("abort", rejectWithReason, { once: true });
+                finalizer.raceListenerRemovers.push(() => {
+                    controller.signal.removeEventListener("abort", rejectWithReason);
+                });
+            }
+        });
+        try {
+            const rawOutput = await Promise.race([
+                Promise.resolve().then(() => currentAction.run(input, actionCtx)),
+                abortPromise,
+            ]);
+            const outputCheck = validateJsonValue(rawOutput);
+            if (!outputCheck.valid) {
+                const error = {
+                    code: OUTPUT_NOT_JSON,
+                    message: `Output validation failed for action '${targetActionId}': ${outputCheck.reason}`,
+                };
+                finalizer.finalize("failed", undefined, error);
+                return { ok: false, runId, error };
+            }
+            const outputSchemaError = this.checkActionOutputSchema(currentAction, targetActionId, rawOutput);
+            if (outputSchemaError) {
+                finalizer.finalize("failed", undefined, outputSchemaError);
+                return { ok: false, runId, error: outputSchemaError };
+            }
+            finalizer.finalize("success", rawOutput);
+            if (finalizer.persistError) {
+                return { ok: false, runId, error: finalizer.persistError };
+            }
+            return {
+                ok: true,
+                runId,
+                data: rawOutput,
+            };
+        }
+        catch (err) {
+            return this.classifyExecutionError(err, runId, context.timeoutMs, controller, finalizer);
+        }
+    }
+    classifyExecutionError(err, runId, timeoutMs, controller, finalizer) {
+        if (finalizer.isTimeout) {
+            const error = {
+                code: ACTION_TIMEOUT,
+                message: `Action exceeded timeout of ${timeoutMs}ms`,
+            };
+            finalizer.finalize("timed_out", undefined, error);
+            return { ok: false, runId, error: finalizer.persistError || error };
+        }
+        if (controller.signal.aborted) {
+            const reason = controller.signal.reason;
+            const reasonMsg = reason instanceof Error
+                ? reason.message
+                : typeof reason === "string"
+                    ? reason
+                    : undefined;
+            const error = {
+                code: ACTION_CANCELLED,
+                message: "Action execution was cancelled",
+                details: reasonMsg ? { reason: reasonMsg } : undefined,
+            };
+            finalizer.finalize("cancelled", undefined, error);
+            return { ok: false, runId, error: finalizer.persistError || error };
+        }
+        const error = {
+            code: err?.code || ACTION_FAILED,
+            message: err?.message || String(err),
+            details: err?.details,
+        };
+        finalizer.finalize("failed", undefined, error);
+        return {
+            ok: false,
+            runId,
+            error: finalizer.persistError || error,
+        };
+    }
+    async invokeChildAction(args) {
+        const { controller, rootRunId, childAction, childInput, parentRunId, currentActionId, currentAction, callStack, context, effectiveProcess, effectiveOwner, } = args;
+        const invoker = this.actionInvoker;
+        if (!invoker) {
+            throw new ActionDockError(INVOCATION_UNSUPPORTED, "Nested action invocation requires a Host ActionInvoker");
+        }
+        const childRunId = crypto.randomUUID();
+        const invocationContext = {
+            runId: childRunId,
+            rootRunId,
+            parentRunId,
+            caller: {
+                packageId: this.packageId,
+                actionId: currentActionId,
+                runId: parentRunId,
+                declaredUses: currentAction?.uses ||
+                    this.projectConfig?.actions?.[currentActionId]?.uses,
+            },
+            callStack: [...callStack],
+            package: this.identity,
+            signal: controller.signal,
+            timeoutMs: context.timeoutMs,
+            maxCallDepth: context.maxCallDepth,
+            config: context.config,
+            tenantId: effectiveOwner.tenantId,
+            principalId: effectiveOwner.principalId,
+            hostSessionId: context.hostSessionId || this.hostSessionId,
+            logger: context.logger,
+            progress: context.progress,
+            process: effectiveProcess,
+            owner: effectiveOwner,
+        };
+        return await invoker(childAction, childInput, invocationContext);
+    }
     async checkIdempotencyGate(input, context, actionRef, effectiveClock) {
         if (!context.requestId) {
             return {};
@@ -246,7 +571,7 @@ export class DefaultExecutionService {
             requestId: context.requestId,
             inputDigest,
             runId: provisionalRunId,
-            createdAt: (effectiveClock?.now() ?? new Date()).toISOString(),
+            createdAt: (effectiveClock?.now() ?? this.clock.now()).toISOString(),
         });
         if (idemp.outcome === "conflict") {
             throw new ActionDockError(IDEMPOTENCY_CONFLICT, `Idempotency conflict for requestId '${context.requestId}': input parameters digest mismatch`, {
@@ -261,11 +586,7 @@ export class DefaultExecutionService {
             const active = this.activeRuns.get(existingRunId);
             if (active) {
                 return {
-                    ticket: {
-                        runId: existingRunId,
-                        status: active.status,
-                        result: active.handle.result,
-                    },
+                    ticket: active.ticket,
                 };
             }
             const record = await this.get(existingRunId);
@@ -285,91 +606,90 @@ export class DefaultExecutionService {
                         runId: existingRunId,
                         status: record.status,
                         result: Promise.resolve(execRes),
+                        cancel: () => false,
                     },
                 };
             }
         }
         return { designatedRunId: provisionalRunId };
     }
-    /**
-     * 解析执行目标：确定目标 Action 定义。
-     * 铁律 4：Runner 不找 Package，ExecutionService 仅执行本 Package 的 Action。
-     */
     async resolveExecutionTarget(parsedRef, targetPackageId, targetActionId) {
-        const runnerToUse = this._runner;
-        let resolveError;
         if (targetPackageId && targetPackageId !== this.packageId) {
-            resolveError = {
+            const resolveError = {
                 code: ACTION_NOT_FOUND,
                 message: `Package '${this.packageId}' cannot execute action for external package '${targetPackageId}'`,
+                details: {
+                    reason: `Cross-package action '${targetPackageId}/${targetActionId}' cannot be resolved by ActionRunner of package '${this.packageId}'`,
+                },
             };
-            return { runner: runnerToUse, action: undefined, resolveError };
+            return { action: undefined, resolveError };
         }
-        let action = runnerToUse.getAction(targetActionId) || runnerToUse.getAction(`${targetPackageId}/${targetActionId}`);
-        if (!action) {
-            const resolution = await runnerToUse.resolveAction(parsedRef);
-            if (resolution.status === "found") {
-                action = resolution.action;
-            }
-            else {
-                const targetAction = await this.actionResolver?.(targetActionId);
-                if (targetAction) {
-                    action = targetAction;
-                }
-                else if (this.projectRoot && existsSync(this.projectRoot)) {
-                    let config;
-                    try {
-                        config = this.projectConfig || loadProjectConfig(this.projectRoot);
-                    }
-                    catch (err) {
-                        resolveError = describeActionLoadFailure(err, {
-                            actionId: targetActionId,
-                            packageId: this.packageId,
-                            projectRoot: this.projectRoot,
-                        });
-                        return { runner: runnerToUse, action: undefined, resolveError };
-                    }
-                    let actionsMap;
-                    try {
-                        actionsMap = await loadActions(this.projectRoot, config.actionsDir, {
-                            loader: this.moduleLoader,
-                        });
-                    }
-                    catch (err) {
-                        resolveError = describeActionLoadFailure(err, {
-                            actionId: targetActionId,
-                            packageId: this.packageId,
-                            projectRoot: this.projectRoot,
-                        });
-                        return { runner: runnerToUse, action: undefined, resolveError };
-                    }
-                    const matched = actionsMap.get(targetActionId);
-                    if (matched) {
-                        action = matched;
-                        runnerToUse.registerAction(targetActionId, matched);
-                    }
-                    else {
-                        resolveError = {
-                            code: ACTION_NOT_FOUND,
-                            message: `Action '${targetActionId}' not found in package '${targetPackageId}'`,
-                            details: resolution.reason ? { reason: resolution.reason } : undefined,
-                        };
+        let action = this.registry.getAction(targetActionId) ||
+            this.registry.getAction(`${targetPackageId}/${targetActionId}`);
+        if (action) {
+            return { action };
+        }
+        if (this.actionResolver) {
+            try {
+                const customResolved = await this.actionResolver(targetActionId);
+                if (customResolved) {
+                    this.registry.registerAction(targetActionId, customResolved);
+                    if (this.packageId) {
+                        this.registry.registerAction(`${this.packageId}/${targetActionId}`, customResolved);
                     }
+                    return { action: customResolved };
                 }
-                else {
-                    resolveError = {
+            }
+            catch (err) {
+                return {
+                    action: undefined,
+                    resolveError: {
                         code: ACTION_NOT_FOUND,
                         message: `Action '${targetActionId}' not found in package '${targetPackageId}'`,
-                        details: resolution.reason ? { reason: resolution.reason } : undefined,
-                    };
-                }
+                        details: { reason: err.message },
+                    },
+                };
             }
         }
-        return { runner: runnerToUse, action, resolveError };
+        if (this.projectRoot && existsSync(this.projectRoot)) {
+            let config;
+            try {
+                config = this.projectConfig || loadProjectConfig(this.projectRoot);
+            }
+            catch (err) {
+                const resolveError = describeActionLoadFailure(err, {
+                    actionId: targetActionId,
+                    packageId: this.packageId,
+                    projectRoot: this.projectRoot,
+                });
+                return { action: undefined, resolveError };
+            }
+            let actionsMap;
+            try {
+                actionsMap = await loadActions(this.projectRoot, config.actionsDir, {
+                    loader: this.moduleLoader,
+                });
+            }
+            catch (err) {
+                const resolveError = describeActionLoadFailure(err, {
+                    actionId: targetActionId,
+                    packageId: this.packageId,
+                    projectRoot: this.projectRoot,
+                });
+                return { action: undefined, resolveError };
+            }
+            const matched = actionsMap.get(targetActionId);
+            if (matched) {
+                this.registry.registerAction(targetActionId, matched);
+                return { action: matched };
+            }
+        }
+        const resolveError = {
+            code: ACTION_NOT_FOUND,
+            message: `Action '${targetActionId}' not found in package '${targetPackageId}'`,
+        };
+        return { action: undefined, resolveError };
     }
-    /**
-     * 解析指定 Action 定义（供 PackageRuntime 或内部使用）。
-     */
     async resolveAction(ref) {
         let parsedRef;
         try {
@@ -383,13 +703,10 @@ export class DefaultExecutionService {
         const target = await this.resolveExecutionTarget(parsedRef, targetPackageId, targetActionId);
         return target.action;
     }
-    /**
-     * 目标 Action 缺失时的失败票据：落库 failed 记录并补发 status 与 finish 事件。
-     */
     failTicketForMissingAction(args) {
         const { target, input, context, targetPackageId, targetActionId, designatedRunId, effectiveClock } = args;
         const runId = designatedRunId || context.runId || crypto.randomUUID();
-        const now = (effectiveClock?.now() ?? new Date()).toISOString();
+        const now = (effectiveClock?.now() ?? this.clock.now()).toISOString();
         const error = target.resolveError || {
             code: ACTION_NOT_FOUND,
             message: `Action '${targetActionId}' not found in package '${targetPackageId}'`,
@@ -400,19 +717,20 @@ export class DefaultExecutionService {
             rootRunId,
             parentRunId: context.parentRunId,
             packageId: targetPackageId,
-            packageInstanceId: context.package.instanceId || target.runner.packageInstanceId,
+            packageInstanceId: context.package?.instanceId || this.packageInstanceId,
             actionId: targetActionId,
-            generationId: context.package.generation || target.runner.generationId,
+            generationId: context.package?.generation || this.generationId,
             ownerId: this.ownerId,
             hostSessionId: context.hostSessionId || this.hostSessionId,
+            hostPid: this.hostPid,
             status: "failed",
-            input,
+            input: input,
             error,
             startedAt: now,
             finishedAt: now,
         };
         try {
-            target.runner.getStorage().createRun(initialRun);
+            this.storage.createRun(initialRun);
         }
         catch (err) {
             throw new ActionDockError(RUN_REPOSITORY_UNAVAILABLE, `RUN_REPOSITORY_UNAVAILABLE: Failed to initialize run record in repository: ${err?.message || String(err)}`, { originalError: err?.message });
@@ -446,11 +764,66 @@ export class DefaultExecutionService {
                 runId,
                 error,
             }),
+            cancel: () => false,
         };
     }
-    /**
-     * 创建执行事件桥：事件序列号分配、进度报告器与双写日志适配器。
-     */
+    buildPersistenceInput(args) {
+        const { runId, rootRunId, context, targetPackageId, targetActionId, input, effectiveClock } = args;
+        const startedAt = effectiveClock?.now().toISOString() ||
+            (typeof this.storage.clock?.now === "function"
+                ? this.storage.clock.now().toISOString()
+                : this.clock.now().toISOString());
+        return {
+            runId,
+            rootRunId,
+            parentRunId: context.parentRunId,
+            ownerId: context.principalId || context.tenantId || this.ownerId,
+            hostSessionId: context.hostSessionId || this.hostSessionId,
+            hostPid: this.hostPid,
+            packageInstanceId: context.package?.instanceId || this.packageInstanceId,
+            generationId: context.package?.generation || this.generationId,
+            targetPackageId,
+            targetActionId,
+            startedAt,
+            input,
+            runnerPackageId: this.packageId,
+            runnerPackageInstanceId: this.packageInstanceId,
+            runnerGenerationId: this.generationId,
+            runnerHostSessionId: this.hostSessionId,
+        };
+    }
+    checkActionInputSchema(action, targetActionId, 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,
+                    message: `Input schema validation failed for action '${targetActionId}'`,
+                    details: val.errors,
+                };
+            }
+        }
+        return undefined;
+    }
+    checkActionOutputSchema(action, targetActionId, 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,
+                    message: `Output schema validation failed for action '${targetActionId}'`,
+                    details: outVal.errors,
+                };
+            }
+        }
+        return undefined;
+    }
     createEventBridge(args) {
         const { runId, context, effectiveClock } = args;
         let sequence = 0;
@@ -460,7 +833,7 @@ export class DefaultExecutionService {
                 runId,
                 rootRunId: context.rootRunId || context.parentRunId || runId,
                 sequence: sequence++,
-                timestamp: (effectiveClock?.now() ?? new Date()).toISOString(),
+                timestamp: (effectiveClock?.now() ?? this.clock.now()).toISOString(),
             };
             this.eventSink.emit(evt);
         };
@@ -493,40 +866,6 @@ export class DefaultExecutionService {
         };
         return { emitEvent, progressReporter, executionLogger };
     }
-    /**
-     * 监听执行句柄终态：映射终态状态、补发 status 与 finish 事件并注销活跃运行。
-     */
-    watchHandleCompletion(handle, activeItem, bridge) {
-        handle.result
-            .then((result) => {
-            const finalStatus = resultStatusToRunStatus(result.ok, result.ok ? undefined : result.error?.code);
-            activeItem.status = finalStatus;
-            bridge.emitEvent({ type: "status", status: finalStatus });
-            bridge.emitEvent({ type: "finish", result });
-        })
-            .catch((err) => {
-            activeItem.status = "failed";
-            bridge.emitEvent({ type: "status", status: "failed" });
-            bridge.emitEvent({
-                type: "finish",
-                result: {
-                    ok: false,
-                    runId: handle.runId,
-                    error: {
-                        code: UNHANDLED_EXECUTION_ERROR,
-                        message: err?.message || String(err),
-                    },
-                },
-            });
-        })
-            .finally(() => {
-            if (activeItem.signal && activeItem.onAbort) {
-                activeItem.signal.removeEventListener("abort", activeItem.onAbort);
-                activeItem.onAbort = undefined;
-            }
-            this.activeRuns.delete(handle.runId);
-        });
-    }
     async get(runId) {
         return this.storage.getRun(runId) ?? undefined;
     }
@@ -544,22 +883,69 @@ export class DefaultExecutionService {
             active.onAbort = undefined;
         }
         active.controller.abort(new Error(reason || "Execution cancelled"));
-        active.handle.cancel(reason);
         return { outcome: "requested", runId };
     }
     events(runId, options = {}) {
         return this.eventSink.subscribe(runId, options);
     }
+    /**
+     * 确保在途运行心跳定时器存在。
+     *
+     * 存活判定的第一依据是进程探测（运行记录已落库宿主进程标识），
+     * 心跳是对遗留记录（无进程标识）与其他协作场景的兜底信号：
+     * 持有进程周期性刷新在途记录的心跳时间戳，收割方仅对心跳过期的
+     * 遗留记录做宽限期判定，正常运行中的记录绝不会被误判过期。
+     * 定时器不阻塞进程退出（unref），无在途运行时不产生任何调度。
+     */
+    ensureHeartbeatTimer() {
+        if (this.heartbeatTimer)
+            return;
+        const touch = () => {
+            if (this.isClosing || this.activeRuns.size === 0)
+                return;
+            if (typeof this.storage.touchRunHeartbeat !== "function")
+                return;
+            try {
+                this.storage.touchRunHeartbeat(Array.from(this.activeRuns.keys()));
+            }
+            catch (err) {
+                // 心跳失败不影响执行主链路，存活判定仍可依赖进程探测，但必须通过 logger.warn 记录告警
+                const errDetail = err instanceof Error ? `${err.message}${err.stack ? `\n${err.stack}` : ""}` : String(err);
+                const warnMsg = `[ExecutionService] Failed to touch run heartbeat: ${errDetail}`;
+                if (this.logger) {
+                    this.logger.warn(warnMsg, {
+                        error: err instanceof Error ? err.message : String(err),
+                        stack: err instanceof Error ? err.stack : undefined,
+                    });
+                }
+                else {
+                    console.warn(warnMsg);
+                }
+            }
+        };
+        this.heartbeatTimer = setInterval(touch, RUN_HEARTBEAT_INTERVAL_MS);
+        if (this.heartbeatTimer.unref) {
+            this.heartbeatTimer.unref();
+        }
+    }
     async close(options = {}) {
         this.isClosing = true;
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = undefined;
+        }
         this.reservedSlots = 0;
         const graceMs = options.graceMs ?? 5000;
         for (const [_, active] of this.activeRuns) {
             active.controller.abort(new Error("Service shutting down"));
-            active.handle.cancel("Service shutting down");
         }
         if (this.activeRuns.size > 0) {
-            const waitPromise = Promise.all(Array.from(this.activeRuns.values()).map((a) => a.handle.result.catch(() => { })));
+            const waitPromise = Promise.all(Array.from(this.activeRuns.values()).map((a) => a.ticket.result?.catch(() => { })));
+            // 此处优雅关闭竞速保留原生 setTimeout 与 clearTimeout 的取舍说明：
+            // Clock 接口仅提供 sleep 异步等待能力，未提供注销或取消计划中休眠的句柄；
+            // 若直接使用 clock.sleep 与 waitPromise 竞速，在任务提早完成时未触发的休眠 Promise 将在后台悬挂直至超时；
+            // 保留原生定时器并在 finally 中即时清理，可确保优雅关闭在任何分支下均不产生定时器泄漏；
+            // 且此处仅为服务终结阶段的兜底防护，对确定性测试执行链路无负面干扰。
             let timeoutTimer;
             const timeoutPromise = new Promise((resolve) => {
                 timeoutTimer = setTimeout(resolve, graceMs);
@@ -574,7 +960,10 @@ export class DefaultExecutionService {
             }
         }
         this.activeRuns.clear();
-        await this._runner.dispose();
+    }
+    async dispose() {
+        await this.close();
     }
 }
 export { DefaultExecutionService as ExecutionService };
+export { DefaultExecutionService as ActionRunner };