@exellix/graph-engine 8.1.8 → 8.1.9

package/CHANGELOG.md

@@ -2,15 +2,24 @@
 
 ## 8.1.8
 
+### Breaking
+
+- **Run-task data model 2.1:** `runtime.input` → `RunTaskRequest.input` via `inputsConfig` (`path: "input"`); **`executionMemory.input` is no longer seeded** or mirrored before `runTask`. `taskVariable` stays on `nodePlan.invokeContract` only (not merged into `input`). `executeGraph` requires compiled `plan.nodePlans[nodeId]` (`requireCompiledNodePlan`).
+- **`buildExecutionSeedFromGraphEntry`** skips `input` / `input.*` graphEntry paths (invoke payload belongs on `runtime.input` only).
+
 ### Changed
 
 - **Graphenix 2.1.0 alignment (Tier 2 + 3):** `@x12i/graphenix-core` ^2.0.1 (`formatVersion: "2.1.0"`); lifecycle `@x12i/graphenix-*` ^2.0.0; testkit emits `metadata.modelConfig` (no `metadata.extensions`, no `parameters.profile` / `nodeType`).
+- **`compileExellixExecutablePlan`** — removed host patch that prefixed bare `invokeContract.reads` with `executionMemory.`.
+- **`buildRunTaskInvokeInput`** / **`executionMemoryForRunTaskWire`** — canonical invoke binding resolver; entry gates evaluate `runtime.input`.
 - **`@exellix/ai-tasks` ^9.1.0** — accepts parent plan `"executable-plan"` v2 and trace `"execution-trace"` v2; dedupes nested `graphenix-*@1.1.x` under ai-tasks.
 - **`check:no-legacy`** — fails when ai-tasks < 9.1.0, graphenix-core < 2.0.1, or ai-tasks nests duplicate `@x12i/graphenix-*`.
 
 ### Added
 
 - **`tests/reference-fixtures-compile.test.ts`** — compiles `graph-content-pipeline` and `graph-subnets-analysis` authoring fixtures; asserts `validateExecutablePlanV2`.
+- **`tests/run-task-invoke-input.test.ts`** — wire-sketch parity for graphenix 2.1 invoke bindings.
+- **`docs/run-task-handoff/`** — client handoff docs (compiler, backend-host, graph-engine, observability).
 
 ## 8.1.3
 

package/dist/src/compile/compileExellixExecutablePlan.js

@@ -25,36 +25,6 @@ function patchEntryGatesFromGraphEntryDataFilters(plan, doc) {
     next.deferredGates = { ...next.deferredGates, entryGates };
     return next;
 }
-function patchInvokeContractReadPathsForExecutionMemory(plan) {
-    const allowedRoots = new Set([
-        'executionMemory',
-        'input',
-        'inputs',
-        'jobMemory',
-        'taskMemory',
-        'smartInput',
-        'xynthesized',
-        'runtime',
-        'response',
-    ]);
-    const next = structuredClone(plan);
-    for (const nodePlan of Object.values(next.nodePlans ?? {})) {
-        if (!nodePlan?.executionUnits)
-            continue;
-        for (const unit of nodePlan.executionUnits) {
-            const contract = unit.invokeContract;
-            if (!contract || !Array.isArray(contract.reads))
-                continue;
-            contract.reads = contract.reads.map((readPath) => {
-                if (typeof readPath !== 'string')
-                    return readPath;
-                const root = readPath.split('.')[0];
-                return allowedRoots.has(root) ? readPath : `executionMemory.${readPath}`;
-            });
-        }
-    }
-    return next;
-}
 /**
  * Host/test helper: canonical {@link AuthoringGraphDocument} + runtime → validated v2 executable plan.
  * No legacy migration — graphs must already be Graphenix 2.x authoring shape.
@@ -65,7 +35,7 @@ export function compileExellixExecutablePlan(doc, runtime, options) {
         const summary = authoringValidation.errors.map((e) => `${e.path}: ${e.message}`).join('; ');
         throw new Error(`compileExellixExecutablePlan: invalid authoring graph: ${summary}`);
     }
-    const plan = patchInvokeContractReadPathsForExecutionMemory(patchEntryGatesFromGraphEntryDataFilters(compileExecutablePlanV2(doc, runtime, options), doc));
+    const plan = patchEntryGatesFromGraphEntryDataFilters(compileExecutablePlanV2(doc, runtime, options), doc);
     const planValidation = validateExecutablePlanV2(plan);
     if (!planValidation.valid) {
         const summary = planValidation.errors.map((e) => `${e.path}: ${e.message}`).join('; ');

package/dist/src/index.d.ts

@@ -51,6 +51,8 @@ export { isGraphAiModelConfig, isPartialGraphAiModelConfig, isModelConfigSelecti
 export { GRAPH_ENGINE_MEMORY_PATH_ROOTS, splitGraphEngineMemoryPath, isAllowedGraphEngineMemoryPath, graphEngineMemoryPathValidationMessage, } from './runtime/graphEngineMemoryPaths.js';
 export { buildRunTaskMainInput, extractCallerInputsBag, buildGraphEngineMemoryResolutionRoot, buildGraphEngineMemoryResolutionRootFromWorkingMemory, resolveGraphEngineMemoryPathValue, } from './runtime/resolveGraphEngineMemoryPaths.js';
 export { mirrorStructuredInputOntoExecutionMemory, } from './runtime/materializeStructuredRunTaskInput.js';
+export { buildRunTaskInvokeInput, executionMemoryForRunTaskWire, } from './runtime/resolveRunTaskInvokeInput.js';
+export type { InvokeBindingContext } from './runtime/resolveRunTaskInvokeInput.js';
 export { buildRunTaskTaskConfigurationForward } from './runtime/buildRunTaskTaskConfigurationForward.js';
 export { normalizeSmartInputPath, collectSmartInputPaths, normalizeSmartInputConfigForRunTask, } from './runtime/smartInputPaths.js';
 export { evaluateTaskNodeMainReadiness, buildMainReadinessResolutionRoot, resolveMainReadinessPolicy, collectInputSynthesisSourcePaths, } from './runtime/taskNodeMainReadiness.js';

package/dist/src/index.js

@@ -41,6 +41,7 @@ export { isGraphAiModelConfig, isPartialGraphAiModelConfig, isModelConfigSelecti
 export { GRAPH_ENGINE_MEMORY_PATH_ROOTS, splitGraphEngineMemoryPath, isAllowedGraphEngineMemoryPath, graphEngineMemoryPathValidationMessage, } from './runtime/graphEngineMemoryPaths.js';
 export { buildRunTaskMainInput, extractCallerInputsBag, buildGraphEngineMemoryResolutionRoot, buildGraphEngineMemoryResolutionRootFromWorkingMemory, resolveGraphEngineMemoryPathValue, } from './runtime/resolveGraphEngineMemoryPaths.js';
 export { mirrorStructuredInputOntoExecutionMemory, } from './runtime/materializeStructuredRunTaskInput.js';
+export { buildRunTaskInvokeInput, executionMemoryForRunTaskWire, } from './runtime/resolveRunTaskInvokeInput.js';
 export { buildRunTaskTaskConfigurationForward } from './runtime/buildRunTaskTaskConfigurationForward.js';
 export { normalizeSmartInputPath, collectSmartInputPaths, normalizeSmartInputConfigForRunTask, } from './runtime/smartInputPaths.js';
 export { evaluateTaskNodeMainReadiness, buildMainReadinessResolutionRoot, resolveMainReadinessPolicy, collectInputSynthesisSourcePaths, } from './runtime/taskNodeMainReadiness.js';

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

@@ -39,9 +39,9 @@ export interface GraphRuntimeObject extends HostExecuteGraphRunOptions {
     jobId: string;
     /** Host job envelope (`agentId`, `jobType`, `input`, etc.). */
     job: any;
-    /** Active input for this execution. Mirrored to `runtime.executionMemory.input`. */
+    /** Active invoke payload for this run — maps to `RunTaskRequest.input` per node (not seeded into executionMemory). */
     input?: Record<string, unknown>;
-    /** Caller / graph-entry bag. Mirrored to `runtime.executionMemory.inputs` (dual root with `input`). */
+    /** Caller / graph-entry bag forwarded on `RunTaskRequest.inputs` (dual root with `input`). */
     inputs?: Record<string, unknown>;
     /** Temporary task/node-scoped runtime memory. */
     taskMemory?: any;
@@ -201,6 +201,12 @@ export declare function createExellixGraphRuntime(opts: ExellixGraphRuntimeOptio
             jobType?: string;
         };
         mainReadinessPolicy?: import("../types/options.js").MainReadinessPolicy;
+        /** Canonical invoke payload — not mirrored into executionMemory.input. */
+        invokeRuntimeInput?: Record<string, unknown>;
+        /** Caller bag (`runtime.inputs`) forwarded separately on RunTaskRequest.inputs. */
+        invokeRuntimeInputs?: Record<string, unknown>;
+        /** When true, requires compiled nodePlan (executeGraph path). */
+        requireCompiledNodePlan?: boolean;
     }) => Promise<{
         nodeId: string;
         skillKey: string;

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -8,10 +8,9 @@ import { mergeExecutionObject, copyExecutionContextFields, } from "./memory.js";
 import { buildAiTasksRunTaskRequest, extractRunTaskStrategyOverrides, resolveJobTypeId, } from "./buildAiTasksRunTaskRequest.js";
 import { runTaskResponseSucceeded } from "./runTaskResponse.js";
 import { mergeGraphDocumentModel, EXELLIX_GRAPH_MODEL_VARIABLE_KEY, } from "../types/refs.js";
-import { resolveTaskNodeInputsForRunTask } from "./resolveTaskNodeInputs.js";
 import { assertAiTasksNodeExtensionsValid } from "../inspection/validateAiTasksNodeExtensions.js";
-import { buildRunTaskMainInput, extractCallerInputsBag } from "./resolveGraphEngineMemoryPaths.js";
-import { mirrorStructuredInputOntoExecutionMemory, } from "./materializeStructuredRunTaskInput.js";
+import { extractCallerInputsBag } from "./resolveGraphEngineMemoryPaths.js";
+import { buildRunTaskInvokeInput, executionMemoryForRunTaskWire, } from "./resolveRunTaskInvokeInput.js";
 import { buildMainReadinessResolutionRoot, evaluateTaskNodeMainReadiness, resolveMainReadinessPolicy, } from "./taskNodeMainReadiness.js";
 import { mergeXynthesizedPatchIntoExecution, seedGraphRunExecutionState, xynthesizedOutboundForNode, } from "./graphRunExecutionSeed.js";
 import { buildTaskNodeJobContext } from "./buildTaskNodeJobContext.js";
@@ -30,7 +29,7 @@ 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";
+import { buildPredicateEvalContextForNode, readExecutionVariableBuckets, seedGraphVariableBucketsFromRuntime, } from "./variables.js";
 import { mergeExellixGraphRuntimeInvocation } from "./mergeExellixGraphRuntimeInvocation.js";
 import { resolveStepRetryPolicy, runRunTaskWithRetry } from "./stepRetry.js";
 import { isLocalSkillKey, runScopedDataReader, runDeterministicRule, runScopedAnswerWriter, runScopedAnswerAssembler, } from "./localSkills/index.js";
@@ -117,7 +116,7 @@ function resolveCoreObjectiveValue(args) {
         ? args.execution
         : undefined;
     return selectByPath({
-        input: executionRec?.input,
+        input: args.invokeInput ?? executionRec?.input,
         execution: args.execution,
         variables: executionRec?.jobVariables ?? args.variables,
         jobVariables: executionRec?.jobVariables,
@@ -236,19 +235,18 @@ async function resolveKnowledgePatch(args) {
 }
 function normalizeRuntimeExecutionMemory(runtime) {
     const execution = isPlainRecord(runtime.executionMemory)
-        ? runtime.executionMemory
+        ? { ...runtime.executionMemory }
         : {};
-    if (runtime.input !== undefined) {
-        execution.input = isPlainRecord(runtime.input) ? { ...runtime.input } : runtime.input;
-    }
-    else if (!isPlainRecord(execution.input)) {
-        execution.input = {};
-    }
     if (isPlainRecord(runtime.inputs)) {
         execution.inputs = { ...runtime.inputs };
     }
     return execution;
 }
+function normalizeInvokeRuntimeInput(runtime) {
+    if (isPlainRecord(runtime.input))
+        return { ...runtime.input };
+    return {};
+}
 function normalizeRuntimeOutputsMemory(runtime) {
     return isPlainRecord(runtime.outputsMemory) ? runtime.outputsMemory : {};
 }
@@ -337,9 +335,8 @@ export function createExellixGraphRuntime(opts) {
         if (executionSeed == null || typeof executionSeed !== "object")
             executionSeed = {};
         const executionRecSeed = executionSeed;
-        const dataFiltersRecordSeed = isPlainRecord(executionRecSeed.input)
-            ? executionRecSeed.input
-            : {};
+        const invokeInputSeed = isPlainRecord(input.invokeRuntimeInput) ? input.invokeRuntimeInput : {};
+        const dataFiltersRecordSeed = invokeInputSeed;
         let effectiveModelConfig = input.modelConfig;
         if (!isGraphAiModelConfig(effectiveModelConfig)) {
             if (input.graph == null) {
@@ -664,17 +661,9 @@ export function createExellixGraphRuntime(opts) {
             throw pe;
         }
         const executionRec = execution;
-        mirrorTaskVariablesOnExecution({
-            execution: executionRec,
-            node: input.node,
-            runtimeTaskVariables: input.taskVariables ?? undefined,
-        });
         const variableBuckets = readExecutionVariableBuckets(executionRec);
         const jobVariables = variableBuckets.jobVariables;
-        const nodeBindings = resolveTaskNodeInputsForRunTask({
-            node: input.node,
-            execution: executionRec,
-        });
+        const invokeRuntimeInput = isPlainRecord(input.invokeRuntimeInput) ? input.invokeRuntimeInput : {};
         const jobContext = buildTaskNodeJobContext({
             node: input.node,
             jobMemory: input.jobMemory,
@@ -695,8 +684,9 @@ export function createExellixGraphRuntime(opts) {
             nodePlan: input.nodePlan,
             skillKey,
             nodeId: String(input.node.id),
+            requireCompiledPlan: input.requireCompiledNodePlan === true,
         });
-        if (!input.nodePlan) {
+        if (!input.nodePlan && input.requireCompiledNodePlan !== true) {
             runTaskNodePlan = patchNodePlanMainModelFromWire(runTaskNodePlan, wireModelConfig);
         }
         const startedAt = Date.now();
@@ -714,21 +704,22 @@ export function createExellixGraphRuntime(opts) {
                 return c;
             })()
             : executionRec;
-        const callerInputs = extractCallerInputsBag({
-            execution: executionRec,
-            jobMemory: isPlainRecord(input.jobMemory) ? input.jobMemory : undefined,
-        });
-        const taskInput = buildRunTaskMainInput({
-            execution: executionRec,
-            jobMemory: isPlainRecord(input.jobMemory) ? input.jobMemory : undefined,
-            nodeBindings: {
-                ...nodeBindings,
-                ...(input.node?.data?.upstreamNodeIds !== undefined
-                    ? { upstreamNodeIds: input.node.data.upstreamNodeIds }
-                    : {}),
-            },
+        const callerInputs = input.invokeRuntimeInputs ??
+            extractCallerInputsBag({
+                execution: executionRec,
+                jobMemory: isPlainRecord(input.jobMemory) ? input.jobMemory : undefined,
+            });
+        const taskInput = buildRunTaskInvokeInput({
+            node: input.node,
+            runtimeInput: invokeRuntimeInput,
+            executionMemory: executionRec,
+            runtimeInputs: callerInputs,
+            variables: jobVariables,
+            extraFields: input.node?.data?.upstreamNodeIds !== undefined
+                ? { upstreamNodeIds: input.node.data.upstreamNodeIds }
+                : undefined,
         });
-        mirrorStructuredInputOntoExecutionMemory(executionForTask, taskInput);
+        const executionMemoryForWire = executionMemoryForRunTaskWire(executionForTask);
         const graphDocModel = jobVariables[EXELLIX_GRAPH_MODEL_VARIABLE_KEY];
         const graphEntry = graphDocModel != null && typeof graphDocModel === "object" && !Array.isArray(graphDocModel)
             ? graphDocModel.graphEntry
@@ -740,7 +731,7 @@ export function createExellixGraphRuntime(opts) {
         const readinessRoot = buildMainReadinessResolutionRoot({
             taskInput,
             callerInputs,
-            executionMemory: executionForTask,
+            executionMemory: executionMemoryForWire,
             xynthesized: xynthesizedOutboundForNode(executionRec, String(input.node.id)),
             jobMemory: input.jobMemory,
             taskMemory: input.taskMemory,
@@ -797,7 +788,7 @@ export function createExellixGraphRuntime(opts) {
             variables: jobVariables,
             jobMemory: runTaskJobMemory,
             taskMemory: runTaskTaskMemory,
-            executionMemory: executionForTask,
+            executionMemory: executionMemoryForWire,
             jobContext,
             prevNodeId: input.prevNodeId,
             narrix: narrix ?? undefined,
@@ -1186,6 +1177,8 @@ export function createExellixGraphRuntime(opts) {
                 // Track current memory and execution state (will be updated as nodes execute)
                 let currentJobMemory = runtime.jobMemory || {};
                 let currentTaskMemory = runtime.taskMemory;
+                const invokeRuntimeInput = normalizeInvokeRuntimeInput(runtime);
+                const invokeRuntimeInputs = isPlainRecord(runtime.inputs) ? { ...runtime.inputs } : undefined;
                 let currentExecution = normalizeRuntimeExecutionMemory(runtime);
                 let currentOutputsMemory = normalizeRuntimeOutputsMemory(runtime);
                 if (!currentExecution._trace)
@@ -1217,6 +1210,7 @@ export function createExellixGraphRuntime(opts) {
                 const coreObjectiveValue = resolveCoreObjectiveValue({
                     sourcePath: coreObjectiveConfig.sourcePath,
                     execution: currentExecution,
+                    invokeInput: invokeRuntimeInput,
                     jobMemory: currentJobMemory,
                     taskMemory: currentTaskMemory,
                     job,
@@ -1300,9 +1294,7 @@ export function createExellixGraphRuntime(opts) {
                     currentExecutionIsNull: currentExecution === null,
                 });
                 function recordForStructuredDataFilters() {
-                    return isPlainRecord(currentExecution?.input)
-                        ? currentExecution.input
-                        : {};
+                    return invokeRuntimeInput;
                 }
                 const entryGateEv = await evaluatePlanEntryGates(plan.deferredGates.entryGates, recordForStructuredDataFilters(), {
                     executionMemory: currentExecution,
@@ -1311,7 +1303,7 @@ export function createExellixGraphRuntime(opts) {
                     job,
                 }, runxClient);
                 if (!entryGateEv.ok) {
-                    const err = new Error("GRAPH_ENTRY_DATA_FILTERS_REJECTED: plan entry gates rejected runtime.executionMemory.input");
+                    const err = new Error("GRAPH_ENTRY_DATA_FILTERS_REJECTED: plan entry gates rejected runtime.input");
                     err.code = ExellixGraphErrorCode.GRAPH_ENTRY_DATA_FILTERS_REJECTED;
                     logGraphEngineErrorCode(ExellixGraphErrorCode.GRAPH_ENTRY_DATA_FILTERS_REJECTED, err.message, {
                         graphId: resolvedGraphId,
@@ -1571,6 +1563,9 @@ export function createExellixGraphRuntime(opts) {
                                 outputsMemory: outputsForNode,
                                 variables: runtime.variables,
                                 taskVariables: runtime.taskVariables,
+                                invokeRuntimeInput,
+                                invokeRuntimeInputs,
+                                requireCompiledNodePlan: true,
                                 modelConfig: effectiveModelConfig,
                                 runTaskIdentity: merged.runTaskIdentity,
                                 runTaskExecutionMode: merged.runTaskExecutionMode,

package/dist/src/runtime/executionMatrixHost.js

@@ -56,6 +56,9 @@ export function buildExecutionSeedFromGraphEntry(graphEntry, sources = {}) {
         const path = spec.path.trim();
         if (!path)
             continue;
+        // Invoke payload paths belong on runtime.input (graphenix 2.1) — not executionMemory.
+        if (path === 'input' || path.startsWith('input.'))
+            continue;
         let value = undefined;
         if (Object.prototype.hasOwnProperty.call(valuesByPath, path)) {
             value = valuesByPath[path];

package/dist/src/runtime/graphEngineLogxer.js

@@ -12,11 +12,11 @@ const GRAPH_ENGINE_DIAGNOSTIC_CATALOG = {
         impact: 'The graph run cannot start because structured entry filters did not accept runtime input.',
         possibleCauses: [
             'metadata.graphEntry.dataFilters shape is unsupported or evaluated false.',
-            'runtime.executionMemory.input is missing expected fields for the filter contract.',
+            'runtime.input is missing expected fields for the filter contract.',
         ],
         remediation: [
             'Inspect metadata.graphEntry.dataFilters against exellix.dataFilters.v1.',
-            'Verify runtime.executionMemory.input before executeGraph.',
+            'Verify runtime.input before executeGraph.',
         ],
         retryable: false,
         userActionRequired: true,

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

@@ -0,0 +1,35 @@
+/**
+ * Resolves `nodePlan.invokeContract.inputsConfig` → `RunTaskRequest.input` per graphenix 2.1.
+ * Invoke payload reads from `runtime.input` (`path: "input"`); cross-node reads use `executionMemoryPath`.
+ */
+import type { TaskNode } from '../types/refs.js';
+export type InvokeBindingContext = {
+    /** Canonical invoke payload (`runtime.input`). */
+    invokeInput: Record<string, unknown>;
+    /** Caller bag (`runtime.inputs`). */
+    callerInputs?: Record<string, unknown>;
+    executionMemory: Record<string, unknown>;
+    jobVariables?: Record<string, unknown>;
+    taskVariables?: Record<string, unknown>;
+};
+/**
+ * Resolves `inputsConfig` bindings into the outbound `RunTaskRequest.input` object.
+ */
+export declare function resolveInputsConfigToRunTaskInput(args: {
+    inputsConfig: Record<string, unknown>;
+    ctx: InvokeBindingContext;
+}): Record<string, unknown>;
+/**
+ * Builds MAIN `RunTaskRequest.input` from frozen invoke contract + runtime invoke payload.
+ * When `inputsConfig` is empty, returns a shallow copy of `runtimeInput`.
+ */
+export declare function buildRunTaskInvokeInput(args: {
+    node: TaskNode;
+    runtimeInput: Record<string, unknown>;
+    executionMemory: Record<string, unknown>;
+    runtimeInputs?: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+    extraFields?: Record<string, unknown>;
+}): Record<string, unknown>;
+/** Strips invoke-payload mirror fields before sending executionMemory on RunTask wire. */
+export declare function executionMemoryForRunTaskWire(execution: Record<string, unknown>): Record<string, unknown>;

package/dist/src/runtime/resolveRunTaskInvokeInput.js

@@ -0,0 +1,135 @@
+import { readTaskNodeInputsConfig } from './readTaskNodeInputsConfig.js';
+import { selectByPath } from './pathExpr.js';
+function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+function getByDotPath(root, path) {
+    if (!path)
+        return root;
+    const parts = path.split('.').filter(Boolean);
+    let cur = root;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+function resolvePathBinding(path, ctx) {
+    const p = path.trim();
+    if (!p)
+        return undefined;
+    if (p === 'input')
+        return ctx.invokeInput;
+    if (p.startsWith('input.'))
+        return selectByPath(ctx.invokeInput, p.slice('input.'.length));
+    if (p === 'inputs')
+        return ctx.callerInputs ?? {};
+    if (p.startsWith('inputs.')) {
+        const bag = ctx.callerInputs ?? {};
+        return selectByPath(bag, p.slice('inputs.'.length));
+    }
+    if (p.startsWith('variables.') || p.startsWith('jobVariables.')) {
+        const tail = p.startsWith('variables.') ? p.slice('variables.'.length) : p.slice('jobVariables.'.length);
+        return ctx.jobVariables != null ? selectByPath(ctx.jobVariables, tail) : undefined;
+    }
+    if (p.startsWith('taskVariables.')) {
+        return ctx.taskVariables != null ? selectByPath(ctx.taskVariables, p.slice('taskVariables.'.length)) : undefined;
+    }
+    if (p.startsWith('executionMemory.')) {
+        return selectByPath(ctx.executionMemory, p.slice('executionMemory.'.length));
+    }
+    return getByDotPath(ctx.executionMemory, p);
+}
+function resolveBindingValue(binding, ctx) {
+    if (!isPlainObject(binding))
+        return binding;
+    if (typeof binding.path === 'string') {
+        return resolvePathBinding(binding.path, ctx);
+    }
+    if (typeof binding.executionMemoryPath === 'string') {
+        const emp = binding.executionMemoryPath.trim();
+        if (emp === 'executionMemory.input' || emp.startsWith('executionMemory.input.')) {
+            return undefined;
+        }
+        if (emp.startsWith('executionMemory.')) {
+            return selectByPath(ctx.executionMemory, emp.slice('executionMemory.'.length));
+        }
+        return getByDotPath(ctx.executionMemory, emp);
+    }
+    if (binding.type === 'executionMemoryPath' && typeof binding.path === 'string') {
+        const p = binding.path.trim();
+        if (p === 'executionMemory.input' || p.startsWith('executionMemory.input.')) {
+            return undefined;
+        }
+        if (p === 'input' || p.startsWith('input.')) {
+            return resolvePathBinding(p, ctx);
+        }
+        if (p === 'inputs' || p.startsWith('inputs.')) {
+            return resolvePathBinding(p, ctx);
+        }
+        if (binding.optional === true) {
+            const v = getByDotPath(ctx.executionMemory, p);
+            return v === undefined || v === null ? undefined : v;
+        }
+        return getByDotPath(ctx.executionMemory, p);
+    }
+    if (typeof binding.$path === 'string') {
+        const p = binding.$path.trim();
+        if (p.startsWith('variables.') || p.startsWith('jobVariables.') || p.startsWith('taskVariables.')) {
+            return resolvePathBinding(p, ctx);
+        }
+        if (p === 'input' || p.startsWith('input.') || p === 'inputs' || p.startsWith('inputs.')) {
+            return resolvePathBinding(p, ctx);
+        }
+        return getByDotPath(ctx.executionMemory, p);
+    }
+    const nested = {};
+    for (const [k, v] of Object.entries(binding)) {
+        if (k === '$path' || k === 'type' || k === 'path' || k === 'executionMemoryPath' || k === 'optional')
+            continue;
+        const child = resolveBindingValue(v, ctx);
+        if (child !== undefined)
+            nested[k] = child;
+    }
+    return Object.keys(nested).length > 0 ? nested : binding;
+}
+/**
+ * Resolves `inputsConfig` bindings into the outbound `RunTaskRequest.input` object.
+ */
+export function resolveInputsConfigToRunTaskInput(args) {
+    const out = {};
+    for (const [key, val] of Object.entries(args.inputsConfig)) {
+        const resolved = resolveBindingValue(val, args.ctx);
+        if (resolved !== undefined)
+            out[key] = resolved;
+    }
+    return out;
+}
+/**
+ * Builds MAIN `RunTaskRequest.input` from frozen invoke contract + runtime invoke payload.
+ * When `inputsConfig` is empty, returns a shallow copy of `runtimeInput`.
+ */
+export function buildRunTaskInvokeInput(args) {
+    const ctx = {
+        invokeInput: args.runtimeInput,
+        callerInputs: args.runtimeInputs,
+        executionMemory: args.executionMemory,
+        jobVariables: args.variables,
+    };
+    const recipe = readTaskNodeInputsConfig(args.node);
+    const fromConfig = Object.keys(recipe).length > 0
+        ? resolveInputsConfigToRunTaskInput({ inputsConfig: recipe, ctx })
+        : { ...args.runtimeInput };
+    return {
+        ...fromConfig,
+        ...(args.extraFields ?? {}),
+    };
+}
+/** Strips invoke-payload mirror fields before sending executionMemory on RunTask wire. */
+export function executionMemoryForRunTaskWire(execution) {
+    const wire = { ...execution };
+    delete wire.input;
+    delete wire.inputs;
+    return wire;
+}

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

@@ -5,6 +5,8 @@ export declare function resolveRunTaskNodePlan(args: {
     nodePlan?: NodeExecutionPlan;
     skillKey: string;
     nodeId: string;
+    /** When true (executeGraph path), missing compiled nodePlan is an error. */
+    requireCompiledPlan?: boolean;
 }): NodeExecutionPlan;
 /** Standalone {@link executeNode} without compile: patch MAIN unit selection from resolved graph profiles. */
 export declare function patchNodePlanMainModelFromWire(plan: NodeExecutionPlan, wire: RunTaskModelConfigWire): NodeExecutionPlan;

package/dist/src/runtime/runTaskNodePlan.js

@@ -9,7 +9,12 @@ function selectionFromWireSlot(value) {
 }
 /** Resolve the frozen node plan required by `@exellix/ai-tasks` ≥ 9. */
 export function resolveRunTaskNodePlan(args) {
-    return args.nodePlan ?? minimalNodePlanForSkillKey(args.skillKey, args.nodeId);
+    if (args.nodePlan)
+        return args.nodePlan;
+    if (args.requireCompiledPlan) {
+        throw new Error(`MISSING_NODE_PLAN: compiled plan has no nodePlans[${args.nodeId}] — executeGraph requires full compiled node plans`);
+    }
+    return minimalNodePlanForSkillKey(args.skillKey, args.nodeId);
 }
 /** Standalone {@link executeNode} without compile: patch MAIN unit selection from resolved graph profiles. */
 export function patchNodePlanMainModelFromWire(plan, wire) {

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

@@ -26,13 +26,9 @@ export type BuildTaskNodeRunTaskRequestArgs = {
     taskMemory?: unknown;
     taskVariables?: Record<string, unknown>;
     prevNodeId?: string;
-    /** Same UUID used for every `runTask` in one `executeGraph` invocation. */
     graphRunTaskId?: string;
-    /** Host job id on `job.jobId` / `job.id`; defaults from `job` when omitted. */
     runTaskJobId?: string;
-    /** Frozen per-node plan from compile; when omitted a minimal plan is synthesized and patched from modelConfig. */
     nodePlan?: NodeExecutionPlan;
-    /** Resolved graph model profiles (required for runnable MAIN when nodePlan is omitted). */
     modelConfig: GraphAiModelConfig;
     runTaskIdentity?: Record<string, unknown>;
     runTaskExecutionMode?: 'default' | 'trace';
@@ -41,11 +37,11 @@ export type BuildTaskNodeRunTaskRequestArgs = {
     taskKnowledgePatch?: Record<string, unknown>;
     skillKeyResolution?: SkillKeyResolutionOptions;
     clearSynthesizedContextPerNode?: boolean;
+    /** Canonical invoke payload (`runtime.input`). */
+    invokeRuntimeInput?: Record<string, unknown>;
+    invokeRuntimeInputs?: Record<string, unknown>;
+    requireCompiledNodePlan?: boolean;
 };
-/**
- * Materialize the outbound `RunTaskRequest` graph-engine would send for a task node
- * (mirrors `executeNode` request assembly; does not invoke `runTask`).
- */
 export declare function buildTaskNodeRunTaskRequest(args: BuildTaskNodeRunTaskRequestArgs): Promise<BuildTaskNodeRunTaskRequestResult>;
 export type ValidateTaskNodeRunTaskConfigArgs = BuildTaskNodeRunTaskRequestArgs;
 export type ValidateTaskNodeRunTaskConfigResult = {
@@ -57,7 +53,6 @@ export type ValidateTaskNodeRunTaskConfigResult = {
     skillKey: string;
     request: RunTaskRequest;
 } & RunTaskValidationResult);
-/** Static ai-tasks validation on the graph-built {@link RunTaskRequest}. */
 export declare function validateTaskNodeRunTaskConfig(args: ValidateTaskNodeRunTaskConfigArgs): Promise<ValidateTaskNodeRunTaskConfigResult>;
 export type ValidateTaskNodeRunTaskInvokeArgs = BuildTaskNodeRunTaskRequestArgs & Omit<ValidateRunTaskInvokeParams, 'request'>;
 export type ValidateTaskNodeRunTaskInvokeResult = {
@@ -69,5 +64,4 @@ export type ValidateTaskNodeRunTaskInvokeResult = {
     skillKey: string;
     request: RunTaskRequest;
 } & RunTaskInvokeValidationResult);
-/** Config + payload + template path validation via ai-tasks {@link validateRunTaskInvoke}. */
 export declare function validateTaskNodeRunTaskInvoke(args: ValidateTaskNodeRunTaskInvokeArgs): Promise<ValidateTaskNodeRunTaskInvokeResult>;

package/dist/src/runtime/taskNodeRunTaskPreflight.js

@@ -3,15 +3,14 @@ import { toRunTaskModelConfig } from './graphAiModelConfig.js';
 import { resolveTaskKey } from './resolveTaskKey.js';
 import { isLocalSkillKey } from './localSkills/index.js';
 import { buildAiTasksRunTaskRequest, extractRunTaskStrategyOverrides, } from './buildAiTasksRunTaskRequest.js';
-import { resolveTaskNodeInputsForRunTask } from './resolveTaskNodeInputs.js';
 import { assertAiTasksNodeExtensionsValid } from '../inspection/validateAiTasksNodeExtensions.js';
-import { buildRunTaskMainInput, extractCallerInputsBag } from './resolveGraphEngineMemoryPaths.js';
-import { mirrorStructuredInputOntoExecutionMemory, } from './materializeStructuredRunTaskInput.js';
+import { extractCallerInputsBag } from './resolveGraphEngineMemoryPaths.js';
+import { buildRunTaskInvokeInput, executionMemoryForRunTaskWire, } from './resolveRunTaskInvokeInput.js';
 import { xynthesizedOutboundForNode } from './graphRunExecutionSeed.js';
 import { buildTaskNodeJobContext } from './buildTaskNodeJobContext.js';
 import { resolveNarrixForTaskNode } from './resolveNarrixForTaskNode.js';
 import { buildRunTaskIdentityEnvelope, shouldForwardRunTaskTraceMode, } from './runTaskAugments.js';
-import { mirrorTaskVariablesOnExecution, readExecutionVariableBuckets, } from './executionVariableBuckets.js';
+import { readExecutionVariableBuckets } from './executionVariableBuckets.js';
 import { newGraphRunTaskId } from './graphRunIdentity.js';
 import { patchNodePlanMainModelFromWire, resolveRunTaskNodePlan } from './runTaskNodePlan.js';
 function isPlainRecord(v) {
@@ -30,10 +29,6 @@ function mergeKnowledgePatchIntoRunTaskMemory(memory, patch) {
         },
     };
 }
-/**
- * Materialize the outbound `RunTaskRequest` graph-engine would send for a task node
- * (mirrors `executeNode` request assembly; does not invoke `runTask`).
- */
 export async function buildTaskNodeRunTaskRequest(args) {
     const node = args.node;
     if (node.type === 'finalizer') {
@@ -53,18 +48,14 @@ export async function buildTaskNodeRunTaskRequest(args) {
     let execution = args.execution != null && typeof args.execution === 'object' && !Array.isArray(args.execution)
         ? { ...args.execution }
         : {};
-    mirrorTaskVariablesOnExecution({
-        execution,
-        node: node,
-        runtimeTaskVariables: args.taskVariables,
-    });
     const wireModelConfig = toRunTaskModelConfig(args.modelConfig);
     let runTaskNodePlan = resolveRunTaskNodePlan({
         nodePlan: args.nodePlan,
         skillKey,
         nodeId: String(node.id),
+        requireCompiledPlan: args.requireCompiledNodePlan === true,
     });
-    if (!args.nodePlan) {
+    if (!args.nodePlan && args.requireCompiledNodePlan !== true) {
         runTaskNodePlan = patchNodePlanMainModelFromWire(runTaskNodePlan, wireModelConfig);
     }
     const hasSynthesizedContextPreStep = runTaskNodePlan.executionUnits.some((u) => u.unitKind === 'externalPreUtility' || u.unitKind === 'pipelinePhase');
@@ -74,7 +65,11 @@ export async function buildTaskNodeRunTaskRequest(args) {
         hasExistingSynthesizedContext;
     const variableBuckets = readExecutionVariableBuckets(execution);
     const jobVariables = variableBuckets.jobVariables;
-    const nodeBindings = resolveTaskNodeInputsForRunTask({ node, execution });
+    const invokeRuntimeInput = isPlainRecord(args.invokeRuntimeInput)
+        ? args.invokeRuntimeInput
+        : isPlainRecord(args.execution?.input)
+            ? args.execution.input
+            : {};
     const jobContext = buildTaskNodeJobContext({
         node,
         jobMemory: args.jobMemory,
@@ -98,19 +93,20 @@ export async function buildTaskNodeRunTaskRequest(args) {
             return c;
         })()
         : execution;
-    const callerInputs = extractCallerInputsBag({
-        execution,
-        jobMemory: isPlainRecord(args.jobMemory) ? args.jobMemory : undefined,
-    });
-    const taskInput = buildRunTaskMainInput({
-        execution,
-        jobMemory: isPlainRecord(args.jobMemory) ? args.jobMemory : undefined,
-        nodeBindings: {
-            ...nodeBindings,
-            ...(node.data?.upstreamNodeIds !== undefined ? { upstreamNodeIds: node.data.upstreamNodeIds } : {}),
-        },
+    const callerInputs = args.invokeRuntimeInputs ??
+        extractCallerInputsBag({
+            execution,
+            jobMemory: isPlainRecord(args.jobMemory) ? args.jobMemory : undefined,
+        });
+    const taskInput = buildRunTaskInvokeInput({
+        node,
+        runtimeInput: invokeRuntimeInput,
+        executionMemory: execution,
+        runtimeInputs: callerInputs,
+        variables: jobVariables,
+        extraFields: node.data?.upstreamNodeIds !== undefined ? { upstreamNodeIds: node.data.upstreamNodeIds } : undefined,
     });
-    mirrorStructuredInputOntoExecutionMemory(executionForTask, taskInput);
+    const executionMemoryForWire = executionMemoryForRunTaskWire(executionForTask);
     const runTaskJobMemory = mergeKnowledgePatchIntoRunTaskMemory(args.jobMemory, args.jobKnowledgePatch);
     const runTaskTaskMemory = mergeKnowledgePatchIntoRunTaskMemory(args.taskMemory, args.taskKnowledgePatch);
     const forwardRunTaskTrace = shouldForwardRunTaskTraceMode({
@@ -142,7 +138,7 @@ export async function buildTaskNodeRunTaskRequest(args) {
         variables: jobVariables,
         jobMemory: runTaskJobMemory,
         taskMemory: runTaskTaskMemory,
-        executionMemory: executionForTask,
+        executionMemory: executionMemoryForWire,
         jobContext,
         prevNodeId: args.prevNodeId,
         narrix: narrix ?? undefined,
@@ -170,7 +166,6 @@ export async function buildTaskNodeRunTaskRequest(args) {
     });
     return { runnable: true, skillKey, request };
 }
-/** Static ai-tasks validation on the graph-built {@link RunTaskRequest}. */
 export async function validateTaskNodeRunTaskConfig(args) {
     const built = await buildTaskNodeRunTaskRequest(args);
     if (!built.runnable) {
@@ -179,7 +174,6 @@ export async function validateTaskNodeRunTaskConfig(args) {
     const validation = validateRunTaskConfig(built.request);
     return { skipped: false, skillKey: built.skillKey, request: built.request, ...validation };
 }
-/** Config + payload + template path validation via ai-tasks {@link validateRunTaskInvoke}. */
 export async function validateTaskNodeRunTaskInvoke(args) {
     const built = await buildTaskNodeRunTaskRequest(args);
     if (!built.runnable) {

package/dist/src/runtime/validateCanonicalGraphDocument.js

@@ -411,6 +411,17 @@ function assertForbidInputRawExecutionPath(dotPath, label, context) {
         throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `${label}: executionMemoryPath "${dotPath}" is forbidden — bind to "input" (flat MAIN bucket). input.raw mirroring was removed.`, context);
     }
 }
+function assertForbidHubPathExecutionInput(binding, label, context) {
+    const hubPaths = [
+        typeof binding.executionMemoryPath === 'string' ? binding.executionMemoryPath.trim() : undefined,
+        binding.type === 'executionMemoryPath' && typeof binding.path === 'string' ? binding.path.trim() : undefined,
+    ].filter((p) => p != null && p.length > 0);
+    for (const p of hubPaths) {
+        if (p === 'executionMemory.input' || p.startsWith('executionMemory.input.')) {
+            throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `${label}: TASK_INPUT_BINDING_HUB_PATH_FORBIDDEN — use path "input" instead of executionMemoryPath "executionMemory.input".`, context);
+        }
+    }
+}
 function assertGraphResponseShapeNoLegacy(shape, path, context) {
     if (Array.isArray(shape)) {
         shape.forEach((item, index) => assertGraphResponseShapeNoLegacy(item, `${path}[${index}]`, context));
@@ -553,6 +564,9 @@ export function assertCanonicalTaskNode(node, context, options) {
             throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `Task node "${String(node.id)}": inputsConfig must be a plain object when present.`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id) });
         }
         for (const [bindingKey, bindingVal] of Object.entries(inputsConfig)) {
+            if (isPlainObject(bindingVal)) {
+                assertForbidHubPathExecutionInput(bindingVal, `Task node "${String(node.id)}": inputsConfig.${bindingKey}`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id) });
+            }
             if (isExecutionMemoryPathBinding(bindingVal)) {
                 assertForbidInputRawExecutionPath(bindingVal.path, `Task node "${String(node.id)}": inputsConfig.${bindingKey}`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id) });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exellix/graph-engine",
-  "version": "8.1.8",
+  "version": "8.1.9",
   "type": "module",
   "description": "Graph executor SDK",
   "main": "dist/src/index.js",
@@ -52,22 +52,22 @@
     "access": "public"
   },
   "dependencies": {
-    "@exellix/ai-skills": "^6.9.0",
-    "@exellix/ai-tasks": "^9.1.0",
+    "@exellix/ai-skills": "^6.9.1",
+    "@exellix/ai-tasks": "^9.1.1",
     "@x12i/activix": "^8.6.3",
     "@x12i/catalox": "^5.2.0",
     "@x12i/env": "^4.0.1",
-    "@x12i/funcx": "^4.9.6",
+    "@x12i/funcx": "^4.9.13",
     "@x12i/graphenix": "^2.5.0",
-    "@x12i/graphenix-authoring-format": "^2.0.0",
+    "@x12i/graphenix-authoring-format": "^2.0.1",
     "@x12i/graphenix-core": "^2.0.1",
-    "@x12i/graphenix-executable-contracts": "^2.0.0",
-    "@x12i/graphenix-executable-format": "^2.2.0",
+    "@x12i/graphenix-executable-contracts": "^2.0.1",
+    "@x12i/graphenix-executable-format": "^2.2.1",
     "@x12i/graphenix-execute-envelope": "^2.0.0",
     "@x12i/graphenix-format": "^2.0.0",
-    "@x12i/graphenix-plan-compiler": "^2.0.0",
-    "@x12i/graphenix-plan-format": "^2.0.0",
-    "@x12i/graphenix-trace-format": "^2.0.0",
+    "@x12i/graphenix-plan-compiler": "^2.0.1",
+    "@x12i/graphenix-plan-format": "^2.0.1",
+    "@x12i/graphenix-trace-format": "^2.0.1",
     "@x12i/logxer": "^4.6.0",
     "@x12i/memorix-descriptors": "^1.6.0",
     "@x12i/memorix-retrieval": "^1.11.2",