@exellix/graph-engine 8.0.1 → 8.1.0

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -2,16 +2,12 @@ import { createExecutionTrace, appendExecutionEvent, validateExecutionTrace } fr
 import { preparePlanExecuteEntry, computePlanAudit } from "../plan/planExecuteEntry.js";
 import { embeddedGraphToExellixGraph } from "../plan/embeddedGraphToExellixGraph.js";
 import { graphAiModelConfigFromFinalizerPlan, graphAiModelConfigFromNodePlan } from "../plan/planModelConfig.js";
-import { executionPipelineFromNodePlan } from "../plan/planExecutionPipeline.js";
 import { applyNodePlanInvoke, finalizerPlanForId, nodePlanForId } from "../plan/applyNodePlanInvoke.js";
 import { evaluateDeferredNodeGate, evaluateDeferredEdgeGate, nodeDeferredGate, hasPlanConditionalEdges, evaluatePlanEntryGates, planNeedsRunx, } from "../plan/planDeferredGates.js";
 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";
@@ -26,11 +22,12 @@ import { createFinalizerError } from "./finalizers/errors.js";
 import { assertCanonicalGraphRuntimeObject } from "./validateCanonicalGraphRuntime.js";
 import { applyGraphResponseDefinition } from "./graphResponseMapping.js";
 import { buildAiTasksObservabilityRecord } from "./aiTasksObservability.js";
-import { buildMainLlmCallForRunTask, buildRunTaskIdentityEnvelope, shouldForwardRunTaskTraceMode, } from "./runTaskAugments.js";
+import { buildRunTaskIdentityEnvelope, 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 { runWithAiTasksStackLogging } from "@exellix/ai-tasks";
+import { nodePlanFromFinalizerPlan, patchNodePlanMainModelFromWire, resolveRunTaskNodePlan, } from "./runTaskNodePlan.js";
 import { assertHostJobId, newGraphRunTaskId } from "./graphRunIdentity.js";
 import { resolveTaskKey } from "./resolveTaskKey.js";
 import { buildPredicateEvalContextForNode, mirrorTaskVariablesOnExecution, readExecutionVariableBuckets, seedGraphVariableBucketsFromRuntime, } from "./variables.js";
@@ -366,7 +363,6 @@ export function createExellixGraphRuntime(opts) {
             });
         }
         const wireModelConfig = toRunTaskModelConfig(effectiveModelConfig);
-        const effectiveLlmCall = buildMainLlmCallForRunTask(wireModelConfig, input.node?.taskConfiguration?.llmCall);
         const forwardRunTaskTrace = shouldForwardRunTaskTraceMode({
             runTaskExecutionMode: input.runTaskExecutionMode ?? opts.runTaskExecutionMode,
         });
@@ -401,34 +397,43 @@ export function createExellixGraphRuntime(opts) {
                         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
+                        runTask: (req) => {
+                            const utilityKey = String(req.skillKey ??
+                                finalizer.config?.utilityKey ??
+                                "synthesize");
+                            return opts.tasksClient.runTask({
+                                ...req,
+                                agentId: input.job?.agentId ?? "standalone-agent",
+                                jobTypeId: resolveJobTypeId(input.job),
+                                taskTypeId: `exellix-graph-finalizer:${utilityKey}`,
+                                coreSkillId: String(finalizer.id),
+                                nodeId: String(finalizer.id),
+                                graphId: input.graphId,
+                                masterSkillId: input.graphId,
+                                masterSkillActivityId: `${lifecycleJobId}:${finalizer.id}`,
+                                input: req.input ?? {},
+                                skillKey: utilityKey,
+                                executionStrategies: [],
+                                nodePlan: nodePlanFromFinalizerPlan({
+                                    finalizerId: String(finalizer.id),
+                                    utilityKey,
+                                    finalizerPlan: input.finalizerPlan,
+                                }),
+                                identity: {
+                                    ...finalizerIdentity,
+                                    ...(req.identity &&
+                                        typeof req.identity === "object" &&
+                                        !Array.isArray(req.identity)
+                                        ? req.identity
+                                        : {}),
+                                    kind: "finalizer",
+                                },
+                                ...(forwardRunTaskTrace ? { executionMode: "trace" } : {}),
+                                ...((input.runTaskDiagnostics ?? opts.runTaskDiagnostics) != null
+                                    ? { diagnostics: input.runTaskDiagnostics ?? opts.runTaskDiagnostics }
                                     : {}),
-                                kind: "finalizer",
-                            },
-                            modelConfig: wireModelConfig,
-                            llmCall: effectiveLlmCall,
-                            executionStrategies: [],
-                            ...(forwardRunTaskTrace ? { executionMode: "trace" } : {}),
-                            ...((input.runTaskDiagnostics ?? opts.runTaskDiagnostics) != null
-                                ? { diagnostics: input.runTaskDiagnostics ?? opts.runTaskDiagnostics }
-                                : {}),
-                        }),
+                            });
+                        },
                         context: {
                             graphId: input.graphId,
                             jobId: input.job?.jobId,
@@ -658,34 +663,6 @@ export function createExellixGraphRuntime(opts) {
             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,
@@ -694,12 +671,6 @@ export function createExellixGraphRuntime(opts) {
         });
         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;
         const nodeBindings = resolveTaskNodeInputsForRunTask({
             node: input.node,
             execution: executionRec,
@@ -720,51 +691,22 @@ export function createExellixGraphRuntime(opts) {
         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,
-                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;
-            }
+        let runTaskNodePlan = resolveRunTaskNodePlan({
+            nodePlan: input.nodePlan,
+            skillKey,
+            nodeId: String(input.node.id),
+        });
+        if (!input.nodePlan) {
+            runTaskNodePlan = patchNodePlanMainModelFromWire(runTaskNodePlan, wireModelConfig);
         }
+        const startedAt = Date.now();
+        const hasSynthesizedContextPreStep = runTaskNodePlan.executionUnits.some((u) => u.unitKind === "externalPreUtility" || u.unitKind === "pipelinePhase");
+        const hasExistingSynthesizedContext = execution != null &&
+            typeof execution === "object" &&
+            execution.synthesizedContext != null;
+        const clearSynthForTask = input.clearSynthesizedContextPerNode === true &&
+            hasSynthesizedContextPreStep &&
+            hasExistingSynthesizedContext;
         const executionForTask = clearSynthForTask
             ? (() => {
                 const c = { ...executionRec };
@@ -830,7 +772,18 @@ export function createExellixGraphRuntime(opts) {
         }
         const runTaskJobMemory = mergeKnowledgePatchIntoRunTaskMemory(input.jobMemory, input.jobKnowledgePatch);
         const runTaskTaskMemory = mergeKnowledgePatchIntoRunTaskMemory(input.taskMemory, input.taskKnowledgePatch);
-        const metaStrats = input.node?.taskConfiguration?.executionStrategies;
+        const metaStrats = runTaskNodePlan.invokeContract?.pipeline &&
+            typeof runTaskNodePlan.invokeContract.pipeline === "object" &&
+            Array.isArray(runTaskNodePlan.invokeContract.pipeline.executionStrategies)
+            ? runTaskNodePlan.invokeContract.pipeline
+                .executionStrategies
+            : input.node?.taskConfiguration?.executionStrategies;
+        const outputValidationFromPlan = runTaskNodePlan.invokeContract?.validation &&
+            typeof runTaskNodePlan.invokeContract.validation === "object" &&
+            "aiTasksOutputValidation" in runTaskNodePlan.invokeContract.validation
+            ? runTaskNodePlan.invokeContract.validation
+                .aiTasksOutputValidation
+            : undefined;
         const req = buildAiTasksRunTaskRequest({
             skillKey,
             job: input.job,
@@ -847,19 +800,16 @@ export function createExellixGraphRuntime(opts) {
             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,
+            outputValidation: outputValidationFromPlan ??
+                (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: wireModelConfig,
-            llmCall: effectiveLlmCall,
             identity: buildRunTaskIdentityEnvelope({
                 base: runTaskIdentityBase,
                 nodeMeta: input.node?.taskConfiguration,
@@ -874,6 +824,8 @@ export function createExellixGraphRuntime(opts) {
             executionStrategies: Array.isArray(metaStrats) ? metaStrats : [],
             xynthesized: xynthesizedOutboundForNode(executionRec, String(input.node.id)),
             smartInput: input.node.smartInput,
+            nodePlan: runTaskNodePlan,
+            ...(input.executionTrace != null ? { executionTrace: input.executionTrace } : {}),
         });
         // TRACE: Validate request object before sending
         traceExecutionMemory('executeNode', 'runTask request built', {
@@ -1021,53 +973,6 @@ export function createExellixGraphRuntime(opts) {
         };
         // 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,
-                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
         traceExecutionMemory('executeNode', 'Processing runTask response', {
             nodeId: input.node?.id,
@@ -1649,12 +1554,14 @@ export function createExellixGraphRuntime(opts) {
                                 : nodePlanEntryResolved && node.type !== "finalizer"
                                     ? graphAiModelConfigFromNodePlan(nodePlanEntryResolved)
                                     : undefined;
-                            const nodeExecutionPipeline = nodePlanEntryResolved != null ? executionPipelineFromNodePlan(nodePlanEntryResolved) : undefined;
                             const r = await executeNode({
                                 graphId: resolvedGraphId,
                                 graph,
                                 graphRunTaskId: graphTaskId,
                                 node: taskNodeForExecute,
+                                nodePlan: nodePlanEntryResolved,
+                                finalizerPlan: finalizerPlanEntryResolved,
+                                executionTrace,
                                 job,
                                 jobMemory: currentJobMemory,
                                 taskMemory: nodeTaskMemory,
@@ -1668,7 +1575,6 @@ export function createExellixGraphRuntime(opts) {
                                 runTaskIdentity: merged.runTaskIdentity,
                                 runTaskExecutionMode: merged.runTaskExecutionMode,
                                 runTaskDiagnostics: merged.runTaskDiagnostics,
-                                graphExecutionPipeline: nodeExecutionPipeline ?? merged.executionPipeline,
                                 skillKeyResolution: merged.skillKeyResolution,
                                 nodeTimeoutMs: merged.nodeTimeoutMs,
                                 clearSynthesizedContextPerNode: merged.clearSynthesizedContextPerNode,

package/dist/src/runtime/aiTasksStrategyPhases.js

@@ -3,6 +3,7 @@ import { buildAiTasksRunTaskRequest } from './buildAiTasksRunTaskRequest.js';
 import { buildRunTaskIdentityEnvelope } from './runTaskAugments.js';
 import { runTaskResponseSucceeded } from './runTaskResponse.js';
 import { withTimeout } from './withTimeout.js';
+import { patchNodePlanMainModelFromWire, resolveRunTaskNodePlan } from './runTaskNodePlan.js';
 function nonEmptyStrategyKey(v) {
     return typeof v === 'string' && v.trim().length > 0;
 }
@@ -31,11 +32,15 @@ export async function runEngineAiTasksStrategyPhase(args) {
     const taskTypeIdOverride = args.phase === 'pre'
         ? `exellix-graph-xynthesis-pre:${args.parentSkillKey}`
         : `exellix-graph-xynthesis-post:${args.parentSkillKey}`;
+    const wireModelConfig = toRunTaskModelConfig(args.modelConfig);
+    const runTaskNodePlan = patchNodePlanMainModelFromWire(resolveRunTaskNodePlan({
+        skillKey: args.strategySkillKey,
+        nodeId: args.nodeId,
+    }), wireModelConfig);
     const req = buildAiTasksRunTaskRequest({
         skillKey: args.strategySkillKey,
         job: args.job,
         nodeId: args.nodeId,
-        taskConfiguration: undefined,
         graphId: args.graphId,
         taskId: args.taskId,
         runTaskJobId: args.runTaskJobId,
@@ -52,14 +57,13 @@ export async function runEngineAiTasksStrategyPhase(args) {
         executionMemory: args.execution,
         jobContext: args.jobContext,
         prevNodeId: args.prevNodeId,
-        executionPipeline: [{ phase: 'main', type: 'direct' }],
         executionStrategies: [],
-        modelConfig: toRunTaskModelConfig(args.modelConfig),
         identity,
         ...(args.forwardRunTaskTrace ? { executionMode: 'trace' } : {}),
         ...(args.runTaskDiagnostics != null && { diagnostics: args.runTaskDiagnostics }),
         taskKind: 'utility',
         taskTypeIdOverride,
+        nodePlan: runTaskNodePlan,
     });
     const run = () => args.aiTasks.runTask(req);
     const response = await (args.nodeTimeoutMs

package/dist/src/runtime/buildAiTasksRunTaskRequest.d.ts

@@ -7,11 +7,10 @@
  * v7 closed schema: no root `executionType`, `outputConstraints`, `question`, or `jobInput`.
  * Graph-engine forwards optional `inputs` (caller bag, as-is) separately from `input` (MAIN as-is + node bindings) — see `.docs/CR-input-and-inputs-dual-root.md`.
  */
-import type { LlmCallConfig, RunTaskRequest } from '@exellix/ai-tasks';
+import type { RunTaskRequest } from '@exellix/ai-tasks';
+import type { GraphExecutionTraceV2, NodeExecutionPlan } from '@x12i/graphenix-executable-contracts';
 import type { SmartInputConfig, XynthesizedMemory } from '../types/aiTasksDerivedTypes.js';
 import type { Job } from '../types/refs.js';
-import type { RunTaskModelConfigWire } from './graphAiModelConfig.js';
-import type { ExecutionStepOption } from '../types/options.js';
 import type { ResolvedNarrixWirePayload } from '../types/narrix.js';
 /** Request/metadata keys that must never carry provider API secrets (env-only). */
 export declare const FORBIDDEN_RUN_TASK_SECRET_KEYS: readonly ["openrouterApiKey", "OPENROUTER_API_KEY", "OPEN_ROUTER_KEY", "apiKey", "api_key", "openRouterApiKey"];
@@ -43,14 +42,9 @@ export type BuildAiTasksRunTaskRequestArgs = {
     executionMemory?: Record<string, unknown>;
     jobContext?: Record<string, unknown>;
     prevNodeId?: string;
-    executionPipeline?: ExecutionStepOption[];
-    includeContextInPrompt?: boolean;
     narrix?: ResolvedNarrixWirePayload;
     outputValidation?: RunTaskRequest['outputValidation'];
     diagnostics?: RunTaskRequest['diagnostics'];
-    /** Required on every `runTask` (@exellix/ai-tasks 8.4+). */
-    modelConfig: RunTaskModelConfigWire;
-    llmCall?: LlmCallConfig;
     identity?: Record<string, unknown>;
     executionMode?: 'default' | 'trace';
     taskKind?: RunTaskRequest['taskKind'];
@@ -65,6 +59,10 @@ export type BuildAiTasksRunTaskRequestArgs = {
     executionStrategies?: RunTaskRequest['executionStrategies'];
     xynthesized?: XynthesizedMemory;
     smartInput?: SmartInputConfig;
+    /** Frozen graphenix node plan — required for `@exellix/ai-tasks` ≥ 9 (`runTask` hot path). */
+    nodePlan: NodeExecutionPlan;
+    /** Optional graphenix v2 trace handle; ai-tasks appends unit / model invocation events. */
+    executionTrace?: GraphExecutionTraceV2;
 };
 export declare function resolveJobTypeId(job?: Job): string;
 export declare function resolveTaskTypeId(skillKey: string, nodeId: string, taskConfiguration?: Record<string, unknown>): string;

package/dist/src/runtime/buildAiTasksRunTaskRequest.js

@@ -1,4 +1,3 @@
-import { buildRunTaskTaskConfigurationForward } from './buildRunTaskTaskConfigurationForward.js';
 import { normalizeSmartInputConfigForRunTask } from './smartInputPaths.js';
 /** Request/metadata keys that must never carry provider API secrets (env-only). */
 export const FORBIDDEN_RUN_TASK_SECRET_KEYS = [
@@ -135,11 +134,12 @@ export function buildAiTasksRunTaskRequest(args) {
     const masterSkillActivityId = `${args.runTaskJobId}:${args.nodeId}`;
     const executionStrategies = args.executionStrategies ?? [];
     const metaPassthrough = extractRunTaskMetadataPassthrough(args.taskConfiguration);
-    const taskConfigurationForward = buildRunTaskTaskConfigurationForward(args.taskConfiguration);
     const smartInputForward = normalizeSmartInputConfigForRunTask(args.smartInput);
     const req = {
         ...metaPassthrough,
         skillKey: args.skillKey,
+        nodePlan: args.nodePlan,
+        ...(args.executionTrace != null ? { executionTrace: args.executionTrace } : {}),
         jobId: args.runTaskJobId,
         taskId: args.taskId,
         agentId,
@@ -162,13 +162,9 @@ export function buildAiTasksRunTaskRequest(args) {
         ...(args.executionMemory != null ? { executionMemory: args.executionMemory } : {}),
         ...(args.jobContext != null ? { jobContext: args.jobContext } : {}),
         ...(args.prevNodeId != null && args.prevNodeId !== '' ? { prevNodeId: args.prevNodeId } : {}),
-        ...(args.executionPipeline != null ? { executionPipeline: args.executionPipeline } : {}),
-        ...(args.includeContextInPrompt === true ? { includeContextInPrompt: true } : {}),
         ...(args.narrix != null ? { narrix: args.narrix } : {}),
         ...(args.outputValidation != null ? { outputValidation: args.outputValidation } : {}),
         ...(args.diagnostics != null ? { diagnostics: args.diagnostics } : {}),
-        modelConfig: args.modelConfig,
-        ...(args.llmCall != null ? { llmCall: args.llmCall } : {}),
         ...(args.identity != null ? { identity: args.identity } : {}),
         ...(args.executionMode != null ? { executionMode: args.executionMode } : {}),
         ...(args.taskKind != null ? { taskKind: args.taskKind } : {}),
@@ -179,7 +175,6 @@ export function buildAiTasksRunTaskRequest(args) {
         executionStrategies,
         ...(args.xynthesized != null ? { xynthesized: args.xynthesized } : {}),
         ...(smartInputForward != null ? { smartInput: smartInputForward } : {}),
-        ...(taskConfigurationForward != null ? { taskConfiguration: taskConfigurationForward } : {}),
     };
     return req;
 }

package/dist/src/runtime/executionMatrixHost.d.ts

@@ -5,12 +5,15 @@
  * a `{ plan, runtime }` request with per-graph `GraphEntryContract` + seeded
  * `runtime.executionMemory` objects built here.
  */
+import type { AuthoringGraphDocument } from '@x12i/graphenix-executable-contracts';
 import type { Graph, GraphEntryContract, GraphEntryExecutionInputSpec, Job } from '../types/refs.js';
 import type { ExellixGraphRuntimeOptions, ExecuteGraphInput, ExecuteGraphResult, GraphRuntimeObject } from './ExellixGraphRuntime.js';
 import type { GraphLoader } from './ExellixGraphRuntime.js';
+export { resolveGraphEntryFromAuthoringDocument, authoringDocumentGraphId } from '../compile/authoringDocumentHelpers.js';
 /**
  * Reads Layer 01 contract from the canonical graph document (`metadata.graphEntry`).
- * Does not fetch Catalox or bundle stores — those are host concerns before load.
+ * For execute-time materialized {@link Graph} (from plan). Authoring loaders should use
+ * {@link resolveGraphEntryFromAuthoringDocument}.
  */
 export declare function resolveGraphEntryFromGraph(graph: Graph): GraphEntryContract | undefined;
 /**
@@ -47,7 +50,7 @@ export type BuildExecutionSeedResult = {
 export declare function buildExecutionSeedFromGraphEntry(graphEntry: GraphEntryContract | undefined, sources?: BuildExecutionSeedSources): BuildExecutionSeedResult;
 /** Builds the canonical graph-engine execution request for matrix-style hosts. */
 export declare function buildGraphExecutionRequest(input: {
-    model: Graph;
+    doc: AuthoringGraphDocument;
     runtime: GraphRuntimeObject;
 }): ExecuteGraphInput;
 /**

package/dist/src/runtime/executionMatrixHost.js

@@ -15,9 +15,11 @@ function isExecutionInputSpec(spec) {
 function isValueInputSpec(spec) {
     return spec.kind !== 'execution' && typeof spec.path === 'string';
 }
+export { resolveGraphEntryFromAuthoringDocument, authoringDocumentGraphId } from '../compile/authoringDocumentHelpers.js';
 /**
  * Reads Layer 01 contract from the canonical graph document (`metadata.graphEntry`).
- * Does not fetch Catalox or bundle stores — those are host concerns before load.
+ * For execute-time materialized {@link Graph} (from plan). Authoring loaders should use
+ * {@link resolveGraphEntryFromAuthoringDocument}.
  */
 export function resolveGraphEntryFromGraph(graph) {
     const meta = mergeGraphDocumentModel(graph);
@@ -77,7 +79,7 @@ export function buildExecutionSeedFromGraphEntry(graphEntry, sources = {}) {
 /** Builds the canonical graph-engine execution request for matrix-style hosts. */
 export function buildGraphExecutionRequest(input) {
     return {
-        plan: compileExellixExecutablePlan(input.model, input.runtime),
+        plan: compileExellixExecutablePlan(input.doc, input.runtime),
         runtime: input.runtime,
     };
 }

package/dist/src/runtime/runTaskNodePlan.d.ts

@@ -0,0 +1,15 @@
+import type { FinalizerExecutionPlan, NodeExecutionPlan } from '@x12i/graphenix-executable-contracts';
+import type { RunTaskModelConfigWire } from './graphAiModelConfig.js';
+/** Resolve the frozen node plan required by `@exellix/ai-tasks` ≥ 9. */
+export declare function resolveRunTaskNodePlan(args: {
+    nodePlan?: NodeExecutionPlan;
+    skillKey: string;
+    nodeId: string;
+}): NodeExecutionPlan;
+/** Standalone {@link executeNode} without compile: patch MAIN unit selection from resolved graph profiles. */
+export declare function patchNodePlanMainModelFromWire(plan: NodeExecutionPlan, wire: RunTaskModelConfigWire): NodeExecutionPlan;
+export declare function nodePlanFromFinalizerPlan(args: {
+    finalizerId: string;
+    utilityKey: string;
+    finalizerPlan?: FinalizerExecutionPlan;
+}): NodeExecutionPlan;

package/dist/src/runtime/runTaskNodePlan.js

@@ -0,0 +1,46 @@
+import { minimalNodePlanForSkillKey } from '@exellix/ai-tasks';
+function mainSkillUnit(plan) {
+    return plan.executionUnits.find((u) => u.unitKind === 'mainSkill');
+}
+function selectionFromWireSlot(value) {
+    if (typeof value !== 'string' || value.trim().length === 0)
+        return undefined;
+    return { kind: 'profileChoice', key: value.trim() };
+}
+/** Resolve the frozen node plan required by `@exellix/ai-tasks` ≥ 9. */
+export function resolveRunTaskNodePlan(args) {
+    return args.nodePlan ?? minimalNodePlanForSkillKey(args.skillKey, args.nodeId);
+}
+/** Standalone {@link executeNode} without compile: patch MAIN unit selection from resolved graph profiles. */
+export function patchNodePlanMainModelFromWire(plan, wire) {
+    const next = structuredClone(plan);
+    const main = mainSkillUnit(next);
+    const selection = selectionFromWireSlot(wire.skillModel);
+    if (main && selection) {
+        main.modelSelection = selection;
+        main.modelSlot = 'skillModel';
+    }
+    return next;
+}
+export function nodePlanFromFinalizerPlan(args) {
+    const slots = args.finalizerPlan?.modelSlots;
+    const plan = minimalNodePlanForSkillKey(args.utilityKey, args.finalizerId);
+    if (!slots)
+        return plan;
+    const main = mainSkillUnit(plan);
+    if (!main)
+        return plan;
+    const selection = slots.postActionModel?.selection ??
+        slots.skillModel?.selection ??
+        slots.preActionModel?.selection;
+    if (selection) {
+        main.modelSelection = selection;
+        main.modelSlot =
+            slots.postActionModel?.selection != null
+                ? 'postActionModel'
+                : slots.skillModel?.selection != null
+                    ? 'skillModel'
+                    : 'preActionModel';
+    }
+    return plan;
+}

package/dist/src/runtime/studioGraphExecuteRequest.d.ts

@@ -1,40 +1,15 @@
-import type { Graph } from '../types/refs.js';
-import type { ExecuteGraphInput, GraphRuntimeObject } from './ExellixGraphRuntime.js';
+import type { ExecuteGraphInput } from './ExellixGraphRuntime.js';
 /**
  * Removed from the graphs-studio execute envelope (7.8.3+). No reader, no fallback.
- * Default model selection belongs on {@link Graph}.modelConfig only.
+ * Default model selection belongs on authoring graph executable profile only.
  */
 export declare const STUDIO_GRAPH_EXECUTE_REMOVED_KEYS: readonly ["graphDefaultModel"];
 export type StudioGraphExecuteRemovedKey = (typeof STUDIO_GRAPH_EXECUTE_REMOVED_KEYS)[number];
-/**
- * Graphs-studio / playground graph execute envelope before host adaptation to
- * {@link ExecuteGraphInput}. Credential and simulate-only fields are host concerns;
- * graph-engine validates shape and forbidden keys only.
- */
-export type StudioGraphExecuteRequest = {
-    mode: 'graph';
-    graph: Graph;
-    jobId: string;
-    runtime: Pick<GraphRuntimeObject, 'input' | 'inputs' | 'jobMemory' | 'taskMemory' | 'executionMemory' | 'outputsMemory' | 'variables' | 'jobVariables' | 'taskVariables' | 'nodes'>;
-    studioId?: string;
-    executionMode?: string;
-    runLogMode?: GraphRuntimeObject['runLogMode'];
-    maxRunLogEntries?: number;
-    maxRunLogDataJsonChars?: number;
-    graphExecution?: {
-        mode?: GraphRuntimeObject['mode'];
-        goalNodeId?: string;
-        dimension?: string;
-    };
-    runTaskDiagnostics?: GraphRuntimeObject['runTaskDiagnostics'];
-    exampleIndex?: number;
-    validateGraphEntrySeed?: boolean;
-    openrouterApiKey?: string;
-};
+/** @deprecated Prefer {@link AuthoringGraphDocument} from `@x12i/graphenix-executable-contracts`. */
+export type StudioGraphExecuteRequest = import('@x12i/graphenix-executable-contracts').StudioGraphExecuteRequest;
 export declare function getStudioGraphExecuteRemovedKeyViolations(request: unknown): StudioGraphExecuteRemovedKey[];
 /**
  * Rejects removed studio execute keys (notably `graphDefaultModel`).
- * Hosts must persist model defaults on `graph.modelConfig` and stop sending request-level mirrors.
  */
 export declare function assertCanonicalStudioGraphExecuteRequest(request: unknown, context?: {
     jobId?: string;
@@ -46,6 +21,6 @@ export type BuildGraphExecutionRequestFromStudioExecuteOptions = {
 };
 /**
  * Maps a validated studio execute envelope to {@link ExecuteGraphInput}.
- * Does not read or merge removed request-level model defaults — graph.modelConfig is authoritative.
+ * Delegates validate + compile to `@x12i/graphenix-execute-envelope`.
  */
 export declare function buildGraphExecutionRequestFromStudioExecute(request: StudioGraphExecuteRequest, options?: BuildGraphExecutionRequestFromStudioExecuteOptions): ExecuteGraphInput;