callman-core 1.0.4 → 1.0.6

package/dist/scenario-runner/runScenario.js

@@ -4,6 +4,7 @@ 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";
+import { buildNotificationDeliveryRequest, renderNotificationTemplate, } from "./notification/index.js";
 class ScenarioStopError extends Error {
     constructor() {
         super("Scenario execution stopped");
@@ -31,6 +32,57 @@ 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 buildWorkflowRoot = ({ scenario, meta, }) => ({
+    id: scenario.id,
+    name: scenario.name,
+    ...(typeof scenario.version === "number" ? { version: scenario.version } : {}),
+    __meta: cloneWorkflowExecutionMeta(meta),
+});
 const createInputSnapshot = (context) => ({
     env: context.environment,
     global: context.globals,
@@ -48,6 +100,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,
@@ -126,11 +180,104 @@ 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 = {
+        ...(isRecord(context.workflowContext.workflow)
+            ? context.workflowContext.workflow
+            : {}),
+        __meta: cloneWorkflowExecutionMeta(nextMeta),
+    };
+    return nextMeta;
+};
+const withNotificationFailurePolicyOverride = (node, policy) => {
+    if (node.type !== "notification") {
+        return policy;
+    }
+    if (typeof node.data.config.continueOnFailure !== "boolean") {
+        return policy;
+    }
+    return {
+        ...policy,
+        onFailure: node.data.config.continueOnFailure ? "continue" : "stop",
+    };
+};
+const normalizeNotificationSeverity = (value) => {
+    switch (value) {
+        case "success":
+        case "warning":
+        case "error":
+            return value;
+        case "info":
+        default:
+            return "info";
+    }
+};
+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,
@@ -201,6 +348,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,
@@ -223,6 +371,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,
@@ -257,6 +406,7 @@ 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,
@@ -272,6 +422,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,
@@ -353,10 +504,21 @@ 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: buildWorkflowRoot({
+                scenario,
+                meta: initialWorkflowMeta,
+            }),
+        },
+        nodeMetaByLabel: {},
+        workflowMeta: initialWorkflowMeta,
         responseRoot: null,
         lastResponse: null,
         dbResult: null,
@@ -419,6 +581,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,
@@ -426,10 +602,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) => {
@@ -484,8 +669,9 @@ 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)
+            ? withNotificationFailurePolicyOverride(node, getScenarioNodeExecutionPolicy(node))
             : getLegacyScenarioNodeExecutionPolicy();
         const executionStartedAtMs = Date.now();
         let inputData = createInputSnapshot(runtimeContext);
@@ -510,6 +696,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;
@@ -532,6 +719,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
             conditionMode = null;
             conditionDebug = null;
             shouldMarkPartialSuccess = false;
+            workflowOutput = undefined;
         };
         const executeNodeAttempt = async (attempt, maxAttempts) => {
             throwIfStopped(signal);
@@ -555,10 +743,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,
@@ -574,6 +770,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,
@@ -690,6 +887,48 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         throw new ScenarioNodeFailureError(redisResult.failureMessage);
                     }
                 }
+                if (node.type === "notification") {
+                    const resolvedMessage = renderNotificationTemplate(node.data.config.messageTemplate, templateValues).trim();
+                    const resolvedChannelOverride = node.data.config.channelOverride?.trim()
+                        ? renderNotificationTemplate(node.data.config.channelOverride, templateValues).trim()
+                        : null;
+                    const workflowRoot = isRecord(runtimeContext.workflowContext.workflow)
+                        ? runtimeContext.workflowContext.workflow
+                        : {};
+                    const deliveryRequest = buildNotificationDeliveryRequest({
+                        provider: node.data.config.provider,
+                        scenario: {
+                            id: scenario.id,
+                            name: scenario.name,
+                            ...(typeof scenario.version === "number"
+                                ? { version: scenario.version }
+                                : {}),
+                        },
+                        nodeLabel: title,
+                        severity: normalizeNotificationSeverity(node.data.config.severity),
+                        message: resolvedMessage || "N/A",
+                        channelOverride: resolvedChannelOverride,
+                        triggerLabel: "Scenario Run",
+                        workflowMeta: runtimeContext.workflowMeta,
+                        useRichBlocks: node.data.config.advanced?.useRichBlocks !== false,
+                    });
+                    const notificationResult = await runtimeAdapters.notificationExecutor({
+                        runId,
+                        stepId,
+                        node,
+                        context: createContextSnapshot(runtimeContext),
+                        deliveryRequest,
+                        signal,
+                    });
+                    outputData = notificationResult.outputData;
+                    if (!notificationResult.delivered || notificationResult.failureMessage) {
+                        throw new ScenarioNodeFailureError(notificationResult.failureMessage ?? "Notification delivery failed.");
+                    }
+                    runtimeContext.workflowContext.workflow = {
+                        ...workflowRoot,
+                        __meta: cloneWorkflowExecutionMeta(runtimeContext.workflowMeta),
+                    };
+                }
                 if (node.type === "kafka") {
                     const resolvedTopic = resolveScenarioTemplateString(node.data.config.topic, templateValues);
                     const rules = node.data.config.rules?.filter((rule) => rule.trim()) ?? [];
@@ -727,6 +966,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,
@@ -753,6 +993,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,
@@ -831,13 +1072,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;
@@ -880,11 +1122,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,
@@ -893,7 +1167,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,
@@ -903,6 +1177,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,
@@ -931,6 +1206,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,
@@ -939,7 +1241,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,
@@ -949,6 +1251,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,
@@ -983,6 +1286,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,
@@ -991,7 +1317,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,
@@ -1001,6 +1327,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     failurePolicy: executionPolicy.onFailure,
                     continuedAfterFailure: false,
                     errors: policyResult.errors,
+                    nodeMeta,
                     durationMs,
                     statusCode,
                     response,
@@ -1070,7 +1397,30 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     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,
@@ -1078,8 +1428,9 @@ 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,
@@ -1110,29 +1461,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,
@@ -1144,6 +1523,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) ??