@exellix/graph-engine 7.2.9 → 7.2.13

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -24,6 +24,7 @@ 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 { DebugLogAbstract, bindGraphEngineRunLogxer, clearGraphEngineRunLogxer, createGraphEngineLogxer, ensureGraphEngineLogxerOnRuntimeObjects, logGraphEngineErrorCode, patchGraphNodeLogContext, runGraphWithLogContext, traceExecutionMemory, } from "./graphEngineLogxer.js";
 import { assertHostJobId, newGraphRunTaskId } from "./graphRunIdentity.js";
 import { resolveTaskKey } from "./resolveTaskKey.js";
 import { buildPredicateEvalContextForNode, mirrorTaskVariablesOnExecution, readExecutionVariableBuckets, seedGraphVariableBucketsFromRuntime, } from "./variables.js";
@@ -611,9 +612,11 @@ export function createExellixGraphRuntime(opts) {
             ? toRunTaskModelConfigForPhase(effectiveModelConfig, 'main')
             : undefined;
         // 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));
-        }
+        traceExecutionMemory('executeNode', 'Node execution object before runTask', {
+            nodeId: input.node?.id,
+            execution: input.execution,
+        });
+        patchGraphNodeLogContext(String(input.node?.id ?? ''));
         let execution = input.execution;
         if (execution == null || typeof execution !== "object")
             execution = {};
@@ -855,18 +858,18 @@ export function createExellixGraphRuntime(opts) {
             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));
-            }
-        }
+        traceExecutionMemory('executeNode', 'runTask request built', {
+            nodeId: input.node?.id,
+            executionMemory: req.executionMemory,
+            executionMemoryType: typeof req.executionMemory,
+            executionMemoryIsUndefined: req.executionMemory === undefined,
+            executionMemoryIsNull: req.executionMemory === null,
+            hasExecutionMemoryProperty: 'executionMemory' in req,
+            requestKeys: Object.keys(req),
+            executionMemoryKeys: req.executionMemory && typeof req.executionMemory === 'object'
+                ? Object.keys(req.executionMemory)
+                : undefined,
+        });
         let res;
         const nodeTimeoutMs = input.nodeTimeoutMs;
         const stepRetryPolicyResolved = resolveStepRetryPolicy(input.stepRetryPolicy ?? opts.stepRetryPolicy, input.node);
@@ -1047,28 +1050,25 @@ export function createExellixGraphRuntime(opts) {
             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));
-        }
+        traceExecutionMemory('executeNode', 'Processing runTask response', {
+            nodeId: input.node?.id,
+            responseExecution: res.execution,
+            inputExecution: input.execution,
+            updatedExecutionBeforeMapping: updatedExecution,
+        });
         // 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);
-            }
-        }
+        traceExecutionMemory('executeNode', 'runTask response structure', {
+            nodeId: input.node?.id,
+            parsed: res.parsed,
+            parsedType: typeof res.parsed,
+            parsedKeys: res.parsed && typeof res.parsed === 'object' ? Object.keys(res.parsed) : undefined,
+            parsedShortAnswer: res.parsed && typeof res.parsed === 'object' ? res.parsed.shortAnswer : undefined,
+            parsedFullAnswer: res.parsed && typeof res.parsed === 'object' ? res.parsed.fullAnswer : undefined,
+        });
         // 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))
@@ -1076,15 +1076,13 @@ export function createExellixGraphRuntime(opts) {
                 : { 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);
-            }
-        }
+        traceExecutionMemory('executeNode', 'outputForMapping structure', {
+            nodeId: input.node?.id,
+            outputForMapping,
+            outputForMappingParsed: outputForMapping?.parsed,
+            outputForMappingParsedShortAnswer: outputForMapping?.parsed?.shortAnswer,
+            outputForMappingParsedFullAnswer: outputForMapping?.parsed?.fullAnswer,
+        });
         updatedExecution = applyTaskResultMapping({
             targetMemory: updatedExecution,
             mapping: input.node?.executionMapping,
@@ -1094,12 +1092,12 @@ export function createExellixGraphRuntime(opts) {
         });
         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);
-        }
+        traceExecutionMemory('executeNode', 'Final execution state before returning', {
+            nodeId: input.node?.id,
+            updatedExecution,
+            updatedExecutionType: typeof updatedExecution,
+            updatedExecutionIsUndefined: updatedExecution === undefined,
+        });
         const resMetaOk = res.metadata ?? res.meta;
         const taskRunLogOk = [...retryOutcome.syntheticRunLog, ...extractTaskRunLogFromMetadata(resMetaOk)];
         const logxerCorrelationIdOk = extractLogxerCorrelationFromMetadata(resMetaOk);
@@ -1158,553 +1156,572 @@ export function createExellixGraphRuntime(opts) {
             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;
+        const runLogxer = createGraphEngineLogxer({ logging: merged.logging });
+        return runGraphWithLogContext({ jobId, taskId: graphTaskId, graphId: resolvedGraphId, runId: graphTaskId }, async () => {
+            bindGraphEngineRunLogxer(runLogxer);
+            try {
+                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();
+                    }
                 }
-                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 graphAudit = {
+                    source: 'model',
+                    contentSha256: computeGraphDocumentContentSha256(suppliedGraph),
                 };
-                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,
+                const graphDocumentModel = mergeGraphDocumentModel(graph);
+                const graphExecution = graphDocumentModel.graphExecution;
+                const nodeResponseKeys = resolveNodeResponseKeys(graphExecution);
+                const coreObjectiveConfig = resolveCoreObjectiveConfig(graphExecution);
+                setRuntimeObjectsLastJobId(merged.runtimeObjects, jobId);
+                ensureGraphEngineLogxerOnRuntimeObjects(merged.runtimeObjects, runLogxer);
+                runLogxer.info("Graph run started", {
                     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 ?? {}),
-                        }));
+                    debugKind: DebugLogAbstract.EVENT,
+                });
+                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);
                     }
-                    else {
-                        eventEmitter.emit(createGraphFailEvent(jobId, resolvedGraphId, graphTaskId, errors[0]?.error, {
-                            finalMemory: { jobMemory: currentJobMemory, taskMemory: currentTaskMemory, execution: currentExecution, outputsMemory: currentOutputsMemory },
-                            ...(jobCorrelation ?? {}),
-                        }));
+                }
+                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;
                     }
                 }
-                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 ?? {}),
-                    }));
+                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,
+                    };
                 }
-                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,
+                // 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,
-                    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));
+                    job: runtime.job,
                 });
-            }
-            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({
+                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,
-                    node: n,
-                    runtimeTaskVariables: runtime.taskVariables,
+                    job,
                 });
-                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;
+                if (eventEmitter) {
+                    eventEmitter.emit(createGraphStartEvent(jobId, resolvedGraphId, graphTaskId, {
+                        agentId: job?.agentId,
+                        input: {
+                            variables: runtime.variables,
+                            jobMemory: currentJobMemory,
+                            taskMemory: currentTaskMemory,
+                        },
+                        ...(jobCorrelation ?? {}),
+                    }));
                 }
-                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));
+                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 };
                 }
-                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 },
+                function appendStepResponse(node, output) {
+                    if (node?.type === "finalizer")
+                        return;
+                    const nodeResponse = unwrapNodeResponse(output);
+                    stepsResponses.push({
+                        [coreObjectiveConfig.propertyName]: coreObjectiveValue,
+                        [nodeResponseKeys.singular]: nodeResponse,
                     });
-                    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,
-                        conditionCtx: buildPredicateEvalContextForNode({
-                            executionMemory: currentExecution,
-                            jobMemory: currentJobMemory,
-                            taskMemory: currentTaskMemory,
-                            node: node,
-                            runtimeTaskVariables: runtime.taskVariables,
-                        }),
-                        executionInput: dataFiltersRecord,
-                        runx: runxClient,
-                        graphId: resolvedGraphId,
-                        nodeId: typeof node.id === "string" ? node.id : String(node.id),
-                        jobId,
+                }
+                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 r = await executeNode({
+                }
+                const playgroundReporter = runtime.playgroundReporter ?? opts.playgroundReporter;
+                if (playgroundReporter) {
+                    playgroundReporter.step("graph:start", {
+                        jobId,
+                        taskId: graphTaskId,
                         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,
+                        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
+                            : {}),
                     });
-                    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');
+                    if (merged.runtimeObjects) {
+                        playgroundReporter.step("graph:observability", summarizeRuntimeObjectsForPlayground(merged.runtimeObjects));
+                    }
+                }
+                // TRACE: Log initial execution state
+                traceExecutionMemory('executeGraph', 'Initial execution state', {
+                    runtimeExecutionMemory: runtime.executionMemory,
+                    currentExecution,
+                    currentExecutionType: typeof currentExecution,
+                    currentExecutionIsUndefined: currentExecution === undefined,
+                    currentExecutionIsNull: 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;
+                        logGraphEngineErrorCode(ExellixGraphErrorCode.GRAPH_ENTRY_DATA_FILTERS_REJECTED, err.message, {
+                            graphId: resolvedGraphId,
+                            jobId,
+                            taskId: graphTaskId,
+                            error: err,
+                        });
+                        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 ?? {}),
+                            }));
                         }
-                        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));
+                        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;
                     }
-                    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 (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;
                     }
-                    if (r.outputsMemory !== undefined) {
-                        currentOutputsMemory = mergeExecutionUpdate(currentOutputsMemory, r.outputsMemory, outputsBaseForNode);
+                    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));
+                        });
                     }
-                    // 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));
+                    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);
                     }
-                    if (failFast) {
-                        batchHadFailFastError = true;
-                        // Throw to stop scheduling new nodes in runPool
-                        throw e;
+                    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
+                        traceExecutionMemory('executeGraph', 'About to execute node', {
+                            nodeId: node.id,
+                            executionForNode,
+                            executionForNodeType: typeof executionForNode,
+                            executionForNodeIsUndefined: executionForNode === undefined,
+                            executionForNodeIsNull: executionForNode === null,
+                            executionForNodeKeys: executionForNode && typeof executionForNode === 'object'
+                                ? Object.keys(executionForNode)
+                                : undefined,
+                        });
+                        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,
+                                conditionCtx: buildPredicateEvalContextForNode({
+                                    executionMemory: currentExecution,
+                                    jobMemory: currentJobMemory,
+                                    taskMemory: currentTaskMemory,
+                                    node: node,
+                                    runtimeTaskVariables: runtime.taskVariables,
+                                }),
+                                executionInput: dataFiltersRecord,
+                                runx: runxClient,
+                                graphId: resolvedGraphId,
+                                nodeId: typeof node.id === "string" ? node.id : String(node.id),
+                                jobId,
+                            });
+                            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) {
+                                traceExecutionMemory('executeGraph', 'Node returned execution object', {
+                                    nodeId: node.id,
+                                    execution: r.execution,
+                                    executionType: typeof r.execution,
+                                    executionKeys: r.execution && typeof r.execution === 'object'
+                                        ? Object.keys(r.execution)
+                                        : undefined,
+                                });
+                                currentExecution = mergeExecutionUpdate(currentExecution, r.execution, executionBaseForNode);
+                                traceExecutionMemory('executeGraph', 'Updated currentExecution after node', {
+                                    nodeId: node.id,
+                                    currentExecution,
+                                });
+                            }
+                            else {
+                                traceExecutionMemory('executeGraph', 'Node did not return execution object', {
+                                    nodeId: node.id,
+                                    execution: r.execution,
+                                    currentExecution,
+                                });
+                            }
+                            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;
                     }
                 }
-            }, { 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;
             }
-        }
+            finally {
+                clearGraphEngineRunLogxer();
+            }
+        });
     }
     return {
         executeGraph,