@exellix/graph-engine 6.0.0

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -0,0 +1,1716 @@
+import { mergeExecutionObject, copyExecutionContextFields, } from "./memory.js";
+import { buildAiTasksRunTaskRequest, extractRunTaskStrategyOverrides, resolveJobTypeId, } from "./buildAiTasksRunTaskRequest.js";
+import { runTaskResponseSucceeded } from "./runTaskResponse.js";
+import { getAiTaskProfileStrategyKeys, runEngineAiTasksStrategyPhase, } from "./aiTasksStrategyPhases.js";
+import { mergeGraphDocumentModel, EXELLIX_GRAPH_MODEL_VARIABLE_KEY, } from "../types/refs.js";
+import { normalizeSynthesizedContextConfig } from "./synthesizedContextPipeline.js";
+import { resolveExecutionPipelineForTaskNode } from "./resolveExecutionPipelineForTaskNode.js";
+import { resolveTaskNodeInputsForRunTask } from "./resolveTaskNodeInputs.js";
+import { assertAiTasksNodeExtensionsValid } from "../inspection/validateAiTasksNodeExtensions.js";
+import { buildRunTaskMainInput, extractCallerInputsBag } from "./resolveGraphEngineMemoryPaths.js";
+import { mirrorRuntimeInputRawOnExecutionMemory, mirrorStructuredInputOntoExecutionMemory, } from "./materializeStructuredRunTaskInput.js";
+import { buildMainReadinessResolutionRoot, evaluateTaskNodeMainReadiness, resolveMainReadinessPolicy, } from "./taskNodeMainReadiness.js";
+import { mergeXynthesizedPatchIntoExecution, seedGraphRunExecutionState, xynthesizedOutboundForNode, } from "./graphRunExecutionSeed.js";
+import { buildTaskNodeJobContext } from "./buildTaskNodeJobContext.js";
+import { resolveNarrixForTaskNode } from "./resolveNarrixForTaskNode.js";
+import { assertFinalizerRequiredReadsResolvable, validateGraphFinalizer, } from "./finalizers/validateFinalizer.js";
+import { executeDeterministicFinalizer, executeSynthesizeFinalizer } from "./finalizers/executeFinalizer.js";
+import { createFinalizerError } from "./finalizers/errors.js";
+import { assertCanonicalGraphDocument } from "./validateCanonicalGraphDocument.js";
+import { applyGraphResponseDefinition } from "./graphResponseMapping.js";
+import { migrateLegacyGraphResponse } from "./graphResponseMigration.js";
+import { computeGraphDocumentContentSha256 } from "./graphDocumentFingerprint.js";
+import { buildAiTasksObservabilityRecord } from "./aiTasksObservability.js";
+import { buildRunTaskIdentityEnvelope, mergeDefinedLlmCallParts, shouldForwardRunTaskTraceMode, } from "./runTaskAugments.js";
+import { buildRunLog, extractLogxerCorrelationFromMetadata, extractTaskRunLogFromMetadata, resolveRunLogLimits, } from "./buildRunLog.js";
+import { setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground } from "./runtimeObjects.js";
+import { assertHostJobId, newGraphRunTaskId } from "./graphRunIdentity.js";
+import { resolveTaskKey } from "./resolveTaskKey.js";
+import { buildPredicateEvalContextForNode, mirrorTaskVariablesOnExecution, readExecutionVariableBuckets, seedGraphVariableBucketsFromRuntime, } from "./variables.js";
+import { mergeExellixGraphRuntimeInvocation } from "./mergeExellixGraphRuntimeInvocation.js";
+import { resolveStepRetryPolicy, runRunTaskWithRetry } from "./stepRetry.js";
+import { isLocalSkillKey, runScopedDataReader, runDeterministicRule, runScopedAnswerWriter, runScopedAnswerAssembler, } from "./localSkills/index.js";
+import { evaluateGraphPredicate } from "./predicates.js";
+import { evaluateStructuredDataFilters } from "./dataFiltersEvaluation.js";
+import { evaluateTaskNodeConditions } from "./taskNodeConditionsEvaluation.js";
+import { resolveModelConfigForNode } from "./resolveModelConfigForNode.js";
+import { createRunx } from "@x12i/runx";
+import { selectByPath } from "./pathExpr.js";
+import { createGraphStartEvent, createGraphCompleteEvent, createGraphFailEvent, createNodeStartEvent, createNodeCompleteEvent, createNodeFailEvent, } from "./events.js";
+import { ExellixGraphErrorCode } from "../errors/exellixGraphErrorCodes.js";
+const NODE_LIFECYCLE_EMITTED = "__exellixNodeLifecycleEmitted";
+function skippedByConditionsOutput(skipReason) {
+    return Object.freeze({
+        __exellixSkipped: true,
+        skipReason,
+    });
+}
+const DEFAULT_CORE_OBJECTIVE_PROPERTY_NAME = "coreObjective";
+const DEFAULT_CORE_OBJECTIVE_SOURCE_PATH = "input.coreObjective";
+const DEFAULT_NODE_RESPONSE_SINGULAR = "nodeResponse";
+const DEFAULT_NODE_RESPONSE_PLURAL = "nodeResponses";
+const SUPPORTED_CORE_OBJECTIVE_SOURCE_ROOTS = new Set([
+    "input",
+    "execution",
+    "variables",
+    "jobVariables",
+    "taskVariables",
+    "jobMemory",
+    "taskMemory",
+    "job",
+]);
+function markNodeLifecycleEmitted(err) {
+    if (err != null && typeof err === "object") {
+        err[NODE_LIFECYCLE_EMITTED] = true;
+    }
+}
+function wasNodeLifecycleEmitted(err) {
+    return (err != null &&
+        typeof err === "object" &&
+        err[NODE_LIFECYCLE_EMITTED] === true);
+}
+function taskRunSucceeded(res) {
+    return runTaskResponseSucceeded(res);
+}
+function unwrapNodeResponse(output) {
+    if (output != null &&
+        typeof output === "object" &&
+        !Array.isArray(output) &&
+        output.parsed !== undefined) {
+        return output.parsed;
+    }
+    return output;
+}
+function resolveNodeResponseKeys(graphExecution) {
+    const singular = graphExecution?.nodesResponses?.singular;
+    const plural = graphExecution?.nodesResponses?.plural;
+    return {
+        singular: typeof singular === "string" && singular.length > 0 ? singular : DEFAULT_NODE_RESPONSE_SINGULAR,
+        plural: typeof plural === "string" && plural.length > 0 ? plural : DEFAULT_NODE_RESPONSE_PLURAL,
+    };
+}
+function resolveCoreObjectiveConfig(graphExecution) {
+    const propertyName = graphExecution?.coreObjective?.propertyName;
+    const sourcePath = graphExecution?.coreObjective?.sourcePath;
+    return {
+        propertyName: typeof propertyName === "string" && propertyName.length > 0
+            ? propertyName
+            : DEFAULT_CORE_OBJECTIVE_PROPERTY_NAME,
+        sourcePath: typeof sourcePath === "string" && sourcePath.length > 0
+            ? sourcePath
+            : DEFAULT_CORE_OBJECTIVE_SOURCE_PATH,
+    };
+}
+function isSupportedCoreObjectiveSourcePath(path) {
+    const root = path.split(".")[0];
+    return SUPPORTED_CORE_OBJECTIVE_SOURCE_ROOTS.has(root);
+}
+function resolveCoreObjectiveValue(args) {
+    if (!isSupportedCoreObjectiveSourcePath(args.sourcePath))
+        return undefined;
+    const executionRec = args.execution != null && typeof args.execution === "object" && !Array.isArray(args.execution)
+        ? args.execution
+        : undefined;
+    return selectByPath({
+        input: executionRec?.input,
+        execution: args.execution,
+        variables: executionRec?.jobVariables ?? args.variables,
+        jobVariables: executionRec?.jobVariables,
+        taskVariables: executionRec?.taskVariables,
+        jobMemory: args.jobMemory,
+        taskMemory: args.taskMemory,
+        job: args.job,
+    }, args.sourcePath);
+}
+function isPlainRecord(v) {
+    return v != null && typeof v === "object" && !Array.isArray(v);
+}
+function cloneJsonLike(value) {
+    if (value === undefined || value === null)
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}
+function jsonValuesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((item, index) => jsonValuesEqual(item, b[index]));
+    }
+    if (isPlainRecord(a) || isPlainRecord(b)) {
+        if (!isPlainRecord(a) || !isPlainRecord(b))
+            return false;
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every((key) => Object.prototype.hasOwnProperty.call(b, key) && jsonValuesEqual(a[key], b[key]));
+    }
+    return false;
+}
+function arrayStartsWith(value, prefix) {
+    if (prefix.length > value.length)
+        return false;
+    return prefix.every((item, index) => jsonValuesEqual(value[index], item));
+}
+function applyExecutionDelta(target, next, base) {
+    for (const [key, nextValue] of Object.entries(next)) {
+        const baseValue = base[key];
+        if (jsonValuesEqual(nextValue, baseValue))
+            continue;
+        const currentValue = target[key];
+        if (isPlainRecord(nextValue) && isPlainRecord(currentValue)) {
+            applyExecutionDelta(currentValue, nextValue, isPlainRecord(baseValue) ? baseValue : {});
+            continue;
+        }
+        if (Array.isArray(nextValue) && Array.isArray(baseValue) && Array.isArray(currentValue) && arrayStartsWith(nextValue, baseValue)) {
+            target[key] = [...currentValue, ...nextValue.slice(baseValue.length)];
+            continue;
+        }
+        target[key] = cloneJsonLike(nextValue);
+    }
+}
+function mergeExecutionUpdate(current, next, base) {
+    if (!isPlainRecord(next))
+        return next;
+    if (!isPlainRecord(current))
+        return cloneJsonLike(next);
+    const merged = cloneJsonLike(current);
+    applyExecutionDelta(merged, next, isPlainRecord(base) ? base : {});
+    return merged;
+}
+function readRuntimeNodeConfig(nodes, nodeId) {
+    if (nodes == null || typeof nodeId !== "string" || nodeId.length === 0)
+        return undefined;
+    const candidate = nodes[nodeId];
+    return isPlainRecord(candidate) ? candidate : undefined;
+}
+function mergeAliasConfigs(rootAliases, nodeAliases) {
+    const aliases = {};
+    for (const source of [rootAliases, nodeAliases]) {
+        if (!isPlainRecord(source))
+            continue;
+        for (const [alias, model] of Object.entries(source)) {
+            if (alias.trim() !== "" && typeof model === "string" && model.trim() !== "") {
+                aliases[alias] = model;
+            }
+        }
+    }
+    return Object.keys(aliases).length > 0 ? aliases : undefined;
+}
+function taskNodeNeedsRunxClient(conditions) {
+    return conditions?.jsConditionFunction != null || conditions?.aiCondition != null;
+}
+function modelConfigSelectionNeedsRunx(sel) {
+    if (sel == null || !Array.isArray(sel.cases))
+        return false;
+    return sel.cases.some((c) => c.when?.jsConditionFunction != null || c.when?.aiCondition != null);
+}
+function graphNeedsRunxClient(graph, runtimeModelConfig) {
+    if (modelConfigSelectionNeedsRunx(runtimeModelConfig))
+        return true;
+    if (modelConfigSelectionNeedsRunx(graph.modelConfig))
+        return true;
+    for (const n of graph.nodes ?? []) {
+        const tn = n;
+        if (taskNodeNeedsRunxClient(tn.conditions))
+            return true;
+        if (modelConfigSelectionNeedsRunx(tn.taskConfiguration?.modelConfig))
+            return true;
+    }
+    return false;
+}
+function mergeKnowledgePatchIntoRunTaskMemory(memory, patch) {
+    if (patch == null)
+        return memory;
+    const base = isPlainRecord(memory) ? { ...memory } : {};
+    const existingKnowledge = isPlainRecord(base.knowledge) ? base.knowledge : {};
+    return {
+        ...base,
+        knowledge: {
+            ...existingKnowledge,
+            ...patch,
+        },
+    };
+}
+function applyTaskResultMapping(args) {
+    if (args.mapping == null || args.outputForMapping === undefined)
+        return args.targetMemory;
+    const { path, mode, map, fields } = args.mapping;
+    return mergeExecutionObject(isPlainRecord(args.targetMemory) ? args.targetMemory : {}, path, args.outputForMapping, mode, map || fields ? { map, fields } : undefined, {
+        node: args.node,
+        variables: args.variables,
+    });
+}
+async function resolveKnowledgePatch(args) {
+    const refs = [...new Set((args.refs ?? []).filter((ref) => typeof ref === "string" && ref.trim() !== "").map((ref) => ref.trim()))];
+    if (refs.length === 0 || args.resolver == null)
+        return undefined;
+    const patch = await args.resolver(refs, args.context);
+    return patch ?? undefined;
+}
+function normalizeRuntimeExecutionMemory(runtime) {
+    const execution = isPlainRecord(runtime.executionMemory)
+        ? runtime.executionMemory
+        : {};
+    if (runtime.input !== undefined) {
+        execution.input = isPlainRecord(runtime.input) ? { ...runtime.input } : runtime.input;
+    }
+    else if (!isPlainRecord(execution.input)) {
+        execution.input = {};
+    }
+    if (isPlainRecord(runtime.inputs)) {
+        execution.inputs = { ...runtime.inputs };
+    }
+    mirrorRuntimeInputRawOnExecutionMemory(execution);
+    return execution;
+}
+function normalizeRuntimeOutputsMemory(runtime) {
+    return isPlainRecord(runtime.outputsMemory) ? runtime.outputsMemory : {};
+}
+export function createExellixGraphRuntime(opts) {
+    function parsePositiveInt(v) {
+        const n = Number(v);
+        if (!Number.isFinite(n))
+            return undefined;
+        const i = Math.floor(n);
+        return i > 0 ? i : undefined;
+    }
+    /**
+     * Concurrency tiers (highest → lowest):
+     * 1) node-level: node.concurrency | node.taskConfiguration.concurrency | node.data.concurrency
+     * 2) graph-level: graph.concurrency | graph.metadata.concurrency | graph.config?.concurrency
+     * 3) env-level: process.env.WOREX_GRAPH_CONCURRENCY
+     * 4) default fallback: 4
+     *
+     * Node-level is "confusing" because it affects siblings, so we interpret it as:
+     * - If multiple runnable nodes specify concurrency, we take the MIN across them
+     *   (strictest wins) for the current batch.
+     */
+    function resolveConcurrencyLimit(args) {
+        // Tier 4: default fallback
+        let limit = 4;
+        // Tier 3: env
+        const envLimit = parsePositiveInt(process.env.WOREX_GRAPH_CONCURRENCY);
+        if (envLimit)
+            limit = envLimit;
+        // Tier 2: graph-level
+        const graphLimit = parsePositiveInt(args.graph?.concurrency) ??
+            parsePositiveInt(args.graph?.metadata?.concurrency) ??
+            parsePositiveInt(args.graph?.config?.concurrency);
+        if (graphLimit)
+            limit = graphLimit;
+        // Tier 1: node-level (strictest wins for the batch)
+        const nodeLimits = args.runnableNodes
+            .map((n) => parsePositiveInt(n?.concurrency) ??
+            parsePositiveInt(n?.taskConfiguration?.concurrency) ??
+            parsePositiveInt(n?.data?.concurrency))
+            .filter((x) => typeof x === "number");
+        if (nodeLimits.length) {
+            limit = Math.min(limit, ...nodeLimits);
+        }
+        // Also respect runtime option if you still want it as a hard cap:
+        const hardCap = parsePositiveInt(opts.concurrency);
+        if (hardCap)
+            limit = Math.min(limit, hardCap);
+        return Math.max(1, limit);
+    }
+    /**
+     * Runs items with a concurrency limit. If failFast=true, stops scheduling new items
+     * after first error, but does not "cancel" in-flight executions.
+     */
+    async function runPool(items, concurrency, worker, options) {
+        const failFastLocal = options?.failFast ?? false;
+        let index = 0;
+        let aborted = false;
+        async function runner() {
+            while (true) {
+                if (aborted)
+                    return;
+                const i = index++;
+                if (i >= items.length)
+                    return;
+                try {
+                    await worker(items[i]);
+                }
+                catch (e) {
+                    if (failFastLocal)
+                        aborted = true;
+                    throw e;
+                }
+            }
+        }
+        const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => runner());
+        // We want all worker errors, but caller usually handles errors per-node.
+        // Here, we let errors bubble.
+        await Promise.all(workers);
+    }
+    async function executeNode(input) {
+        const graphRunTaskId = input.graphRunTaskId ?? newGraphRunTaskId();
+        const runTaskJobIdStr = String(input.job?.jobId ?? input.job?.id ?? "");
+        const lifecycleJobId = runTaskJobIdStr || String(input.job?.jobId ?? input.job?.id ?? "standalone-job");
+        const effectiveLlmCall = mergeDefinedLlmCallParts((input.llmCall ?? opts.llmCall), input.node?.taskConfiguration?.llmCall);
+        const forwardRunTaskTrace = shouldForwardRunTaskTraceMode({
+            runTaskExecutionMode: input.runTaskExecutionMode ?? opts.runTaskExecutionMode,
+        });
+        const runTaskIdentityBase = input.runTaskIdentity ?? opts.runTaskIdentity;
+        if (input.node?.type === 'finalizer') {
+            const finalizer = input.node;
+            let execution = input.execution;
+            const outputsMemory = isPlainRecord(input.outputsMemory) ? input.outputsMemory : {};
+            if (execution == null || typeof execution !== 'object')
+                execution = {};
+            if (!execution._trace)
+                execution._trace = { nodes: {} };
+            if (!execution._trace.nodes)
+                execution._trace.nodes = {};
+            const startedAt = Date.now();
+            const finalizerIdentity = buildRunTaskIdentityEnvelope({
+                base: runTaskIdentityBase,
+                nodeMeta: finalizer.metadata,
+                graphId: input.graphId,
+                nodeId: String(finalizer.id),
+                taskId: graphRunTaskId,
+                jobId: lifecycleJobId,
+            });
+            if (input.eventEmitter) {
+                input.eventEmitter.emit(createNodeStartEvent(lifecycleJobId, input.graphId, graphRunTaskId, finalizer, "finalizer", undefined, input.jobCorrelation));
+            }
+            try {
+                const mode = finalizer.finalizerType === 'synthesize' ? 'ai' : 'deterministic';
+                const { parsed, rawContent } = finalizer.finalizerType === 'synthesize'
+                    ? await executeSynthesizeFinalizer({
+                        finalizer,
+                        config: finalizer.config,
+                        executionMemory: execution,
+                        outputsMemory,
+                        runTask: (req) => opts.tasksClient.runTask({
+                            ...req,
+                            agentId: input.job?.agentId ?? "standalone-agent",
+                            jobTypeId: resolveJobTypeId(input.job),
+                            taskTypeId: `exellix-graph-finalizer:${String(finalizer.config?.utilityKey ?? "synthesize")}`,
+                            coreSkillId: String(finalizer.id),
+                            nodeId: String(finalizer.id),
+                            graphId: input.graphId,
+                            masterSkillId: input.graphId,
+                            masterSkillActivityId: `${lifecycleJobId}:${finalizer.id}`,
+                            input: req.input ?? {},
+                            identity: {
+                                ...finalizerIdentity,
+                                ...(req.identity &&
+                                    typeof req.identity === "object" &&
+                                    !Array.isArray(req.identity)
+                                    ? req.identity
+                                    : {}),
+                                kind: "finalizer",
+                            },
+                            ...(input.modelConfig != null ? { modelConfig: input.modelConfig } : {}),
+                            ...(effectiveLlmCall != null ? { llmCall: effectiveLlmCall } : {}),
+                            ...(forwardRunTaskTrace ? { executionMode: "trace" } : {}),
+                            ...((input.runTaskDiagnostics ?? opts.runTaskDiagnostics) != null
+                                ? { diagnostics: input.runTaskDiagnostics ?? opts.runTaskDiagnostics }
+                                : {}),
+                        }),
+                        context: {
+                            graphId: input.graphId,
+                            jobId: input.job?.jobId,
+                            taskId: graphRunTaskId,
+                            agentId: input.job?.agentId,
+                        },
+                    })
+                    : {
+                        ...executeDeterministicFinalizer({
+                            finalizer,
+                            executionMemory: execution,
+                            outputsMemory,
+                            graph: input.graph,
+                        }),
+                        rawContent: undefined,
+                    };
+                const endedAt = Date.now();
+                execution._trace.nodes[String(finalizer.id)] = {
+                    startedAt,
+                    endedAt,
+                    skillKey: 'finalizer',
+                    ok: true,
+                    durationMs: endedAt - startedAt,
+                    summary: {
+                        finalizerType: finalizer.finalizerType,
+                        mode,
+                        ...(mode === 'ai' ? { executionPolicy: finalizer.config?.executionPolicy } : {}),
+                    },
+                };
+                const finalizerOut = { parsed, ...(rawContent ? { rawContent } : {}) };
+                const outputForMapping = parsed !== undefined
+                    ? (isPlainRecord(parsed)
+                        ? { ...parsed, parsed, ...(rawContent ? { rawContent } : {}) }
+                        : { parsed, ...(rawContent ? { rawContent } : {}) })
+                    : rawContent
+                        ? { rawContent }
+                        : undefined;
+                const updatedOutputsMemory = applyTaskResultMapping({
+                    targetMemory: outputsMemory,
+                    mapping: finalizer.outputMapping,
+                    outputForMapping,
+                    node: finalizer,
+                    variables: {},
+                });
+                if (input.eventEmitter) {
+                    input.eventEmitter.emit(createNodeCompleteEvent(lifecycleJobId, input.graphId, graphRunTaskId, finalizer, "finalizer", {
+                        output: finalizerOut,
+                        memoryAfter: {
+                            jobMemory: input.jobMemory,
+                            taskMemory: input.taskMemory,
+                            execution,
+                            outputsMemory: updatedOutputsMemory,
+                        },
+                    }, input.jobCorrelation));
+                }
+                return {
+                    nodeId: String(finalizer.id),
+                    skillKey: 'finalizer',
+                    output: finalizerOut,
+                    execution,
+                    outputsMemory: updatedOutputsMemory,
+                };
+            }
+            catch (e) {
+                const endedAt = Date.now();
+                const err = e?.code != null
+                    ? e
+                    : createFinalizerError({
+                        code: 'GRAPH_FINALIZER_OUTPUT_INVALID',
+                        message: e?.message ?? 'Finalizer failed',
+                        finalizerNodeId: String(finalizer.id),
+                        details: { error: e },
+                    });
+                execution._trace.nodes[String(finalizer.id)] = {
+                    startedAt,
+                    endedAt,
+                    skillKey: 'finalizer',
+                    ok: false,
+                    durationMs: endedAt - startedAt,
+                    error: { message: err.message, code: err.code, stack: err.stack },
+                };
+                if (input.eventEmitter) {
+                    input.eventEmitter.emit(createNodeFailEvent(lifecycleJobId, input.graphId, graphRunTaskId, finalizer, "finalizer", {
+                        error: { message: err.message, code: err.code, stack: err.stack },
+                        memoryAfter: {
+                            jobMemory: input.jobMemory,
+                            taskMemory: input.taskMemory,
+                            execution,
+                            outputsMemory,
+                        },
+                        response: undefined,
+                    }, input.jobCorrelation));
+                }
+                markNodeLifecycleEmitted(err);
+                throw err;
+            }
+        }
+        const skillKey = resolveTaskKey(input.node, input.skillKeyResolution ?? {}, {
+            jobId: runTaskJobIdStr || undefined,
+            graphId: input.graphId,
+        });
+        // Local-skill interception: scoped-data-reader, deterministic-rule, scoped-answer-writer,
+        // scoped-answer-assembler all run in-process — never call `tasksClient.runTask`.
+        if (isLocalSkillKey(skillKey)) {
+            let execution = input.execution;
+            const updatedOutputsMemory = isPlainRecord(input.outputsMemory) ? input.outputsMemory : {};
+            if (execution == null || typeof execution !== "object")
+                execution = {};
+            if (!execution._trace)
+                execution._trace = { nodes: {} };
+            if (!execution._trace.nodes)
+                execution._trace.nodes = {};
+            const startedAt = Date.now();
+            const localCtx = {
+                jobId: lifecycleJobId,
+                graphId: input.graphId,
+                taskId: graphRunTaskId,
+            };
+            if (input.eventEmitter) {
+                input.eventEmitter.emit(createNodeStartEvent(localCtx.jobId, localCtx.graphId, localCtx.taskId, input.node, skillKey, undefined, input.jobCorrelation));
+            }
+            try {
+                const cfg = input.node?.taskConfiguration ?? {};
+                const pathOpts = { graphTaskNodeId: String(input.node.id) };
+                let output;
+                if (skillKey === 'scoped-data-reader') {
+                    output = (await runScopedDataReader(cfg, execution, pathOpts));
+                }
+                else if (skillKey === 'deterministic-rule') {
+                    output = runDeterministicRule(cfg, execution, pathOpts);
+                }
+                else if (skillKey === 'scoped-answer-writer') {
+                    output = (await runScopedAnswerWriter(cfg, execution, pathOpts));
+                }
+                else {
+                    output = runScopedAnswerAssembler(cfg, execution, pathOpts);
+                }
+                const outputForMapping = { ...output, parsed: output };
+                execution = applyTaskResultMapping({
+                    targetMemory: execution,
+                    mapping: input.node?.executionMapping,
+                    outputForMapping,
+                    node: input.node,
+                    variables: {},
+                });
+                const endedAt = Date.now();
+                if (execution == null || typeof execution !== 'object')
+                    execution = {};
+                if (!execution._trace)
+                    execution._trace = { nodes: {} };
+                if (!execution._trace.nodes)
+                    execution._trace.nodes = {};
+                execution._trace.nodes[String(input.node.id)] = {
+                    startedAt,
+                    endedAt,
+                    skillKey,
+                    ok: true,
+                    durationMs: endedAt - startedAt,
+                };
+                if (input.eventEmitter) {
+                    input.eventEmitter.emit(createNodeCompleteEvent(localCtx.jobId, localCtx.graphId, localCtx.taskId, input.node, skillKey, {
+                        output,
+                        memoryAfter: { jobMemory: input.jobMemory, taskMemory: input.taskMemory, execution, outputsMemory: updatedOutputsMemory },
+                        response: { success: true, output },
+                    }, input.jobCorrelation));
+                }
+                return {
+                    nodeId: input.node.id,
+                    skillKey,
+                    output: { ...output, parsed: output },
+                    execution,
+                    outputsMemory: updatedOutputsMemory,
+                };
+            }
+            catch (err) {
+                const endedAt = Date.now();
+                execution._trace.nodes[String(input.node.id)] = {
+                    startedAt,
+                    endedAt,
+                    skillKey,
+                    ok: false,
+                    durationMs: endedAt - startedAt,
+                    error: { message: err?.message ?? 'Local skill failed', code: err?.code },
+                };
+                if (input.eventEmitter) {
+                    input.eventEmitter.emit(createNodeFailEvent(localCtx.jobId, localCtx.graphId, localCtx.taskId, input.node, skillKey, {
+                        error: { code: err?.code ?? 'LOCAL_SKILL_FAILED', message: err?.message ?? 'Local skill failed' },
+                        memoryAfter: { jobMemory: input.jobMemory, taskMemory: input.taskMemory, execution },
+                        response: undefined,
+                    }, input.jobCorrelation));
+                }
+                const wrapped = err?.code != null ? err : new Error(err?.message ?? 'Local skill failed');
+                if (wrapped.code == null)
+                    wrapped.code = 'LOCAL_SKILL_FAILED';
+                wrapped.nodeId = input.node?.id;
+                markNodeLifecycleEmitted(wrapped);
+                throw wrapped;
+            }
+        }
+        if (input.eventEmitter) {
+            input.eventEmitter.emit(createNodeStartEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, undefined, input.jobCorrelation));
+        }
+        const effectiveModelConfig = input.modelConfig;
+        // DEBUG: Verify execution object before sending
+        if (process.env.DEBUG_EXECUTION_MEMORY === 'true') {
+            console.log(`[DEBUG] Node ${input.node?.id}: execution object =`, JSON.stringify(input.execution, null, 2));
+        }
+        let execution = input.execution;
+        if (execution == null || typeof execution !== "object")
+            execution = {};
+        if (!execution._trace)
+            execution._trace = { nodes: {} };
+        if (!execution._trace.nodes)
+            execution._trace.nodes = {};
+        try {
+            assertAiTasksNodeExtensionsValid(input.node, `nodes.${String(input.node.id)}`);
+        }
+        catch (pe) {
+            if (input.eventEmitter) {
+                input.eventEmitter.emit(createNodeFailEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, {
+                    error: { message: pe?.message, code: pe?.code, stack: pe?.stack },
+                    memoryAfter: { jobMemory: input.jobMemory, taskMemory: input.taskMemory, execution },
+                    response: undefined,
+                }, input.jobCorrelation));
+            }
+            markNodeLifecycleEmitted(pe);
+            throw pe;
+        }
+        let executionPipeline;
+        try {
+            executionPipeline = resolveExecutionPipelineForTaskNode({
+                node: input.node,
+                optionsExecutionPipeline: input.graphExecutionPipeline,
+                executionExecutionPipeline: input.execution?.executionPipeline,
+            });
+        }
+        catch (pe) {
+            if (input.eventEmitter) {
+                input.eventEmitter.emit(createNodeFailEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, {
+                    error: { message: pe?.message, code: pe?.code, stack: pe?.stack },
+                    memoryAfter: { jobMemory: input.jobMemory, taskMemory: input.taskMemory, execution },
+                    response: undefined,
+                }, input.jobCorrelation));
+            }
+            const err = new Error(pe?.message ?? "Execution pipeline resolution failed");
+            err.code = pe?.code ?? "INPUT_SYNTHESIS_PIPELINE_CONFLICT";
+            err.nodeId = input.node?.id;
+            markNodeLifecycleEmitted(err);
+            throw err;
+        }
+        const hasSynthesizedContextPreStep = Array.isArray(executionPipeline) &&
+            executionPipeline.some((s) => s.phase === "pre" && s.type === "synthesized-context");
+        const preStepConfig = hasSynthesizedContextPreStep && Array.isArray(executionPipeline)
+            ? normalizeSynthesizedContextConfig(executionPipeline.find((s) => s.phase === "pre" && s.type === "synthesized-context")?.config)
+            : undefined;
+        const includeContextInPrompt = hasSynthesizedContextPreStep && preStepConfig?.autoEnableContext !== true;
+        const executionRec = execution;
+        mirrorTaskVariablesOnExecution({
+            execution: executionRec,
+            node: input.node,
+            runtimeTaskVariables: input.taskVariables ?? undefined,
+        });
+        const variableBuckets = readExecutionVariableBuckets(executionRec);
+        const jobVariables = variableBuckets.jobVariables;
+        const hasExistingSynthesizedContext = execution != null &&
+            typeof execution === "object" &&
+            execution.synthesizedContext != null;
+        const clearSynthForTask = input.clearSynthesizedContextPerNode === true &&
+            hasSynthesizedContextPreStep &&
+            hasExistingSynthesizedContext;
+        mirrorRuntimeInputRawOnExecutionMemory(executionRec);
+        const nodeBindings = resolveTaskNodeInputsForRunTask({
+            node: input.node,
+            execution: executionRec,
+        });
+        const jobContext = buildTaskNodeJobContext({
+            node: input.node,
+            jobMemory: input.jobMemory,
+            executionMemory: executionRec,
+            variables: jobVariables,
+        });
+        const narrix = resolveNarrixForTaskNode({
+            nodeMetadataNarrix: input.node?.taskConfiguration?.narrix != null
+                ? { ...input.node.taskConfiguration.narrix }
+                : undefined,
+            graphVariablesNarrix: jobVariables?.narrix,
+            aiTaskProfile: input.node?.taskConfiguration?.aiTaskProfile,
+        });
+        const metaTk = input.node?.taskConfiguration?.taskKind;
+        const taskKindForward = metaTk === "decision" || metaTk === "utility" || metaTk === "content" ? metaTk : undefined;
+        const autoValDec = input.node?.taskConfiguration?.autoValidateDecisionOutput;
+        const strategyKeys = getAiTaskProfileStrategyKeys(input.node?.taskConfiguration);
+        const startedAt = Date.now();
+        if (strategyKeys.preStrategyKey != null) {
+            const preRes = await runEngineAiTasksStrategyPhase({
+                phase: "pre",
+                strategySkillKey: strategyKeys.preStrategyKey,
+                parentSkillKey: skillKey,
+                aiTasks: opts.tasksClient,
+                job: input.job,
+                nodeId: String(input.node.id),
+                graphId: input.graphId,
+                taskId: graphRunTaskId,
+                runTaskJobId: lifecycleJobId,
+                execution: executionRec,
+                variables: jobVariables,
+                jobMemory: input.jobMemory,
+                taskMemory: input.taskMemory,
+                jobContext,
+                prevNodeId: input.prevNodeId,
+                modelConfig: effectiveModelConfig,
+                llmCall: effectiveLlmCall,
+                runTaskIdentity: runTaskIdentityBase,
+                nodeTaskConfiguration: input.node?.taskConfiguration,
+                forwardRunTaskTrace,
+                runTaskDiagnostics: (input.runTaskDiagnostics ?? opts.runTaskDiagnostics),
+                nodeTimeoutMs: input.nodeTimeoutMs,
+            });
+            if (!preRes.ok) {
+                const err = new Error(preRes.response.error?.message ?? "ENGINE_PRE_STRATEGY_FAILED");
+                err.code = preRes.response.error?.code ?? "ENGINE_PRE_STRATEGY_FAILED";
+                err.nodeId = input.node?.id;
+                if (input.eventEmitter) {
+                    input.eventEmitter.emit(createNodeFailEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, {
+                        error: {
+                            message: err.message,
+                            code: err.code,
+                            ...(preRes.response.error != null ? { details: preRes.response.error } : {}),
+                        },
+                        memoryAfter: { jobMemory: input.jobMemory, taskMemory: input.taskMemory, execution },
+                        response: preRes.response,
+                    }, input.jobCorrelation));
+                }
+                markNodeLifecycleEmitted(err);
+                throw err;
+            }
+        }
+        const executionForTask = clearSynthForTask
+            ? (() => {
+                const c = { ...executionRec };
+                delete c.synthesizedContext;
+                return c;
+            })()
+            : executionRec;
+        const callerInputs = extractCallerInputsBag({
+            execution: executionRec,
+            jobMemory: isPlainRecord(input.jobMemory) ? input.jobMemory : undefined,
+        });
+        const taskInput = buildRunTaskMainInput({
+            execution: executionRec,
+            jobMemory: isPlainRecord(input.jobMemory) ? input.jobMemory : undefined,
+            nodeBindings: {
+                ...nodeBindings,
+                ...(input.node?.data?.upstreamNodeIds !== undefined
+                    ? { upstreamNodeIds: input.node.data.upstreamNodeIds }
+                    : {}),
+            },
+        });
+        mirrorStructuredInputOntoExecutionMemory(executionForTask, taskInput);
+        const graphDocModel = jobVariables[EXELLIX_GRAPH_MODEL_VARIABLE_KEY];
+        const graphEntry = graphDocModel != null && typeof graphDocModel === "object" && !Array.isArray(graphDocModel)
+            ? graphDocModel.graphEntry
+            : undefined;
+        const readinessPolicy = resolveMainReadinessPolicy({
+            runtimePolicy: input.mainReadinessPolicy,
+            nodeTaskConfiguration: input.node?.taskConfiguration,
+        });
+        const readinessRoot = buildMainReadinessResolutionRoot({
+            taskInput,
+            callerInputs,
+            executionMemory: executionForTask,
+            xynthesized: xynthesizedOutboundForNode(executionRec, String(input.node.id)),
+            jobMemory: input.jobMemory,
+            taskMemory: input.taskMemory,
+        });
+        const readiness = evaluateTaskNodeMainReadiness({
+            policy: readinessPolicy,
+            node: input.node,
+            graphEntry,
+            resolutionRoot: readinessRoot,
+        });
+        if (!readiness.ok) {
+            const err = new Error(`MAIN_READINESS_FAILED: ${readiness.failedChecks.join(", ")} (nodeId=${String(input.node.id)})`);
+            err.code = ExellixGraphErrorCode.MAIN_READINESS_FAILED;
+            err.nodeId = input.node?.id;
+            err.readiness = readiness;
+            if (input.eventEmitter) {
+                input.eventEmitter.emit(createNodeFailEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, {
+                    error: {
+                        message: err.message,
+                        code: err.code,
+                        details: { readiness },
+                    },
+                    memoryAfter: { jobMemory: input.jobMemory, taskMemory: input.taskMemory, execution: executionRec },
+                    response: undefined,
+                }, input.jobCorrelation));
+            }
+            markNodeLifecycleEmitted(err);
+            throw err;
+        }
+        const runTaskJobMemory = mergeKnowledgePatchIntoRunTaskMemory(input.jobMemory, input.jobKnowledgePatch);
+        const runTaskTaskMemory = mergeKnowledgePatchIntoRunTaskMemory(input.taskMemory, input.taskKnowledgePatch);
+        const metaStrats = input.node?.taskConfiguration?.executionStrategies;
+        const req = buildAiTasksRunTaskRequest({
+            skillKey,
+            job: input.job,
+            nodeId: String(input.node.id),
+            taskConfiguration: input.node?.taskConfiguration,
+            graphId: input.graphId,
+            taskId: graphRunTaskId,
+            runTaskJobId: lifecycleJobId,
+            taskInput,
+            callerInputs,
+            variables: jobVariables,
+            jobMemory: runTaskJobMemory,
+            taskMemory: runTaskTaskMemory,
+            executionMemory: executionForTask,
+            jobContext,
+            prevNodeId: input.prevNodeId,
+            executionPipeline: executionPipeline,
+            includeContextInPrompt: includeContextInPrompt === true ? true : undefined,
+            narrix: narrix ?? undefined,
+            ...extractRunTaskStrategyOverrides(input.node?.taskConfiguration),
+            outputValidation: input.node?.taskConfiguration?.aiTasksOutputValidation != null &&
+                typeof input.node.taskConfiguration.aiTasksOutputValidation === "object" &&
+                input.node.taskConfiguration.aiTasksOutputValidation !== null &&
+                "schema" in input.node.taskConfiguration.aiTasksOutputValidation
+                ? input.node.taskConfiguration.aiTasksOutputValidation
+                : undefined,
+            diagnostics: (input.runTaskDiagnostics ?? opts.runTaskDiagnostics),
+            modelConfig: effectiveModelConfig ?? undefined,
+            llmCall: effectiveLlmCall,
+            identity: buildRunTaskIdentityEnvelope({
+                base: runTaskIdentityBase,
+                nodeMeta: input.node?.taskConfiguration,
+                graphId: input.graphId,
+                nodeId: String(input.node.id),
+                taskId: graphRunTaskId,
+                jobId: lifecycleJobId,
+            }),
+            executionMode: forwardRunTaskTrace ? "trace" : undefined,
+            taskKind: taskKindForward,
+            autoValidateDecisionOutput: typeof autoValDec === "boolean" ? autoValDec : undefined,
+            executionStrategies: Array.isArray(metaStrats) ? metaStrats : [],
+            xynthesized: xynthesizedOutboundForNode(executionRec, String(input.node.id)),
+            smartInput: input.node.smartInput,
+        });
+        // TRACE: Validate request object before sending
+        if (process.env.DEBUG_EXECUTION_MEMORY === 'true') {
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: Node ${input.node?.id} - Request built`);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: req.executionMemory =`, JSON.stringify(req.executionMemory, null, 2));
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: req.executionMemory type =`, typeof req.executionMemory);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: req.executionMemory is undefined?`, req.executionMemory === undefined);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: req.executionMemory is null?`, req.executionMemory === null);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: req has executionMemory property?`, 'executionMemory' in req);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: req keys =`, Object.keys(req));
+            if (req.executionMemory && typeof req.executionMemory === 'object') {
+                console.log(`[TRACE] ExellixGraphRuntime.executeNode: req.executionMemory keys =`, Object.keys(req.executionMemory));
+            }
+        }
+        let res;
+        const nodeTimeoutMs = input.nodeTimeoutMs;
+        const stepRetryPolicyResolved = resolveStepRetryPolicy(input.stepRetryPolicy ?? opts.stepRetryPolicy, input.node);
+        let retryOutcome;
+        try {
+            retryOutcome = await runRunTaskWithRetry({
+                initialRequest: req,
+                doRunTask: (r) => opts.tasksClient.runTask(r),
+                nodeTimeoutMs,
+                policy: stepRetryPolicyResolved,
+                nodeId: String(input.node.id),
+                skillKey,
+                nodeTimeoutErrorFactory: () => {
+                    const err = new Error(`Node execution timed out after ${nodeTimeoutMs}ms (nodeId=${String(input.node.id)}, skillKey=${String(skillKey)})`);
+                    err.code = "NODE_TIMEOUT";
+                    err.nodeId = input.node.id;
+                    return err;
+                },
+            });
+            res = retryOutcome.response;
+        }
+        catch (runErr) {
+            const endedAt = Date.now();
+            const att = Array.isArray(runErr?.stepRetryAttempts) ? runErr.stepRetryAttempts : [];
+            execution._trace.nodes[input.node.id] = {
+                startedAt,
+                endedAt,
+                skillKey,
+                ok: false,
+                durationMs: endedAt - startedAt,
+                error: {
+                    message: runErr?.message ?? "Task run failed",
+                    code: runErr?.code,
+                    stack: runErr?.stack,
+                },
+                ...(att.length ? { attempts: att } : {}),
+            };
+            const syn = Array.isArray(runErr?.syntheticStepRetryRunLog) ? runErr.syntheticStepRetryRunLog : [];
+            const prevLog = Array.isArray(runErr?.taskRunLog) ? runErr.taskRunLog : [];
+            runErr.taskRunLog = [...syn, ...prevLog];
+            if (input.eventEmitter) {
+                input.eventEmitter.emit(createNodeFailEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, {
+                    error: {
+                        message: runErr?.message ?? "Task run failed",
+                        code: runErr?.code,
+                        stack: runErr?.stack,
+                    },
+                    memoryAfter: { jobMemory: input.jobMemory, taskMemory: input.taskMemory, execution },
+                    response: undefined,
+                }, input.jobCorrelation));
+            }
+            markNodeLifecycleEmitted(runErr);
+            throw runErr;
+        }
+        const endedAt = Date.now();
+        const durationMs = res.parsed?.meta?.durationMs ?? (endedAt - startedAt);
+        const activityId = res.parsed?.meta?.activityId ?? res.parsed?.meta?.localTaskId;
+        const summary = res.parsed?.meta != null ? { ...res.parsed.meta } : undefined;
+        if (!taskRunSucceeded(res)) {
+            execution._trace.nodes[input.node.id] = {
+                startedAt,
+                endedAt,
+                skillKey,
+                ok: false,
+                durationMs,
+                activityId,
+                summary,
+                error: {
+                    message: res.error?.message ?? "Task run failed",
+                    code: res.error?.code,
+                },
+                attempts: retryOutcome.attempts,
+            };
+            const resMeta = res.metadata ?? res.meta;
+            const taskRunLog = [...retryOutcome.syntheticRunLog, ...extractTaskRunLogFromMetadata(resMeta)];
+            const logxerCorrelationId = extractLogxerCorrelationFromMetadata(resMeta);
+            const err = new Error(`TASK_RUN_FAILED: ${skillKey}`);
+            err.code = res.error?.code ?? "TASK_RUN_FAILED";
+            err.skillKey = skillKey;
+            err.diagnostics = res.diagnostics;
+            err.nodeId = input.node?.id;
+            if (taskRunLog.length)
+                err.taskRunLog = taskRunLog;
+            if (logxerCorrelationId)
+                err.logxerCorrelationId = logxerCorrelationId;
+            err.stepRetryAttempts = retryOutcome.attempts;
+            if (input.eventEmitter) {
+                input.eventEmitter.emit(createNodeFailEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, {
+                    error: {
+                        message: err.message,
+                        code: err.code,
+                    },
+                    memoryAfter: { jobMemory: input.jobMemory, taskMemory: input.taskMemory, execution },
+                    response: res,
+                }, input.jobCorrelation));
+            }
+            markNodeLifecycleEmitted(err);
+            throw err;
+        }
+        let updatedExecution = res.execution !== undefined ? res.execution : execution;
+        copyExecutionContextFields(updatedExecution, execution, ["webContext", "synthesizedContext"]);
+        copyExecutionContextFields(updatedExecution, res.executionMemory, ["webContext", "synthesizedContext"]);
+        const xPatchRt = res.xynthesizedPatch;
+        mergeXynthesizedPatchIntoExecution({
+            execution: updatedExecution,
+            nodeId: String(input.node.id),
+            patch: xPatchRt,
+        });
+        const traceSynthExtrasRt = {
+            smartInput: { paths: [...(input.node.smartInput?.paths ?? [])] },
+            xynthesized: {
+                jobPatchKeys: Object.keys(xPatchRt?.job ?? {}),
+                taskPatchKeys: Object.keys(xPatchRt?.task ?? {}),
+                executionPatchKeys: Object.keys(xPatchRt?.execution ?? {}),
+            },
+        };
+        const mergedTraceSummaryRt = summary != null && typeof summary === "object" && !Array.isArray(summary)
+            ? { ...summary, ...traceSynthExtrasRt }
+            : traceSynthExtrasRt;
+        execution._trace.nodes[input.node.id] = {
+            startedAt,
+            endedAt,
+            skillKey,
+            ok: true,
+            durationMs,
+            activityId,
+            summary: mergedTraceSummaryRt,
+            attempts: retryOutcome.attempts,
+        };
+        // Handle execution object updates from response (patch merged above)
+        // Note: We don't modify jobMemory or taskMemory - they're set before the job starts and passed through as-is
+        if (strategyKeys.postStrategyKey != null) {
+            const postExec = updatedExecution != null && typeof updatedExecution === "object" && !Array.isArray(updatedExecution)
+                ? updatedExecution
+                : executionRec;
+            const postRes = await runEngineAiTasksStrategyPhase({
+                phase: "post",
+                strategySkillKey: strategyKeys.postStrategyKey,
+                parentSkillKey: skillKey,
+                aiTasks: opts.tasksClient,
+                job: input.job,
+                nodeId: String(input.node.id),
+                graphId: input.graphId,
+                taskId: graphRunTaskId,
+                runTaskJobId: lifecycleJobId,
+                execution: postExec,
+                variables: jobVariables,
+                jobMemory: input.jobMemory,
+                taskMemory: input.taskMemory,
+                jobContext,
+                prevNodeId: input.prevNodeId,
+                modelConfig: effectiveModelConfig,
+                llmCall: effectiveLlmCall,
+                runTaskIdentity: runTaskIdentityBase,
+                nodeTaskConfiguration: input.node?.taskConfiguration,
+                forwardRunTaskTrace,
+                runTaskDiagnostics: (input.runTaskDiagnostics ?? opts.runTaskDiagnostics),
+                nodeTimeoutMs: input.nodeTimeoutMs,
+            });
+            if (!postRes.ok) {
+                const err = new Error(postRes.response.error?.message ?? "ENGINE_POST_STRATEGY_FAILED");
+                err.code = postRes.response.error?.code ?? "ENGINE_POST_STRATEGY_FAILED";
+                err.nodeId = input.node?.id;
+                if (input.eventEmitter) {
+                    input.eventEmitter.emit(createNodeFailEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, {
+                        error: {
+                            message: err.message,
+                            code: err.code,
+                            ...(postRes.response.error != null ? { details: postRes.response.error } : {}),
+                        },
+                        memoryAfter: { jobMemory: input.jobMemory, taskMemory: input.taskMemory, execution: postExec },
+                        response: postRes.response,
+                    }, input.jobCorrelation));
+                }
+                markNodeLifecycleEmitted(err);
+                throw err;
+            }
+            updatedExecution = postExec;
+        }
+        // TRACE: Log execution object from response
+        if (process.env.DEBUG_EXECUTION_MEMORY === 'true' || process.env.DEBUG_OUTPUT_MAPPING === 'true') {
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: Node ${input.node?.id} - Processing response`);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: res.execution =`, JSON.stringify(res.execution, null, 2));
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: input.execution =`, JSON.stringify(input.execution, null, 2));
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: updatedExecution (before mapping) =`, JSON.stringify(updatedExecution, null, 2));
+        }
+        // Normalize task output for executionMapping.
+        // Normalize: create output object that includes both response output and parsed
+        // This allows path resolution to access both "output.parsed.shortAnswer" and "output.shortAnswer"
+        // If response.parsed exists, wrap it in { parsed: ... } structure for path resolution
+        const responseParsed = res.parsed;
+        // TRACE: Log response structure
+        if (process.env.DEBUG_OUTPUT_MAPPING === 'true' || process.env.DEBUG_EXECUTION_MEMORY === 'true') {
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: Node ${input.node?.id} - Response structure`);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: res.parsed =`, JSON.stringify(res.parsed, null, 2));
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: res.parsed type =`, typeof res.parsed);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: res.parsed keys =`, res.parsed && typeof res.parsed === 'object' ? Object.keys(res.parsed) : 'N/A');
+            if (res.parsed && typeof res.parsed === 'object') {
+                console.log(`[TRACE] ExellixGraphRuntime.executeNode: res.parsed.shortAnswer =`, res.parsed.shortAnswer);
+                console.log(`[TRACE] ExellixGraphRuntime.executeNode: res.parsed.fullAnswer =`, res.parsed.fullAnswer);
+            }
+        }
+        // Create output object similar to executeNode.ts - use parsed as the base, or create structure
+        const outputForMapping = res.parsed !== undefined
+            ? (typeof res.parsed === 'object' && res.parsed !== null && !Array.isArray(res.parsed))
+                ? { ...res.parsed, parsed: responseParsed || res.parsed }
+                : { parsed: responseParsed } // Wrap parsed in object structure for path resolution
+            : undefined;
+        // TRACE: Log outputForMapping structure
+        if (process.env.DEBUG_OUTPUT_MAPPING === 'true' || process.env.DEBUG_EXECUTION_MEMORY === 'true') {
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: outputForMapping structure`);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: outputForMapping =`, JSON.stringify(outputForMapping, null, 2));
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: outputForMapping.parsed =`, JSON.stringify(outputForMapping?.parsed, null, 2));
+            if (outputForMapping?.parsed) {
+                console.log(`[TRACE] ExellixGraphRuntime.executeNode: outputForMapping.parsed.shortAnswer =`, outputForMapping.parsed.shortAnswer);
+                console.log(`[TRACE] ExellixGraphRuntime.executeNode: outputForMapping.parsed.fullAnswer =`, outputForMapping.parsed.fullAnswer);
+            }
+        }
+        updatedExecution = applyTaskResultMapping({
+            targetMemory: updatedExecution,
+            mapping: input.node?.executionMapping,
+            outputForMapping,
+            node: input.node,
+            variables: jobVariables,
+        });
+        const updatedOutputsMemory = isPlainRecord(input.outputsMemory) ? input.outputsMemory : {};
+        // TRACE: Log final execution state before returning
+        if (process.env.DEBUG_EXECUTION_MEMORY === 'true' || process.env.DEBUG_OUTPUT_MAPPING === 'true') {
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: Node ${input.node?.id} - Final execution state before returning`);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: updatedExecution =`, JSON.stringify(updatedExecution, null, 2));
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: updatedExecution type =`, typeof updatedExecution);
+            console.log(`[TRACE] ExellixGraphRuntime.executeNode: updatedExecution is undefined?`, updatedExecution === undefined);
+        }
+        const resMetaOk = res.metadata ?? res.meta;
+        const taskRunLogOk = [...retryOutcome.syntheticRunLog, ...extractTaskRunLogFromMetadata(resMetaOk)];
+        const logxerCorrelationIdOk = extractLogxerCorrelationFromMetadata(resMetaOk);
+        const aiTasksObservability = buildAiTasksObservabilityRecord(res, retryOutcome.lastRequest);
+        if (retryOutcome.attempts.length) {
+            aiTasksObservability.attempts = retryOutcome.attempts;
+        }
+        if (readiness.warnings.length > 0) {
+            aiTasksObservability.mainReadinessWarnings = readiness.warnings;
+            aiTasksObservability.mainReadiness = readiness;
+        }
+        const taskOutput = {
+            rawContent: res.rawContent ?? res.rawText,
+            parsed: res.parsed,
+        };
+        if (input.eventEmitter) {
+            input.eventEmitter.emit(createNodeCompleteEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, {
+                output: taskOutput,
+                memoryAfter: {
+                    jobMemory: input.jobMemory,
+                    taskMemory: input.taskMemory,
+                    execution: updatedExecution,
+                    outputsMemory: updatedOutputsMemory,
+                },
+            }, input.jobCorrelation));
+        }
+        return {
+            nodeId: input.node.id,
+            skillKey,
+            output: taskOutput,
+            execution: updatedExecution, // Return execution object so it can be accumulated
+            outputsMemory: updatedOutputsMemory,
+            request: req,
+            ...(taskRunLogOk.length ? { taskRunLog: taskRunLogOk } : {}),
+            ...(logxerCorrelationIdOk ? { logxerCorrelationId: logxerCorrelationIdOk } : {}),
+            aiTasksObservability,
+        };
+    }
+    async function executeGraph(input) {
+        const { model: suppliedGraph, runtime } = input;
+        const { graph } = migrateLegacyGraphResponse(suppliedGraph);
+        const merged = mergeExellixGraphRuntimeInvocation(runtime, opts);
+        const failFast = merged.failFast;
+        const debugMode = runtime.debugMode === true;
+        const eventEmitter = runtime.eventEmitter ?? opts.eventEmitter;
+        const jobId = assertHostJobId(runtime.jobId);
+        const graphTaskId = newGraphRunTaskId();
+        const job = { ...(runtime.job ?? {}), id: jobId, jobId };
+        if (runtime.mode === "backward" && !runtime.goalNodeId) {
+            const err = new Error(`BACKWARD_GOAL_REQUIRED: mode=backward requires goalNodeId`);
+            err.code = "BACKWARD_GOAL_REQUIRED";
+            throw err;
+        }
+        const resolvedGraphIdRaw = graph?.id;
+        if (resolvedGraphIdRaw == null || resolvedGraphIdRaw === '') {
+            throw new Error('GRAPH_ID_REQUIRED: execution request model must include a non-empty id');
+        }
+        const resolvedGraphId = String(resolvedGraphIdRaw);
+        assertCanonicalGraphDocument(graph, { jobId, graphId: resolvedGraphId });
+        let runxClient = opts.runx;
+        if (graphNeedsRunxClient(graph, merged.modelConfig)) {
+            if (!runxClient) {
+                if (!opts.runxCreateOptions) {
+                    const err = new Error("RUNX_REQUIRED: graph uses jsConditionFunction, aiCondition, or conditional modelConfig cases that require runx. Pass runx or runxCreateOptions on createExellixGraphRuntime.");
+                    err.code = "RUNX_REQUIRED";
+                    throw err;
+                }
+                runxClient = await createRunx(opts.runxCreateOptions);
+                await runxClient.bootstrap();
+                await runxClient.reload();
+            }
+        }
+        const graphAudit = {
+            source: 'model',
+            contentSha256: computeGraphDocumentContentSha256(suppliedGraph),
+        };
+        const graphDocumentModel = mergeGraphDocumentModel(graph);
+        const graphExecution = graphDocumentModel.graphExecution;
+        const nodeResponseKeys = resolveNodeResponseKeys(graphExecution);
+        const coreObjectiveConfig = resolveCoreObjectiveConfig(graphExecution);
+        setRuntimeObjectsLastJobId(merged.runtimeObjects, jobId);
+        const { finalizer } = validateGraphFinalizer(graph);
+        const engine = opts.engineFactory.create({
+            graph,
+            mode: runtime.mode,
+            goalNodeId: runtime.goalNodeId,
+            dimension: runtime.dimension,
+            initialState: runtime.initialState,
+            initialVariables: runtime.initialVariables,
+        });
+        const outputsByNodeId = {};
+        const stepsResponses = [];
+        const errors = [];
+        const finalizerNodeId = String(finalizer.id);
+        const jobCorrelation = job?.jobType != null ? { jobType: job.jobType } : undefined;
+        // Pre-compute incoming-edge map for conditional-edge filtering of plan.nextNodes.
+        const rawEdges = Array.isArray(graph.edges) ? graph.edges : [];
+        const hasConditionalEdges = rawEdges.some((e) => e && typeof e === "object" && e.when != null);
+        const incomingByTo = new Map();
+        if (hasConditionalEdges) {
+            for (const e of rawEdges) {
+                if (!e || typeof e !== "object")
+                    continue;
+                const to = e.to;
+                if (typeof to !== "string" || to.length === 0)
+                    continue;
+                const list = incomingByTo.get(to) ?? [];
+                list.push(e);
+                incomingByTo.set(to, list);
+            }
+        }
+        const graphRunStartedAt = Date.now();
+        const taskRunLogBuffer = [];
+        let logxerCorrelationIdLast;
+        function appendTaskRunLogFromError(e) {
+            if (Array.isArray(e?.taskRunLog))
+                taskRunLogBuffer.push(...e.taskRunLog);
+            if (typeof e?.logxerCorrelationId === "string" && e.logxerCorrelationId.length > 0) {
+                logxerCorrelationIdLast = e.logxerCorrelationId;
+            }
+        }
+        function finalizeGraphPayload(graphStatus) {
+            const lim = resolveRunLogLimits({
+                runLogMode: merged.runLogMode,
+                maxRunLogEntries: merged.maxRunLogEntries,
+                maxRunLogDataJsonChars: merged.maxRunLogDataJsonChars,
+                defaults: {},
+            });
+            const built = buildRunLog({
+                ...lim,
+                jobId,
+                taskId: graphTaskId,
+                graphId: resolvedGraphId,
+                graphRunStartedAt,
+                graphStatus,
+                execution: currentExecution,
+                taskAppendedEntries: taskRunLogBuffer,
+                logxerCorrelationId: logxerCorrelationIdLast,
+            });
+            return {
+                execution: currentExecution,
+                outputsMemory: currentOutputsMemory,
+                ...built,
+            };
+        }
+        // Track current memory and execution state (will be updated as nodes execute)
+        let currentJobMemory = runtime.jobMemory || {};
+        let currentTaskMemory = runtime.taskMemory;
+        let currentExecution = normalizeRuntimeExecutionMemory(runtime);
+        let currentOutputsMemory = normalizeRuntimeOutputsMemory(runtime);
+        if (!currentExecution._trace)
+            currentExecution._trace = { nodes: {} };
+        if (!currentExecution._trace.nodes)
+            currentExecution._trace.nodes = {};
+        const jobKnowledgePatch = await resolveKnowledgePatch({
+            refs: graph.jobKnowledge,
+            resolver: opts.resolveJobKnowledge,
+            context: { model: graph, runtime, graphId: resolvedGraphId, jobId, taskId: graphTaskId },
+        });
+        seedGraphRunExecutionState({
+            execution: currentExecution,
+            jobMemory: currentJobMemory,
+            job: runtime.job,
+        });
+        seedGraphVariableBucketsFromRuntime({
+            execution: currentExecution,
+            graph,
+            runtime,
+            job,
+        });
+        assertFinalizerRequiredReadsResolvable({
+            graph,
+            finalizer,
+            executionMemory: currentExecution,
+            outputsMemory: currentOutputsMemory,
+        });
+        const coreObjectiveValue = resolveCoreObjectiveValue({
+            sourcePath: coreObjectiveConfig.sourcePath,
+            execution: currentExecution,
+            jobMemory: currentJobMemory,
+            taskMemory: currentTaskMemory,
+            job,
+        });
+        if (eventEmitter) {
+            eventEmitter.emit(createGraphStartEvent(jobId, resolvedGraphId, graphTaskId, {
+                agentId: job?.agentId,
+                input: {
+                    variables: runtime.variables,
+                    jobMemory: currentJobMemory,
+                    taskMemory: currentTaskMemory,
+                },
+                ...(jobCorrelation ?? {}),
+            }));
+        }
+        function buildDebugTrace() {
+            if (!debugMode)
+                return undefined;
+            const traceNodes = (currentExecution?._trace?.nodes ?? {});
+            const out = [];
+            for (const [nodeId, entry] of Object.entries(traceNodes)) {
+                if (entry == null || typeof entry !== "object")
+                    continue;
+                out.push({ nodeId, ...entry });
+            }
+            // Stable order by startedAt, then by nodeId.
+            out.sort((a, b) => (a.startedAt ?? 0) - (b.startedAt ?? 0) || a.nodeId.localeCompare(b.nodeId));
+            return { nodes: out };
+        }
+        function appendStepResponse(node, output) {
+            if (node?.type === "finalizer")
+                return;
+            const nodeResponse = unwrapNodeResponse(output);
+            stepsResponses.push({
+                [coreObjectiveConfig.propertyName]: coreObjectiveValue,
+                [nodeResponseKeys.singular]: nodeResponse,
+            });
+        }
+        function buildFinalOutputFromGraphResponse() {
+            const executionMemoryForResponse = isPlainRecord(currentExecution)
+                ? structuredClone(currentExecution)
+                : currentExecution;
+            return applyGraphResponseDefinition({
+                response: graph.response,
+                context: {
+                    graph,
+                    executionMemory: executionMemoryForResponse,
+                    outputsMemory: isPlainRecord(currentOutputsMemory)
+                        ? structuredClone(currentOutputsMemory)
+                        : currentOutputsMemory,
+                    outputsByNodeId,
+                    stepsResponses,
+                },
+            });
+        }
+        const playgroundReporter = runtime.playgroundReporter ?? opts.playgroundReporter;
+        if (playgroundReporter) {
+            playgroundReporter.step("graph:start", {
+                jobId,
+                taskId: graphTaskId,
+                graphId: resolvedGraphId,
+                executionKeys: Object.keys(currentExecution),
+                variablesKeys: runtime.variables != null ? Object.keys(runtime.variables) : [],
+                executionExcerpt: typeof currentExecution === "object" && currentExecution !== null
+                    ? JSON.stringify(currentExecution, null, 2).slice(0, 500)
+                    : undefined,
+                ...(merged.playgroundMeta != null && typeof merged.playgroundMeta === "object"
+                    ? merged.playgroundMeta
+                    : {}),
+            });
+            if (merged.runtimeObjects) {
+                playgroundReporter.step("graph:observability", summarizeRuntimeObjectsForPlayground(merged.runtimeObjects));
+            }
+        }
+        // TRACE: Log initial execution state
+        if (process.env.DEBUG_EXECUTION_MEMORY === 'true') {
+            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: Initial execution state`);
+            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: runtime.executionMemory =`, JSON.stringify(runtime.executionMemory, null, 2));
+            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: currentExecution =`, JSON.stringify(currentExecution, null, 2));
+            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: currentExecution type =`, typeof currentExecution);
+            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: currentExecution is undefined?`, currentExecution === undefined);
+            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: currentExecution is null?`, currentExecution === null);
+        }
+        function recordForStructuredDataFilters() {
+            return isPlainRecord(currentExecution?.input)
+                ? currentExecution.input
+                : {};
+        }
+        const graphEntryForGate = graphDocumentModel.graphEntry;
+        if (graphEntryForGate?.dataFilters !== undefined) {
+            const entryEv = evaluateStructuredDataFilters(graphEntryForGate.dataFilters, recordForStructuredDataFilters());
+            if (entryEv.status === "unsupported_shape" ||
+                (entryEv.status === "evaluated" && !entryEv.ok)) {
+                const err = new Error("GRAPH_ENTRY_DATA_FILTERS_REJECTED: metadata.graphEntry.dataFilters (structured) did not accept runtime.executionMemory.input");
+                err.code = ExellixGraphErrorCode.GRAPH_ENTRY_DATA_FILTERS_REJECTED;
+                const finalOutput = buildFinalOutputFromGraphResponse();
+                const result = {
+                    jobId,
+                    taskId: graphTaskId,
+                    graphId: resolvedGraphId,
+                    status: "failed",
+                    outputsByNodeId,
+                    stepsResponses,
+                    engineSnapshot: engine.snapshot(),
+                    ...(finalOutput !== undefined ? { finalOutput } : {}),
+                    errors: [...errors, { error: err }],
+                    graphAudit,
+                    ...finalizeGraphPayload("failed"),
+                };
+                const debug = buildDebugTrace();
+                if (debug)
+                    result.debug = debug;
+                if (eventEmitter) {
+                    eventEmitter.emit(createGraphFailEvent(jobId, resolvedGraphId, graphTaskId, err, {
+                        finalMemory: { jobMemory: currentJobMemory, taskMemory: currentTaskMemory, execution: currentExecution, outputsMemory: currentOutputsMemory },
+                        ...(jobCorrelation ?? {}),
+                    }));
+                }
+                return result;
+            }
+        }
+        while (true) {
+            const plan = engine.plan();
+            if (plan.status === "completed") {
+                const graphStatus = errors.length ? "failed" : "completed";
+                const finalOutput = buildFinalOutputFromGraphResponse();
+                const result = {
+                    jobId,
+                    taskId: graphTaskId,
+                    graphId: resolvedGraphId,
+                    status: graphStatus,
+                    outputsByNodeId,
+                    stepsResponses,
+                    engineSnapshot: engine.snapshot(),
+                    ...(finalOutput !== undefined ? { finalOutput } : {}),
+                    ...(errors.length === 0 ? { finalizerNodeId, finalizerType: finalizer.finalizerType } : {}),
+                    errors: errors.length ? errors : undefined,
+                    graphAudit,
+                    ...finalizeGraphPayload(graphStatus),
+                };
+                const debug = buildDebugTrace();
+                if (debug)
+                    result.debug = debug;
+                if (eventEmitter) {
+                    if (graphStatus === "completed") {
+                        eventEmitter.emit(createGraphCompleteEvent(jobId, resolvedGraphId, graphTaskId, {
+                            output: finalOutput,
+                            nodesExecuted: Object.keys(outputsByNodeId).length,
+                            finalMemory: { jobMemory: currentJobMemory, taskMemory: currentTaskMemory, execution: currentExecution, outputsMemory: currentOutputsMemory },
+                            ...(jobCorrelation ?? {}),
+                        }));
+                    }
+                    else {
+                        eventEmitter.emit(createGraphFailEvent(jobId, resolvedGraphId, graphTaskId, errors[0]?.error, {
+                            finalMemory: { jobMemory: currentJobMemory, taskMemory: currentTaskMemory, execution: currentExecution, outputsMemory: currentOutputsMemory },
+                            ...(jobCorrelation ?? {}),
+                        }));
+                    }
+                }
+                return result;
+            }
+            if (plan.status !== "continue") {
+                const err = new Error(`GRAPH_BLOCKED: status=${plan.status}`);
+                err.code = "GRAPH_BLOCKED";
+                const finalOutput = buildFinalOutputFromGraphResponse();
+                const result = {
+                    jobId,
+                    taskId: graphTaskId,
+                    graphId: resolvedGraphId,
+                    status: "failed",
+                    outputsByNodeId,
+                    stepsResponses,
+                    engineSnapshot: engine.snapshot(),
+                    ...(finalOutput !== undefined ? { finalOutput } : {}),
+                    errors: [...errors, { error: err }],
+                    graphAudit,
+                    ...finalizeGraphPayload("failed"),
+                };
+                const debug = buildDebugTrace();
+                if (debug)
+                    result.debug = debug;
+                if (eventEmitter) {
+                    eventEmitter.emit(createGraphFailEvent(jobId, resolvedGraphId, graphTaskId, err, {
+                        finalMemory: { jobMemory: currentJobMemory, taskMemory: currentTaskMemory, execution: currentExecution, outputsMemory: currentOutputsMemory },
+                        ...(jobCorrelation ?? {}),
+                    }));
+                }
+                return result;
+            }
+            let runnableNodes = plan.nextNodes ?? [];
+            // Conditional edge filtering: a node with incoming edges that are *all* conditional must
+            // have at least one incoming edge whose `when` evaluates true to be runnable this round.
+            // Roots and nodes with at least one unconditional incoming edge always pass through.
+            if (hasConditionalEdges && runnableNodes.length > 0) {
+                const planningContextBase = {
+                    executionMemory: currentExecution,
+                    jobMemory: currentJobMemory,
+                    taskMemory: currentTaskMemory,
+                };
+                runnableNodes = runnableNodes.filter((n) => {
+                    const id = n?.id;
+                    if (typeof id !== "string" || id.length === 0)
+                        return true;
+                    const incoming = incomingByTo.get(id) ?? [];
+                    if (incoming.length === 0)
+                        return true;
+                    const hasUnconditional = incoming.some((e) => e?.when == null);
+                    if (hasUnconditional)
+                        return true;
+                    const planningContext = buildPredicateEvalContextForNode({
+                        executionMemory: currentExecution,
+                        jobMemory: currentJobMemory,
+                        taskMemory: currentTaskMemory,
+                        node: n,
+                        runtimeTaskVariables: runtime.taskVariables,
+                    });
+                    return incoming.some((e) => evaluateGraphPredicate(e.when, planningContext));
+                });
+            }
+            const dataFiltersRecord = recordForStructuredDataFilters();
+            const conditionCtxBase = {
+                executionMemory: currentExecution,
+                jobMemory: currentJobMemory,
+                taskMemory: currentTaskMemory,
+                job,
+            };
+            const skippedByConditions = [];
+            const gatedRunnable = [];
+            for (const n of runnableNodes) {
+                if (n?.type === "finalizer") {
+                    gatedRunnable.push(n);
+                    continue;
+                }
+                const nodePredicateCtx = buildPredicateEvalContextForNode({
+                    executionMemory: currentExecution,
+                    jobMemory: currentJobMemory,
+                    taskMemory: currentTaskMemory,
+                    node: n,
+                    runtimeTaskVariables: runtime.taskVariables,
+                });
+                const condEv = await evaluateTaskNodeConditions(n.conditions, { ...conditionCtxBase, ...nodePredicateCtx }, dataFiltersRecord, { runx: runxClient });
+                if (!condEv.ok) {
+                    skippedByConditions.push({
+                        node: n,
+                        skipReason: condEv.skipReason ?? "condition_eval_error",
+                    });
+                    continue;
+                }
+                gatedRunnable.push(n);
+            }
+            for (const { node, skipReason } of skippedByConditions) {
+                engine.commit({
+                    nodeId: String(node.id),
+                    output: { ...skippedByConditionsOutput(skipReason) },
+                });
+            }
+            runnableNodes = gatedRunnable;
+            const concurrency = resolveConcurrencyLimit({ graph, runnableNodes });
+            // Execute the current runnable batch in parallel (bounded)
+            // Important: we only call plan() again AFTER all commits from this batch land.
+            let batchHadFailFastError = false;
+            await runPool(runnableNodes, concurrency, async (node) => {
+                // If failFast was triggered, don't schedule more work (runPool also stops scheduling)
+                if (batchHadFailFastError)
+                    return;
+                const executionBaseForNode = cloneJsonLike(currentExecution);
+                const executionForNode = cloneJsonLike(executionBaseForNode);
+                const outputsBaseForNode = cloneJsonLike(currentOutputsMemory);
+                const outputsForNode = cloneJsonLike(outputsBaseForNode);
+                // TRACE: Log execution before passing to node
+                if (process.env.DEBUG_EXECUTION_MEMORY === 'true') {
+                    console.log(`[TRACE] ExellixGraphRuntime.executeGraph: About to execute node ${node.id}`);
+                    console.log(`[TRACE] ExellixGraphRuntime.executeGraph: executionForNode =`, JSON.stringify(executionForNode, null, 2));
+                    console.log(`[TRACE] ExellixGraphRuntime.executeGraph: executionForNode type =`, typeof executionForNode);
+                    console.log(`[TRACE] ExellixGraphRuntime.executeGraph: executionForNode is undefined?`, executionForNode === undefined);
+                    console.log(`[TRACE] ExellixGraphRuntime.executeGraph: executionForNode is null?`, executionForNode === null);
+                    if (executionForNode && typeof executionForNode === 'object') {
+                        console.log(`[TRACE] ExellixGraphRuntime.executeGraph: executionForNode keys =`, Object.keys(executionForNode));
+                    }
+                }
+                try {
+                    const isTaskNodeForKnowledge = node?.type !== "finalizer";
+                    const taskKnowledgePatch = await resolveKnowledgePatch({
+                        refs: isTaskNodeForKnowledge
+                            ? (Array.isArray(node.taskKnowledge) ? node.taskKnowledge : [])
+                            : undefined,
+                        resolver: opts.resolveTaskKnowledge,
+                        context: { model: graph, runtime, graphId: resolvedGraphId, jobId, taskId: graphTaskId, node: node },
+                    });
+                    const nodeTaskMemory = isPlainRecord(currentTaskMemory) ? { ...currentTaskMemory } : currentTaskMemory;
+                    const runtimeNodeConfig = readRuntimeNodeConfig(merged.nodes, typeof node.id === "string" ? node.id : undefined);
+                    const effectiveModelConfig = await resolveModelConfigForNode({
+                        runtimeNodeConfig,
+                        nodeModelConfig: node.taskConfiguration?.modelConfig,
+                        runtimeModelConfig: merged.modelConfig,
+                        graphModelConfig: graph.modelConfig,
+                        runtimeAliasConfig: merged.aliasConfig,
+                        conditionCtx: buildPredicateEvalContextForNode({
+                            executionMemory: currentExecution,
+                            jobMemory: currentJobMemory,
+                            taskMemory: currentTaskMemory,
+                            node: node,
+                            runtimeTaskVariables: runtime.taskVariables,
+                        }),
+                        executionInput: dataFiltersRecord,
+                        runx: runxClient,
+                    });
+                    const r = await executeNode({
+                        graphId: resolvedGraphId,
+                        graph,
+                        graphRunTaskId: graphTaskId,
+                        node,
+                        job,
+                        jobMemory: currentJobMemory,
+                        taskMemory: nodeTaskMemory,
+                        jobKnowledgePatch,
+                        taskKnowledgePatch,
+                        execution: executionForNode,
+                        outputsMemory: outputsForNode,
+                        variables: runtime.variables,
+                        taskVariables: runtime.taskVariables,
+                        modelConfig: effectiveModelConfig,
+                        llmCall: merged.llmCall,
+                        runTaskIdentity: merged.runTaskIdentity,
+                        runTaskExecutionMode: merged.runTaskExecutionMode,
+                        runTaskDiagnostics: merged.runTaskDiagnostics,
+                        graphExecutionPipeline: merged.executionPipeline,
+                        skillKeyResolution: merged.skillKeyResolution,
+                        nodeTimeoutMs: merged.nodeTimeoutMs,
+                        clearSynthesizedContextPerNode: merged.clearSynthesizedContextPerNode,
+                        stepRetryPolicy: merged.stepRetryPolicy,
+                        mainReadinessPolicy: merged.mainReadinessPolicy,
+                        eventEmitter,
+                        jobCorrelation,
+                    });
+                    outputsByNodeId[r.nodeId] = r.output;
+                    appendStepResponse(node, r.output);
+                    engine.commit({ nodeId: r.nodeId, output: r.output });
+                    const trl = r.taskRunLog;
+                    if (trl?.length)
+                        taskRunLogBuffer.push(...trl);
+                    const lcid = r.logxerCorrelationId;
+                    if (typeof lcid === "string" && lcid.length > 0)
+                        logxerCorrelationIdLast = lcid;
+                    // Update execution object from node result if available.
+                    // Task nodes write execution state through executionMapping.
+                    if (r.execution !== undefined) {
+                        // TRACE: Log execution object update
+                        if (process.env.DEBUG_EXECUTION_MEMORY === 'true') {
+                            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: Node ${node.id} returned execution object`);
+                            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: r.execution =`, JSON.stringify(r.execution, null, 2));
+                            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: r.execution type =`, typeof r.execution);
+                            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: r.execution keys =`, r.execution && typeof r.execution === 'object' ? Object.keys(r.execution) : 'N/A');
+                        }
+                        currentExecution = mergeExecutionUpdate(currentExecution, r.execution, executionBaseForNode);
+                        // TRACE: Log updated currentExecution
+                        if (process.env.DEBUG_EXECUTION_MEMORY === 'true') {
+                            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: Updated currentExecution =`, JSON.stringify(currentExecution, null, 2));
+                        }
+                    }
+                    else {
+                        // TRACE: Log when execution is not returned
+                        if (process.env.DEBUG_EXECUTION_MEMORY === 'true') {
+                            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: Node ${node.id} did NOT return execution object`);
+                            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: r.execution =`, r.execution);
+                            console.log(`[TRACE] ExellixGraphRuntime.executeGraph: currentExecution remains =`, JSON.stringify(currentExecution, null, 2));
+                        }
+                    }
+                    if (r.outputsMemory !== undefined) {
+                        currentOutputsMemory = mergeExecutionUpdate(currentOutputsMemory, r.outputsMemory, outputsBaseForNode);
+                    }
+                    // Note: We don't modify jobMemory or taskMemory here
+                    // They are set before the job starts and we just pass them through
+                }
+                catch (e) {
+                    appendTaskRunLogFromError(e);
+                    errors.push({ nodeId: node?.id, error: e });
+                    engine.commit({ nodeId: node?.id, error: e });
+                    if (eventEmitter && !wasNodeLifecycleEmitted(e)) {
+                        eventEmitter.emit(createNodeFailEvent(jobId, resolvedGraphId, graphTaskId, node, String(e?.skillKey ?? ""), {
+                            error: { code: e?.code, message: e?.message, stack: e?.stack },
+                            memoryAfter: { jobMemory: currentJobMemory, taskMemory: currentTaskMemory, execution: currentExecution, outputsMemory: currentOutputsMemory },
+                            response: undefined,
+                        }, jobCorrelation));
+                    }
+                    if (failFast) {
+                        batchHadFailFastError = true;
+                        // Throw to stop scheduling new nodes in runPool
+                        throw e;
+                    }
+                }
+            }, { failFast }).catch((e) => {
+                // failFast path: we intentionally end early after stopping scheduling
+                // (in-flight nodes may still finish; JS won't cancel them).
+                if (!failFast)
+                    throw e;
+            });
+            if (failFast && errors.length) {
+                const finalOutput = buildFinalOutputFromGraphResponse();
+                const result = {
+                    jobId,
+                    taskId: graphTaskId,
+                    graphId: resolvedGraphId,
+                    status: "failed",
+                    outputsByNodeId,
+                    stepsResponses,
+                    engineSnapshot: engine.snapshot(),
+                    ...(finalOutput !== undefined ? { finalOutput } : {}),
+                    errors,
+                    graphAudit,
+                    ...finalizeGraphPayload("failed"),
+                };
+                const debug = buildDebugTrace();
+                if (debug)
+                    result.debug = debug;
+                if (eventEmitter) {
+                    eventEmitter.emit(createGraphFailEvent(jobId, resolvedGraphId, graphTaskId, errors[0]?.error, {
+                        finalMemory: { jobMemory: currentJobMemory, taskMemory: currentTaskMemory, execution: currentExecution, outputsMemory: currentOutputsMemory },
+                        ...(jobCorrelation ?? {}),
+                    }));
+                }
+                return result;
+            }
+        }
+    }
+    return {
+        executeGraph,
+        executeNode, // exported for direct single-node test if you want
+    };
+}