callman-core 1.0.3 → 1.0.5

package/dist/scenario-runner/runScenario.js

@@ -3,6 +3,7 @@ import { createSubScenarioStepId, buildRuntimeStepDescriptors, DEFAULT_END_LOOP_
 import { executeWithScenarioNodePolicy } from "./executionPolicyRunner.js";
 import { getLegacyScenarioNodeExecutionPolicy, getScenarioNodeExecutionPolicy, supportsScenarioNodeExecutionPolicy, } from "./nodePolicy.js";
 import { buildScenarioExecutionGraph, buildScenarioTemplateValues, collectExclusiveBranchNodeIds, evaluateScenarioExpression, resolveScenarioJsonTemplateString, resolveScenarioTemplateString, } from "./templateResolver.js";
+import { executeWaitNode, ScenarioWaitNodeCancelledError, ScenarioWaitNodeValidationError, } from "./waitNodeExecutor.js";
 class ScenarioStopError extends Error {
     constructor() {
         super("Scenario execution stopped");
@@ -30,6 +31,51 @@ const buildTitle = (node) => {
 };
 const isKafkaNode = (node) => node?.type === "kafka";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const RESERVED_WORKFLOW_ROOT_LABELS = new Set(["workflow", "__meta"]);
+const cloneNodeExecutionMeta = (meta) => ({
+    ...meta,
+    ...(meta.error ? { error: { ...meta.error } } : {}),
+});
+const cloneWorkflowExecutionMeta = (meta) => ({
+    ...meta,
+});
+const cloneNodeMetaByLabel = (value) => Object.fromEntries(Object.entries(value).map(([label, meta]) => [label, cloneNodeExecutionMeta(meta)]));
+const attachNodeMetaToOutput = (output, meta) => {
+    const normalizedMeta = cloneNodeExecutionMeta(meta);
+    if (Array.isArray(output)) {
+        const nextValue = [...output];
+        nextValue.__meta = normalizedMeta;
+        return nextValue;
+    }
+    if (isRecord(output)) {
+        return {
+            ...output,
+            __meta: normalizedMeta,
+        };
+    }
+    if (output === null || typeof output === "undefined") {
+        return {
+            __meta: normalizedMeta,
+        };
+    }
+    return output;
+};
+const createInitialWorkflowMeta = ({ startedAt, totalNodes, }) => ({
+    status: "success",
+    success: true,
+    failed: false,
+    totalNodes,
+    successfulNodes: 0,
+    failedNodes: 0,
+    skippedNodes: 0,
+    totalRetries: 0,
+    startedAt,
+    endedAt: startedAt,
+    durationMs: 0,
+    currentNode: null,
+    lastNode: null,
+    failedNode: null,
+});
 const createInputSnapshot = (context) => ({
     env: context.environment,
     global: context.globals,
@@ -47,6 +93,8 @@ const createContextSnapshot = (context) => ({
     environment: { ...context.environment },
     globals: { ...context.globals },
     workflowContext: { ...context.workflowContext },
+    nodeMetaByLabel: cloneNodeMetaByLabel(context.nodeMetaByLabel),
+    workflowMeta: cloneWorkflowExecutionMeta(context.workflowMeta),
     responseRoot: context.responseRoot ? { ...context.responseRoot } : null,
     lastResponse: context.lastResponse,
     dbResult: context.dbResult,
@@ -125,11 +173,78 @@ const throwIfStopped = (signal) => {
         throw new ScenarioStopError();
     }
 };
+const isWorkflowFailureStatus = (status) => status === "failed" || status === "failed_continued";
+const isWorkflowSuccessStatus = (status) => status === "success" || status === "partial_success";
+const buildNodeExecutionMeta = ({ status, attempts, startedAt, endedAt, durationMs, continueAfterFailure = false, errorMessage, }) => ({
+    status,
+    success: status === "success",
+    failed: status === "failed",
+    skipped: status === "skipped",
+    attempts,
+    startedAt,
+    endedAt,
+    durationMs,
+    ...(continueAfterFailure ? { continueAfterFailure: true } : {}),
+    ...(errorMessage
+        ? {
+            error: {
+                message: errorMessage,
+                type: "ScenarioNodeFailureError",
+            },
+        }
+        : {}),
+});
+const updateWorkflowMetaState = ({ context, records, localStatuses, startedAt, currentNode, lastNode, failedNode, endedAt = new Date().toISOString(), }) => {
+    const statuses = Array.from(localStatuses.values());
+    const successfulNodes = statuses.filter(isWorkflowSuccessStatus).length;
+    const failedNodes = statuses.filter(isWorkflowFailureStatus).length;
+    const skippedNodes = statuses.filter((status) => status === "skipped").length;
+    const totalRetries = Array.from(records.values()).reduce((sum, record) => sum + Math.max(0, record.retryCount), 0);
+    const hasPartialNodes = statuses.some((status) => status === "failed_continued" || status === "partial_success");
+    const nextStatus = failedNodes > 0 && !hasPartialNodes
+        ? "failed"
+        : failedNodes > 0 || hasPartialNodes
+            ? "partial"
+            : "success";
+    const nextMeta = {
+        status: nextStatus,
+        success: nextStatus === "success",
+        failed: nextStatus === "failed",
+        totalNodes: context.workflowMeta.totalNodes,
+        successfulNodes,
+        failedNodes,
+        skippedNodes,
+        totalRetries,
+        startedAt,
+        endedAt,
+        durationMs: Math.max(0, new Date(endedAt).getTime() - new Date(startedAt).getTime()),
+        currentNode: currentNode ?? context.workflowMeta.currentNode ?? null,
+        lastNode: lastNode ?? context.workflowMeta.lastNode ?? null,
+        failedNode: failedNode ?? context.workflowMeta.failedNode ?? null,
+    };
+    context.workflowMeta = nextMeta;
+    context.workflowContext.workflow = {
+        __meta: cloneWorkflowExecutionMeta(nextMeta),
+    };
+    return nextMeta;
+};
+const persistNodeExecutionMeta = ({ context, label, output, meta, }) => {
+    const trimmedLabel = label.trim();
+    if (!trimmedLabel) {
+        return;
+    }
+    context.nodeMetaByLabel[trimmedLabel] = cloneNodeExecutionMeta(meta);
+    if (RESERVED_WORKFLOW_ROOT_LABELS.has(trimmedLabel)) {
+        return;
+    }
+    context.workflowContext[trimmedLabel] = attachNodeMetaToOutput(output, meta);
+};
 const createStepExecutionRecord = ({ stepId, stepType, title, }) => ({
     stepId,
     stepType,
     title,
     status: "idle",
+    meta: null,
     attempts: 0,
     currentAttempt: null,
     maxAttempts: 1,
@@ -200,6 +315,7 @@ const updateRecordFromEvent = (records, event) => {
             stepType: event.stepType,
             title: event.title,
             status: "running",
+            meta: null,
             attempts: event.attempt ?? 1,
             currentAttempt: event.attempt ?? 1,
             maxAttempts: event.maxAttempts ?? 1,
@@ -222,6 +338,7 @@ const updateRecordFromEvent = (records, event) => {
             stepType: event.stepType,
             title: event.title,
             status: "retrying",
+            meta: current.meta,
             attempts: event.attempt,
             currentAttempt: event.attempt,
             maxAttempts: event.maxAttempts,
@@ -256,8 +373,11 @@ const updateRecordFromEvent = (records, event) => {
             stepType: event.stepType,
             title: event.title,
             status: "skipped",
+            meta: event.nodeMeta ?? current.meta,
             inputData: event.inputData ?? current.inputData,
+            outputData: event.outputData ?? current.outputData,
             incomingEdgeId: event.incomingEdgeId ?? current.incomingEdgeId,
+            durationMs: event.durationMs ?? current.durationMs,
             startedAt: current.startedAt ?? event.at,
             completedAt: event.at,
         });
@@ -269,6 +389,7 @@ const updateRecordFromEvent = (records, event) => {
         stepType: event.stepType,
         title: event.title,
         status: event.status ?? (isSuccess ? "success" : "failed"),
+        meta: event.nodeMeta ?? current.meta,
         attempts: event.attempts ?? current.attempts,
         currentAttempt: event.currentAttempt ?? current.currentAttempt,
         maxAttempts: event.maxAttempts ?? current.maxAttempts,
@@ -350,10 +471,20 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
     const localStatuses = new Map(runtimeStepIds.map((stepId) => [stepId, "idle"]));
     const records = new Map();
     const events = [];
+    const initialWorkflowMeta = createInitialWorkflowMeta({
+        startedAt,
+        totalNodes: runtimeStepIds.length,
+    });
     const runtimeContext = {
         environment: { ...environment },
         globals: { ...globals },
-        workflowContext: {},
+        workflowContext: {
+            workflow: {
+                __meta: cloneWorkflowExecutionMeta(initialWorkflowMeta),
+            },
+        },
+        nodeMetaByLabel: {},
+        workflowMeta: initialWorkflowMeta,
         responseRoot: null,
         lastResponse: null,
         dbResult: null,
@@ -416,6 +547,20 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                 continue;
             }
             localStatuses.set(stepId, "skipped");
+            const skippedAt = new Date().toISOString();
+            const nodeMeta = buildNodeExecutionMeta({
+                status: "skipped",
+                attempts: 0,
+                startedAt: skippedAt,
+                endedAt: skippedAt,
+                durationMs: 0,
+            });
+            persistNodeExecutionMeta({
+                context: runtimeContext,
+                label: skippedNode.data.label.trim(),
+                output: null,
+                meta: nodeMeta,
+            });
             await emit({
                 type: "step:skip",
                 runId,
@@ -423,10 +568,19 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                 stepId,
                 stepType: skippedNode.type,
                 title: buildTitle(skippedNode),
-                at: new Date().toISOString(),
+                at: skippedAt,
                 reason,
+                nodeMeta,
                 inputData: createInputSnapshot(runtimeContext),
             });
+            updateWorkflowMetaState({
+                context: runtimeContext,
+                records,
+                localStatuses,
+                startedAt,
+                currentNode: null,
+                lastNode: buildTitle(skippedNode),
+            });
         }
     };
     const markRemainingNodesSkipped = async (reason) => {
@@ -481,6 +635,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
             return;
         }
         const title = buildTitle(node);
+        const nodeLabel = node.data.label.trim();
         const executionPolicy = supportsScenarioNodeExecutionPolicy(node)
             ? getScenarioNodeExecutionPolicy(node)
             : getLegacyScenarioNodeExecutionPolicy();
@@ -507,6 +662,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
         let conditionMode = null;
         let conditionDebug = null;
         let shouldMarkPartialSuccess = false;
+        let workflowOutput = undefined;
         const resetAttemptArtifacts = () => {
             statusCode = null;
             response = null;
@@ -529,6 +685,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
             conditionMode = null;
             conditionDebug = null;
             shouldMarkPartialSuccess = false;
+            workflowOutput = undefined;
         };
         const executeNodeAttempt = async (attempt, maxAttempts) => {
             throwIfStopped(signal);
@@ -552,10 +709,18 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                 inputData,
                 incomingEdgeId: incomingEdgeId ?? null,
             });
+            updateWorkflowMetaState({
+                context: runtimeContext,
+                records,
+                localStatuses,
+                startedAt,
+                currentNode: title,
+            });
             const templateValues = buildScenarioTemplateValues({
                 environment: runtimeContext.environment,
                 globals: runtimeContext.globals,
                 workflowContext: runtimeContext.workflowContext,
+                nodeMetaByLabel: runtimeContext.nodeMetaByLabel,
                 responseRoot: runtimeContext.responseRoot,
                 dbResult: runtimeContext.dbResult,
                 kafkaEvent: runtimeContext.kafkaEvent,
@@ -571,6 +736,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                             environment: runtimeContext.environment,
                             globals: runtimeContext.globals,
                             workflowContext: runtimeContext.workflowContext,
+                            nodeMetaByLabel: runtimeContext.nodeMetaByLabel,
                             responseRoot: runtimeContext.responseRoot,
                             dbResult: runtimeContext.dbResult,
                             kafkaEvent: runtimeContext.kafkaEvent,
@@ -630,6 +796,25 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         throw new ScenarioNodeFailureError(dbResult.failureMessage);
                     }
                 }
+                if (node.type === "wait") {
+                    try {
+                        outputData = await executeWaitNode({
+                            durationMs: node.data.config.durationMs,
+                            signal,
+                        });
+                    }
+                    catch (error) {
+                        if (error instanceof ScenarioWaitNodeCancelledError) {
+                            outputData = error.summary;
+                            throw new ScenarioStopError();
+                        }
+                        if (error instanceof ScenarioWaitNodeValidationError) {
+                            outputData = error.summary;
+                            throw new ScenarioNodeFailureError(error.message);
+                        }
+                        throw error;
+                    }
+                }
                 if (node.type === "script") {
                     const scriptResult = await runtimeAdapters.scriptExecutor({
                         runId,
@@ -705,6 +890,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                                     environment: runtimeContext.environment,
                                     globals: runtimeContext.globals,
                                     workflowContext: runtimeContext.workflowContext,
+                                    nodeMetaByLabel: runtimeContext.nodeMetaByLabel,
                                     responseRoot: runtimeContext.responseRoot,
                                     dbResult: runtimeContext.dbResult,
                                     kafkaEvent: kafkaEventValue,
@@ -731,6 +917,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         environment: runtimeContext.environment,
                         globals: runtimeContext.globals,
                         workflowContext: runtimeContext.workflowContext,
+                        nodeMetaByLabel: runtimeContext.nodeMetaByLabel,
                         responseRoot: runtimeContext.responseRoot,
                         dbResult: runtimeContext.dbResult,
                         kafkaEvent: runtimeContext.kafkaEvent,
@@ -809,13 +996,14 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     }
                 }
                 throwIfStopped(signal);
-                const nodeLabel = node.data.label.trim();
-                const workflowOutput = node.type === "script"
-                    ? scriptHasReturnValue
-                        ? scriptReturnValue
-                        : undefined
-                    : outputData;
+                workflowOutput =
+                    node.type === "script"
+                        ? scriptHasReturnValue
+                            ? scriptReturnValue
+                            : undefined
+                        : outputData;
                 if (nodeLabel &&
+                    !RESERVED_WORKFLOW_ROOT_LABELS.has(nodeLabel) &&
                     typeof workflowOutput !== "undefined" &&
                     (node.type === "script" || workflowOutput !== null)) {
                     runtimeContext.workflowContext[nodeLabel] = workflowOutput;
@@ -837,6 +1025,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                 policy: executionPolicy,
                 execute: executeNodeAttempt,
                 wait: waitForDuration,
+                shouldRethrow: (error) => error instanceof ScenarioStopError,
                 onRetry: async (event) => {
                     localStatuses.set(stepId, "retrying");
                     await emit({
@@ -857,11 +1046,43 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         inputData,
                         incomingEdgeId: incomingEdgeId ?? null,
                     });
+                    updateWorkflowMetaState({
+                        context: runtimeContext,
+                        records,
+                        localStatuses,
+                        startedAt,
+                        currentNode: title,
+                    });
                 },
             });
             const durationMs = Math.round(Date.now() - executionStartedAtMs);
             if (policyResult.outcome === "failed") {
                 localStatuses.set(stepId, "failed");
+                const failedAt = new Date().toISOString();
+                const nodeMeta = buildNodeExecutionMeta({
+                    status: "failed",
+                    attempts: policyResult.attempts,
+                    startedAt: new Date(executionStartedAtMs).toISOString(),
+                    endedAt: failedAt,
+                    durationMs,
+                    errorMessage: policyResult.finalErrorMessage ?? "Scenario node failed",
+                });
+                persistNodeExecutionMeta({
+                    context: runtimeContext,
+                    label: nodeLabel,
+                    output: typeof workflowOutput !== "undefined" ? workflowOutput : outputData,
+                    meta: nodeMeta,
+                });
+                updateWorkflowMetaState({
+                    context: runtimeContext,
+                    records,
+                    localStatuses,
+                    startedAt,
+                    currentNode: null,
+                    lastNode: title,
+                    failedNode: title,
+                    endedAt: failedAt,
+                });
                 await emit({
                     type: "step:fail",
                     runId,
@@ -870,7 +1091,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     stepType: node.type,
                     title,
                     status: "failed",
-                    at: new Date().toISOString(),
+                    at: failedAt,
                     attempts: policyResult.attempts,
                     currentAttempt: policyResult.attempts,
                     maxAttempts: policyResult.maxAttempts,
@@ -880,6 +1101,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     failurePolicy: executionPolicy.onFailure,
                     continuedAfterFailure: false,
                     errors: policyResult.errors,
+                    nodeMeta,
                     errorMessage: policyResult.finalErrorMessage ?? "Scenario node failed",
                     durationMs,
                     statusCode,
@@ -908,6 +1130,33 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
             if (policyResult.outcome === "continued") {
                 degradedStepIds.add(stepId);
                 localStatuses.set(stepId, "failed_continued");
+                const continuedAt = new Date().toISOString();
+                const nodeMeta = buildNodeExecutionMeta({
+                    status: "failed",
+                    attempts: policyResult.attempts,
+                    startedAt: new Date(executionStartedAtMs).toISOString(),
+                    endedAt: continuedAt,
+                    durationMs,
+                    continueAfterFailure: true,
+                    errorMessage: policyResult.finalErrorMessage ??
+                        "Scenario node failed but execution continued.",
+                });
+                persistNodeExecutionMeta({
+                    context: runtimeContext,
+                    label: nodeLabel,
+                    output: typeof workflowOutput !== "undefined" ? workflowOutput : outputData,
+                    meta: nodeMeta,
+                });
+                updateWorkflowMetaState({
+                    context: runtimeContext,
+                    records,
+                    localStatuses,
+                    startedAt,
+                    currentNode: null,
+                    lastNode: title,
+                    failedNode: title,
+                    endedAt: continuedAt,
+                });
                 await emit({
                     type: "step:fail",
                     runId,
@@ -916,7 +1165,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     stepType: node.type,
                     title,
                     status: "failed_continued",
-                    at: new Date().toISOString(),
+                    at: continuedAt,
                     attempts: policyResult.attempts,
                     currentAttempt: policyResult.attempts,
                     maxAttempts: policyResult.maxAttempts,
@@ -926,6 +1175,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     failurePolicy: executionPolicy.onFailure,
                     continuedAfterFailure: true,
                     errors: policyResult.errors,
+                    nodeMeta,
                     errorMessage: policyResult.finalErrorMessage ??
                         "Scenario node failed but execution continued.",
                     durationMs,
@@ -960,6 +1210,29 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     degradedStepIds.delete(stepId);
                 }
                 localStatuses.set(stepId, successStatus);
+                const succeededAt = new Date().toISOString();
+                const nodeMeta = buildNodeExecutionMeta({
+                    status: "success",
+                    attempts: policyResult.attempts,
+                    startedAt: new Date(executionStartedAtMs).toISOString(),
+                    endedAt: succeededAt,
+                    durationMs,
+                });
+                persistNodeExecutionMeta({
+                    context: runtimeContext,
+                    label: nodeLabel,
+                    output: typeof workflowOutput !== "undefined" ? workflowOutput : outputData,
+                    meta: nodeMeta,
+                });
+                updateWorkflowMetaState({
+                    context: runtimeContext,
+                    records,
+                    localStatuses,
+                    startedAt,
+                    currentNode: null,
+                    lastNode: title,
+                    endedAt: succeededAt,
+                });
                 await emit({
                     type: "step:success",
                     runId,
@@ -968,7 +1241,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     stepType: node.type,
                     title,
                     status: successStatus,
-                    at: new Date().toISOString(),
+                    at: succeededAt,
                     attempts: policyResult.attempts,
                     currentAttempt: policyResult.attempts,
                     maxAttempts: policyResult.maxAttempts,
@@ -978,6 +1251,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     failurePolicy: executionPolicy.onFailure,
                     continuedAfterFailure: false,
                     errors: policyResult.errors,
+                    nodeMeta,
                     durationMs,
                     statusCode,
                     response,
@@ -1044,7 +1318,33 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
             if (error instanceof ScenarioStopError) {
                 const stepState = localStatuses.get(stepId);
                 if (stepState === "running" || stepState === "retrying") {
+                    const skipDurationMs = isRecord(outputData) && typeof outputData.actualDurationMs === "number"
+                        ? Math.max(0, Math.round(outputData.actualDurationMs))
+                        : Math.max(0, Math.round(Date.now() - executionStartedAtMs));
+                    const skippedAt = new Date().toISOString();
                     localStatuses.set(stepId, "skipped");
+                    const nodeMeta = buildNodeExecutionMeta({
+                        status: "skipped",
+                        attempts: 0,
+                        startedAt: new Date(executionStartedAtMs).toISOString(),
+                        endedAt: skippedAt,
+                        durationMs: skipDurationMs,
+                    });
+                    persistNodeExecutionMeta({
+                        context: runtimeContext,
+                        label: nodeLabel,
+                        output: typeof workflowOutput !== "undefined" ? workflowOutput : outputData,
+                        meta: nodeMeta,
+                    });
+                    updateWorkflowMetaState({
+                        context: runtimeContext,
+                        records,
+                        localStatuses,
+                        startedAt,
+                        currentNode: null,
+                        lastNode: title,
+                        endedAt: skippedAt,
+                    });
                     await emit({
                         type: "step:skip",
                         runId,
@@ -1052,9 +1352,12 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         stepId,
                         stepType: node.type,
                         title,
-                        at: new Date().toISOString(),
+                        at: skippedAt,
                         reason: "Execution stopped",
+                        nodeMeta,
+                        durationMs: skipDurationMs,
                         inputData,
+                        outputData,
                         incomingEdgeId: incomingEdgeId ?? null,
                     });
                 }
@@ -1082,29 +1385,57 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
         }
         await markRemainingNodesSkipped("Node was not reached during this run.");
         finalStatus = degradedStepIds.size > 0 ? "completed_with_failures" : "success";
+        const endedAt = new Date().toISOString();
+        const workflowMeta = updateWorkflowMetaState({
+            context: runtimeContext,
+            records,
+            localStatuses,
+            startedAt,
+            currentNode: null,
+            endedAt,
+        });
         await emit({
             type: "scenario:end",
             runId,
             scenarioId: scenario.id,
             status: finalStatus,
-            at: new Date().toISOString(),
+            at: endedAt,
             durationMs: Date.now() - startedAtMs,
+            workflowMeta,
         });
     }
     catch (error) {
         const isStopped = error instanceof ScenarioStopError || Boolean(signal?.aborted);
         await markRemainingNodesSkipped(isStopped ? "Skipped because execution was stopped." : "Skipped after failure.");
         finalStatus = isStopped ? "stopped" : "failed";
+        const endedAt = new Date().toISOString();
+        const workflowMeta = updateWorkflowMetaState({
+            context: runtimeContext,
+            records,
+            localStatuses,
+            startedAt,
+            currentNode: null,
+            endedAt,
+        });
         await emit({
             type: "scenario:end",
             runId,
             scenarioId: scenario.id,
             status: finalStatus,
-            at: new Date().toISOString(),
+            at: endedAt,
             durationMs: Date.now() - startedAtMs,
+            workflowMeta,
         });
     }
     const endedAt = new Date().toISOString();
+    const finalWorkflowMeta = updateWorkflowMetaState({
+        context: runtimeContext,
+        records,
+        localStatuses,
+        startedAt,
+        currentNode: null,
+        endedAt,
+    });
     const report = {
         runId,
         scenarioId: scenario.id,
@@ -1116,6 +1447,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
         totalSteps: runtimeStepIds.length,
         completedSteps: Array.from(localStatuses.values()).filter(isTerminalStatus).length,
         context: createContextSnapshot(runtimeContext),
+        workflowMeta: cloneWorkflowExecutionMeta(finalWorkflowMeta),
         nodeExecutions: runtimeStepIds.map((stepId) => {
             const descriptor = runtimeStepDescriptors.find((entry) => entry.stepId === stepId);
             return (records.get(stepId) ??