@exellix/graph-engine 7.7.7 → 7.8.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 7.7.9
+
+### Changed
+
+- **Documentation:** Align README, [`.docs/exellix-graph-engine-format.md`](.docs/exellix-graph-engine-format.md), format docs, and [`.docs/ai-tasks-model-profile-aliases-7x.md`](.docs/ai-tasks-model-profile-aliases-7x.md) with ai-tasks **8.6.8** / funcx **4.4.4**: three-slot `modelConfig`, graph-only selection (7.7+), partial task overrides (7.7.8+), studio preflight via `@exellix/graph-composer`, funcx-for-runx vs xynthesis-for-execution-strategies.
+
+### Dependencies
+
+- **`@exellix/ai-tasks`:** ^8.6.8
+- **`@x12i/funcx`:** 4.4.4
+
+## 7.7.8
+
+### Added (CR-11 execute-time model routing)
+
+- **`mergeGraphAiModelConfig`**, **`PartialGraphAiModelConfig`**, **`isPartialGraphAiModelConfig`** — job-default + per-task partial override merge at execute time (`task[slot] ?? graph[slot] ?? engine default`).
+- **`assertCanonicalGraphDocument(..., { mode: 'execute' })`** — accepts partial task `taskConfiguration.modelConfig` and `profile/choice` slot encoding (`cheap/default`, `cyber/deep_forensics`); **`persist`** mode (default) unchanged for save/inspection paths.
+- **`executeGraph`** uses execute-mode validation so hosts can POST authored graph JSON without pre-merging model slots or stripping `/`.
+
+### Changed
+
+- **`looksLikeConcreteModelId`** — only provider-prefixed ids are concrete; `profile/choice` strings are valid graph aliases.
+- **`inspectGraphModelSelection`** — reports merged effective routing when task overrides are partial.
+
+### Migration (hosts / graphs-studio)
+
+- Remove execute-time `skipCanonicalAssert`, host-side job→node model merge, and slot `/` stripping once on **7.7.8+** (see CR-11 / CR-9).
+
 ## 7.7.3
 
 ### Changed
@@ -195,7 +223,7 @@
 ### Changed
 
 - **Dual memory roots `input` and `inputs`:** Both are allowlisted for `smartInput.paths` and `inputSynthesis.sources`; paths are no longer rewritten to `input.*` at validation or runtime. Optional migration via `mapInputsMemoryPathToInputRoot` / `mapSmartInputPathsInputsToInput`.
-- **`runTask` wire:** Forwards `inputs` (caller bag) alongside coalesced `input` when present. See [CR-input-and-inputs-dual-root.md](.docs/CR-input-and-inputs-dual-root.md) for downstream `@exellix/ai-tasks` and graphs-studio work.
+- **`runTask` wire:** Forwards `inputs` (caller bag) alongside coalesced `input` when present.
 
 ## 5.4.0
 

package/README.md

@@ -27,22 +27,21 @@ A minimal, focused SDK for executing graphs in the exellix ecosystem.
 | Topic | Document |
 |--------|----------|
 | **Object contracts** (model × runtime + per-call resolution view) | Index: [`formats-documentations/README.md`](formats-documentations/README.md) — [`graph-model`](formats-documentations/graph-model-object-format.md), [`graph-runtime`](formats-documentations/graph-runtime-object-format.md), [`task-node-model`](formats-documentations/task-node-model-object-format.md), [`task-node-runtime`](formats-documentations/task-node-runtime-object-format.md), [`ExellixRuntimeObject`](formats-documentations/exellix-runtime-object-format.md) |
-| **Ecosystem acceptance** (ai-tasks, studio, matrix parity) | [`.docs/ecosystem-acceptance-criteria.md`](.docs/ecosystem-acceptance-criteria.md) |
 | **Executable graph JSON** (top-level shape, task/finalizer nodes, edges, variables, `metadata.graphExecution`, canonical root enforcement, execution memory, local skills, Narrix / web scope (**forwarded `narrix` → `runTask`**), **graph JSON vs outbound `runTask`**) | **[`.docs/exellix-graph-engine-format.md`](.docs/exellix-graph-engine-format.md)** — start here for authors and schema tooling |
 | Task node bridge (shell, `metadata`, `executionPipeline`, `aiTaskProfile` → Narrix web merge, composer alignment) | [`.docs/task-node-exellix-graph-engine-and-graph-composer.md`](.docs/task-node-exellix-graph-engine-and-graph-composer.md) |
 | Layer 01 / 08 graph entry & response contracts | [`.docs/graph-io-visibility.md`](.docs/graph-io-visibility.md) |
 | Graph entry `dataFilters` v1 / public evaluator | [`.docs/data-filters-evaluation.md`](.docs/data-filters-evaluation.md) |
 | Task-node `conditions` + conditional `modelConfig.cases` (runx) | [`.docs/task-node-conditions-evaluation.md`](.docs/task-node-conditions-evaluation.md) |
-| **Model profile aliases** (7.x: graph = profile names, runtime = concrete models) | [`BREAKING-CHANGES.md`](BREAKING-CHANGES.md) §7.0.0, [`.docs/ai-tasks-model-profile-aliases-7x.md`](.docs/ai-tasks-model-profile-aliases-7x.md) (ai-tasks), [`.docs/fr-model-alias-descriptors.md`](.docs/fr-model-alias-descriptors.md) (upstream FRs) |
+| **Model profile aliases** (7.x+: graph = aliases / `profile/choice`; ai-tasks resolves per phase) | [`BREAKING-CHANGES.md`](BREAKING-CHANGES.md) §7.6 / §7.7, [`.docs/ai-tasks-model-profile-aliases-7x.md`](.docs/ai-tasks-model-profile-aliases-7x.md) |
 | Platform vs implementation (no domain operators in schema) | [`.docs/platform-generic-vs-implementation.md`](.docs/platform-generic-vs-implementation.md) |
 | Activix records, `runContext`, collection tracking (`@x12i/activix` 8.4+) | [`.docs/activix-records.md`](.docs/activix-records.md) |
 | Bundled graph examples & bundle README | [`graphs/README.md`](graphs/README.md) |
 
-The **`runTask`** wire contract (identity, canonical **`input`**, optional extra ai-tasks PRE/POST utility calls vs `executionPipeline`) is summarized later under **Run identity** and **`runTask` request contract**, and expanded in the graph format doc’s [**Graph JSON vs outbound `runTask`**](.docs/exellix-graph-engine-format.md#graph-json-vs-outbound-runtask) section. Graph-engine integrates with **`@exellix/ai-tasks`** at the semver range declared in **`package.json`** (currently **`^7.6.4`**); use your **lockfile** as the tested line. Variable buckets align with ai-tasks **≥ 7.6.2** (two-scope passthrough). There is **no** minimum graph-engine ↔ ai-tasks matrix published inside ai-tasks — follow dependency semver and upstream **`CHANGELOG.md`**. Graph-engine does **not** import or invoke the Xynthesis SDK directly.
+The **`runTask`** wire contract (identity, canonical **`input`**, optional extra ai-tasks PRE/POST utility calls vs `executionPipeline`) is summarized later under **Run identity** and **`runTask` request contract**, and expanded in the graph format doc’s [**Graph JSON vs outbound `runTask`**](.docs/exellix-graph-engine-format.md#graph-json-vs-outbound-runtask) section. Graph-engine integrates with **`@exellix/ai-tasks`** at the semver range declared in **`package.json`** (currently **`^8.6.8`**); use your **lockfile** as the tested line. Variable buckets align with ai-tasks **≥ 7.6.2** (two-scope passthrough). There is **no** minimum graph-engine ↔ ai-tasks matrix published inside ai-tasks — follow dependency semver and upstream **`CHANGELOG.md`**. Graph-engine does **not** import **`@exellix/xynthesis`** directly; **`@x12i/funcx`** is used only for optional **runx** (conditional edges / `modelConfig.cases`), not for ai-tasks execution strategies (those run via xynthesis inside ai-tasks **8.5+**).
 
 ### Canonical executable graph document (strict boundary)
 
-An executable graph model object may have **only** these **top-level** keys: `id`, `version`, `modelConfig`, `jobKnowledge`, `nodes`, `edges`, `variables`, `response`, `metadata`. The required root **`response`** is the single executable final response contract used to build `ExecuteGraphResult.finalOutput`. Document-model and authoring fields (`name`, `description`, `exellixContractTarget`, `graphExecution`, `graphEntry`, `catalogRequests`, and similar) belong **under `metadata`** only. Node-scoped `taskKnowledge` belongs under each task node, not at the model root. Runtime state (`input`, `jobMemory`, `taskMemory`, `executionMemory`, `outputsMemory`, `aliasConfig`, runtime node overrides) belongs under the execution request’s **`runtime`** object and is rejected on the model.
+An executable graph model object may have **only** these **top-level** keys: `id`, `version`, `modelConfig`, `jobKnowledge`, `nodes`, `edges`, `variables`, `response`, `metadata`. The required root **`response`** is the single executable final response contract used to build `ExecuteGraphResult.finalOutput`. Document-model and authoring fields (`name`, `description`, `exellixContractTarget`, `graphExecution`, `graphEntry`, `catalogRequests`, and similar) belong **under `metadata`** only. Node-scoped `taskKnowledge` belongs under each task node, not at the model root. Runtime state (`input`, `jobMemory`, `taskMemory`, `executionMemory`, `outputsMemory`, per-run options) belongs under the execution request’s **`runtime`** object and is rejected on the model. **`runtime.modelConfig`**, **`runtime.aliasConfig`**, and **`runtime.nodes[id].modelConfig`** were removed in **7.7** — model profiles belong on the graph document only.
 
 `metadata.graphExecution` can document graph execution defaults and labels, including `mode: 'forward' | 'backward' | 'hybrid'`, optional `goalNodeId`, optional `dimension`, `outputMode: 'mappedAggregation' | 'lastExitNode'`, `coreObjective`, optional `nodesResponses`, and metadata-only `flowOutline: 'linearSequence' | 'convergingParallelFlow'`. Planner mode still comes from `executeGraph({ model, runtime }).runtime.mode`; `outputMode` does not decide the returned `finalOutput`.
 
@@ -54,7 +53,7 @@ Enforcement: `executeGraph`, `createExellixGraphRuntime().executeGraph`, `execut
 npm install @exellix/graph-engine
 ```
 
-**Upstream tasks SDK:** This package depends on **`@exellix/ai-tasks` ^7.4.0** (see **`package.json`**). Graph-engine emits **`RunTaskRequest`** shapes that match the v7 closed schema (mandatory **`executionStrategies`**, **`xynthesized`**, optional **`smartInput`**, no legacy root mirrors). Pin compatible versions in your app lockfile. Optional CI improvement: fail or warn when the resolved ai-tasks major/minor drifts outside an allowlist (not enforced in-repo today).
+**Upstream tasks SDK:** This package depends on **`@exellix/ai-tasks` ^8.6.8** and **`@x12i/funcx` 4.4.4** (see **`package.json`**). Graph-engine emits **`RunTaskRequest`** shapes that match the ai-tasks **8.x** closed schema (mandatory **`executionStrategies`**, three-slot **`modelConfig`**, **`xynthesized`**, optional **`smartInput`**, no legacy root mirrors). Pin compatible versions in your app lockfile. Optional CI improvement: fail or warn when the resolved ai-tasks major/minor drifts outside an allowlist (not enforced in-repo today).
 
 ### Execution matrix hosts (`@exellix/exellix-runtime`) — documentation only for the engine
 
@@ -83,7 +82,7 @@ For Firebase Admin, `createCataloxFromEnv`, `listAiSkillsCatalogItems`, and rela
 
 ### Task-node preflight (validation & analysis, no `runTask`)
 
-Graph-engine exposes the **`@exellix/ai-tasks` ≥ 7.6** preflight surface so studios and matrix hosts can validate a node **before** execution without a second dependency:
+Graph-engine exposes the **`@exellix/ai-tasks`** preflight surface so studios and matrix hosts can validate a node **before** execution without a second dependency on ai-tasks:
 
 | Export | Purpose |
 |--------|---------|
@@ -91,7 +90,7 @@ Graph-engine exposes the **`@exellix/ai-tasks` ≥ 7.6** preflight surface so st
 | **`validateTaskNodeRunTaskConfig`** | Static config checks (`agentId`, pipeline, `smartInput`, `llmCall`, …). |
 | **`validateTaskNodeRunTaskInvoke`** | Config + payload path resolution + optional template/smart-input render checks. |
 
-Lower-level helpers (`validateRunTaskConfig`, `validateRunTaskInvoke`, `analyzeExpectedRunTaskInput`, Rendrix `listTokens` / `analyzeTemplateResolution`, …) are **re-exported** from the package root when you already have a `RunTaskRequest`. Catalox-backed skill invoke packet analysis was removed from `@exellix/ai-tasks` — use studio / skills-manager preflight (`@x12i/funcx` analyze-gateway-invoke-request) instead.
+Lower-level helpers (`validateRunTaskConfig`, `validateRunTaskInvoke`, `analyzeExpectedRunTaskInput`, Rendrix `listTokens` / `analyzeTemplateResolution`, …) are **re-exported** from the package root when you already have a `RunTaskRequest`. Catalox-backed skill invoke packet analysis was removed from `@exellix/ai-tasks` **8.6** — use **`@exellix/graph-composer`** for studio / skills-manager invoke preflight (see `@exellix/ai-tasks` `documenations/studio-skill-invoke-preflight.md`).
 
 **Testing safety:** Default `npm test` uses **mocked** Catalox in catalog validation tests and does not open Firestore. Do **not** point `FIRESTORE_LIVE_TESTS` / integration flags at a **production** Firebase project; Catalox’s own docs recommend a dedicated test project for live integration runs.
 
@@ -106,6 +105,22 @@ const runtime = createExellixGraphRuntime({
   tasksClient: myTasksClient,     // TasksClientLike — responses may use `ok` or `success` (both accepted)
 });
 
+// graphModel carries static modelConfig (profile aliases on the graph document — not on runtime).
+const graphModel = {
+  id: 'my-graph',
+  modelConfig: {
+    cases: [{
+      modelConfig: {
+        preActionModel: 'cheap',
+        skillModel: 'balanced',
+        postActionModel: 'cheap',
+      },
+    }],
+  },
+  nodes: [/* … */],
+  // …
+};
+
 // Host correlation id (required). Engine sets `job.id` / `job.jobId` from it and generates `result.taskId`.
 const result = await runtime.executeGraph({
   model: graphModel,
@@ -113,15 +128,7 @@ const result = await runtime.executeGraph({
     jobId: 'job-123',
     job: { agentId: 'agent-1', input: {} },
     input: { question: 'Analyze this record' },
-    // 7.x: graph modelConfig values are profile aliases; concrete models bind here (required).
-    modelConfig: {
-      cases: [{ modelConfig: { xynthesisModel: 'weak', skillModel: 'strong' } }],
-    },
-    aliasConfig: {
-      strong: 'anthropic/claude-sonnet-4',
-      weak: 'google/gemini-2.5-flash',
-      default: 'google/gemini-2.5-flash',
-    },
+    // no modelConfig or aliasConfig on runtime (removed in 7.7)
   },
 });
 
@@ -144,9 +151,9 @@ const runtime = createExellixGraphRuntime({
   graphLoader,
   engineFactory,
   tasksClient,
-  modelConfig,            // optional explicit fallback: { xynthesisModel, skillModel }
   eventEmitter,           // optional graph/node lifecycle events
   playgroundReporter,     // optional
+  runxCreateOptions,      // optional — lazy runx + funcx when graph needs conditional modelConfig / conditions
   // …stepRetryPolicy, runLogMode, concurrency, runTaskDiagnostics, etc.
 });
 
@@ -161,6 +168,9 @@ interface GraphExecutionRequest {
 // Task-node model:   TaskNode
 // Task-node runtime: TaskNodeRuntimeObject at runtime.nodes[nodeId]
 
+// Task-node runtime: TaskNodeRuntimeObject at runtime.nodes[nodeId] — extensible bag;
+// modelConfig / aliasConfig on runtime.nodes were removed in 7.7.
+
 interface GraphRuntimeObject {
   jobId: string;                 // required: host correlation id
   job: any;                      // host envelope: agentId, input, jobType, …
@@ -169,21 +179,13 @@ interface GraphRuntimeObject {
   taskMemory?: any;
   executionMemory?: any;
   variables?: Record<string, any>;
-  /** Run-level model profile override (`cases`); values are alias names, not provider ids. */
-  modelConfig?: { cases: Array<{ when?: unknown; modelConfig: { xynthesisModel: string; skillModel: string } }> };
-  /** Required (7.x): profile alias → concrete provider model id for this execution. */
-  aliasConfig: Record<string, string>;
-  nodes?: Record<string, {
-    /** Per-node profile override (alias names). */
-    modelConfig?: { xynthesisModel: string; skillModel: string };
-    /** Per-node alias bindings (overlay `aliasConfig`). */
-    aliasConfig?: Record<string, string>;
-  }>;
+  /** Per-node runtime bag (must not carry modelConfig or aliasConfig since 7.7). */
+  nodes?: Record<string, Record<string, unknown>>;
   mode?: 'forward' | 'backward' | 'hybrid';
   goalNodeId?: string;           // required when mode === 'backward'
   debugMode?: boolean;           // include per-node trace on result.debug
   failFast?: boolean;            // default: false
-  // …llmCall, stepRetryPolicy, runLogMode, runtimeObjects, runTaskDiagnostics, etc.
+  // …stepRetryPolicy, runLogMode, runtimeObjects, runTaskDiagnostics, etc.
 }
 ```
 
@@ -265,7 +267,7 @@ const markdown = playgroundReporter.getMarkdown();
 
 **Standalone node debugging:** The runtime also exposes **`runtime.executeNode(...)`** for single-node test runs. Provide `node`, `job`, optional `graph` / `execution`, and (when continuing an existing run) `graphRunTaskId` from the parent `ExecuteGraphResult.taskId` so `runTask` and Activix stay aligned.
 
-### `runTask` request contract (`@exellix/ai-tasks` v7.x)
+### `runTask` request contract (`@exellix/ai-tasks` 8.x)
 
 Graph-engine builds a canonical `RunTaskRequest` for every outbound task call it owns: MAIN task-node invokes, engine PRE/POST utility invokes, and `synthesize` finalizer invokes. MAIN request assembly lives in [`src/runtime/buildAiTasksRunTaskRequest.ts`](src/runtime/buildAiTasksRunTaskRequest.ts); all paths follow **`RUNTASK_REQUEST.md`** in `@exellix/ai-tasks`. Types align with **`RunTaskRequest`** / **`ExellixGraphRunTaskRequest`** exported from this package.
 
@@ -277,7 +279,7 @@ Graph-engine builds a canonical `RunTaskRequest` for every outbound task call it
 
 To build `RunTaskRequest` without fallback defaults, the execution request must provide both sides of the contract: `model.id`, `node.id`, `node.skillKey`, explicit `node.taskConfiguration.taskTypeId` (even when it matches `skillKey`), `node.taskConfiguration.executionStrategies` (use `[]` for plain MAIN), `runtime.jobId`, `runtime.job.agentId`, `runtime.job.jobTypeId` or `runtime.job.jobType`, active input/memory, and any model/LLM/diagnostic options needed by the task.
 
-**Model profiles (7.x):** Graph and node `modelConfig` carry **profile alias names** only (`strong`, `weak`, `default`, …) — never provider model ids in graph JSON. **`runtime.aliasConfig` is required** and maps every alias used by the run (including `default` when fallback applies) to concrete provider models. Selection order: `runtime.nodes[nodeId].modelConfig` → `node.taskConfiguration.modelConfig` → `runtime.modelConfig` → `model.modelConfig` → implicit `{ default, default }`; then strict resolution through `runtime.aliasConfig` plus `runtime.nodes[nodeId].aliasConfig`. The **resolved** `{ xynthesisModel, skillModel }` is forwarded to MAIN, engine PRE/POST utility calls, and `synthesize` finalizer calls. Snapshot `aliasConfig` on execution records for reproducibility. See [`BREAKING-CHANGES.md`](BREAKING-CHANGES.md) §7.0.0.
+**Model profiles (7.x+):** Graph and node `modelConfig` carry **profile alias names** only (`cheap`, `balanced`, `deep`, or `profile/choice` keys like `cheap/default`, `cyber/deep_forensics`) — never provider model ids in graph JSON. **Since 7.7**, model selection is **graph-document only**: merge `node.taskConfiguration.modelConfig` (partial override per slot) over `model.modelConfig`, then engine defaults (`cheap` / `balanced` / `cheap`). Graph-engine forwards the three-slot triplet `{ preActionModel, skillModel, postActionModel }` on every outbound `runTask`; **`@exellix/ai-tasks`** resolves aliases via `@x12i/ai-profiles`. **7.7.8+** execute-mode validation accepts partial per-task overrides and `profile/choice` encoding without host-side pre-merge. See [`BREAKING-CHANGES.md`](BREAKING-CHANGES.md) §7.6 / §7.7 / §7.7.8.
 
 Graph-engine still derives correlation fields such as `graphId`, `nodeId`, `coreSkillId`, `masterSkillId`, `taskId`, and `masterSkillActivityId` from those authored values.
 
@@ -286,7 +288,7 @@ Graph-engine still derives correlation fields such as `graphId`, `nodeId`, `core
 - Every MAIN (and engine PRE/POST utility) **`runTask`** includes **`executionStrategies`**: an array of **`ExecutionStrategyInvocation`** objects (semantics defined by **`@exellix/ai-tasks`** / `RUNTASK_REQUEST.md`).
 - **Plain MAIN** (no wrappers): graph-engine sends **`executionStrategies: []`**.
 - Optional task-node authoring: **`taskConfiguration.executionStrategies`** — when present and non-empty, it overrides the default **`[]`** for that node’s MAIN call.
-- Optional catalog metadata: **`taskConfiguration.executionStrategyCatalogItems`** is forwarded to `ai-tasks`; `ai-tasks` still validates the runtime invocation shape and consumes only safe catalog fields such as wrapper default function ids.
+- Optional catalog metadata: **`taskConfiguration.executionStrategyCatalogItems`** is forwarded to `ai-tasks`; planner/optimizer rows use **`runtimeKind: "xynthesis-action"`** in ai-tasks **8.5+** (not funcx). `ai-tasks` still validates the runtime invocation shape and consumes only safe catalog fields such as wrapper default sidekick actions.
 - **Removed in 5.0:** `metadata.executionStrategyKey` typing and code branches. Configure planners/optimizers through **`executionStrategies`** per ai-tasks (see upstream docs / Catalox task-strategy catalogs).
 
 #### `xynthesized` and internal `execution.xynthesized`
@@ -480,7 +482,6 @@ const result = await runtime.executeGraph({
     jobId: 'job-123',
     job: { agentId: 'agent-1', jobType: 'analysis' },
     input: entryInput,
-    aliasConfig: { /* … */ },
     runtimeObjects: buildExellixGraphRuntimeObjects({ graphActivixClient: activixClient }),
   },
 });
@@ -919,7 +920,7 @@ Bundled **graph definitions** (JSON DAGs) live in [`graphs/`](graphs/). **[graph
 
 To execute a graph, supply a `graphLoader` that resolves `graphId` to JSON, build a `job` with the input shape your graph expects (often `execution.input` with `raw` and optional `metadata`), and call `executeGraph`. Further integration notes may live under [.docs/](.docs/).
 
-**`taskConfiguration.aiTasksOutputValidation`** on task nodes is forwarded as **`outputValidation`** on the `runTask` request (**`@exellix/ai-tasks` v7+**). Root **`outputConstraints`** is not part of the closed schema.
+**`taskConfiguration.aiTasksOutputValidation`** on task nodes is forwarded as **`outputValidation`** on the `runTask` request (**`@exellix/ai-tasks` 8.x**). Root **`outputConstraints`** is not part of the closed schema.
 
 ## Runtime observability (`runtimeObjects`)
 

package/dist/src/index.d.ts

@@ -15,7 +15,7 @@
 export type { HostExecuteGraphRunOptions, MainReadinessPolicy, ExecutionStepOption, StepRetryPolicy, ActivixNodeActivityExellixConfig, SkillKeyResolutionOptions, RunTaskRequest as ExellixGraphRunTaskRequest, RunTaskResponse as ExellixGraphRunTaskResponse, } from './types/options.js';
 export type { AiTaskProfileMetadata, AiTaskProfileWebScoping, AiTaskProfileInputSynthesis, } from './types/aiTaskProfile.js';
 export type { ExecutionStrategyInvocation, ExecutionStrategyPhase, ExecutionStrategyWrapperKey, SmartInputConfig, TaskStrategyItemData, XynthesizedDestinationScope, XynthesizedMemory, XynthesizedOutputConfig, } from './types/aiTasksDerivedTypes.js';
-export type { Graph, GraphModelObject, GraphAiModelConfig, GraphModelAliasConfig, GraphRuntimeNodeConfig, TaskNodeRuntimeObject, GraphDocumentMetadata, GraphEntryContract, GraphEntryExecutionInputSpec, GraphEntryInputKind, GraphEntryInputSpecBase, GraphEntryInputSpec, GraphEntryValueInputKind, GraphEntryValueInputSpec, GraphResponseDefinition, GraphResponseMissingBehavior, GraphResponseSelector, GraphResponseShape, GraphResponseContract, GraphResponseMapping, GraphResponseMappingMissingBehavior, GraphResponseMappingSelector, GraphResponseMappingTarget, GraphExecutionDefaults, GraphExecutionMode, GraphOutputMode, GraphFlowOutline, GraphCoreObjective, GraphNodesResponses, GraphNode, TaskNode, TaskNodeConditions, TaskNodeConditionWhen, TaskNodeJsonCondition, TaskNodeJsConditionFunction, TaskNodeAiCondition, TaskNodeConditionParameters, ModelConfigSelection, ModelConfigCase, TaskNodePureMetadata, TaskNodeExecutionPipelineStep, TaskOutputValidation, FinalizerNode, FinalizerInputBinding, OutputSchema, AggregateFinalizerConfig, BundleFinalizerConfig, SelectFinalizerConfig, SynthesizeFinalizerConfig, UtilityExecutionPolicy, Job, CatalogPlanningKind, CatalogRequestStatus, CatalogBinding, ScopedQuestionCatalogRequestEntry, DiscoveryDefinitionCatalogRequestEntry, DiscoveryDefinitionCatalogRequest, DiscoveryDefinitionPlanningFields, CatalogRequestEntry, StructuredDataFiltersV1, ConditionsDataFilters, } from './types/refs.js';
+export type { Graph, GraphModelObject, GraphAiModelConfig, PartialGraphAiModelConfig, GraphModelAliasConfig, GraphRuntimeNodeConfig, TaskNodeRuntimeObject, GraphDocumentMetadata, GraphEntryContract, GraphEntryExecutionInputSpec, GraphEntryInputKind, GraphEntryInputSpecBase, GraphEntryInputSpec, GraphEntryValueInputKind, GraphEntryValueInputSpec, GraphResponseDefinition, GraphResponseMissingBehavior, GraphResponseSelector, GraphResponseShape, GraphResponseContract, GraphResponseMapping, GraphResponseMappingMissingBehavior, GraphResponseMappingSelector, GraphResponseMappingTarget, GraphExecutionDefaults, GraphExecutionMode, GraphOutputMode, GraphFlowOutline, GraphCoreObjective, GraphNodesResponses, GraphNode, TaskNode, TaskNodeConditions, TaskNodeConditionWhen, TaskNodeJsonCondition, TaskNodeJsConditionFunction, TaskNodeAiCondition, TaskNodeConditionParameters, ModelConfigSelection, ModelConfigCase, TaskNodePureMetadata, TaskNodeExecutionPipelineStep, TaskOutputValidation, FinalizerNode, FinalizerInputBinding, OutputSchema, AggregateFinalizerConfig, BundleFinalizerConfig, SelectFinalizerConfig, SynthesizeFinalizerConfig, UtilityExecutionPolicy, Job, CatalogPlanningKind, CatalogRequestStatus, CatalogBinding, ScopedQuestionCatalogRequestEntry, DiscoveryDefinitionCatalogRequestEntry, DiscoveryDefinitionCatalogRequest, DiscoveryDefinitionPlanningFields, CatalogRequestEntry, StructuredDataFiltersV1, ConditionsDataFilters, } from './types/refs.js';
 export { mergeGraphDocumentModel, EXELLIX_GRAPH_MODEL_VARIABLE_KEY, EXELLIX_STRUCTURED_DATA_FILTERS_V1, } from './types/refs.js';
 export type { TaskNodeTaskConfiguration, TaskNodeScopedDataReaderPackSlot, } from './types/taskNodeConfiguration.js';
 export { getTaskConfiguration } from './types/taskNodeConfiguration.js';
@@ -39,7 +39,7 @@ export type { PathSegment } from './runtime/pathExpr.js';
 export { evaluateStructuredDataFilters, evaluateDataFilterPredicate, getStructuredDataFilterPathViolations, isStructuredDataFiltersV1, } from './runtime/dataFiltersEvaluation.js';
 export { evaluateTaskNodeConditions, evaluateConditionWhen, applyConditionNegate, } from './runtime/taskNodeConditionsEvaluation.js';
 export type { TaskNodeConditionsEvalDeps, TaskNodeConditionsEvalResult, TaskNodeConditionEvalContext, } from './runtime/taskNodeConditionsEvaluation.js';
-export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './runtime/resolveModelConfigForNode.js';
+export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfig, mergeGraphAiModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './runtime/resolveModelConfigForNode.js';
 export { looksLikeConcreteModelId, isGraphAiProfileName, assertGraphAiProfileNameString, type RunTaskModelConfigWire, type EngineModelPhase, } from './runtime/graphAiModelConfig.js';
 /** @deprecated Use {@link resolveGraphAiModelConfig}. */
 export { resolveGraphAiModelConfig as resolveGraphAiModelConfigAliases } from './runtime/graphAiModelConfig.js';
@@ -47,7 +47,7 @@ export { resolveGraphAiModelConfig as resolveGraphAiModelConfigAliases } from '.
 export { isGraphAiProfileName as isModelAliasString } from './runtime/graphAiModelConfig.js';
 /** @deprecated Use {@link assertGraphAiProfileNameString}. */
 export { assertGraphAiProfileNameString as assertGraphModelAliasString } from './runtime/graphAiModelConfig.js';
-export { isGraphAiModelConfig, isModelConfigSelection, isEmptyConditionWhen, conditionWhenSignature, countDefaultModelConfigCases, } from './runtime/modelConfigSelection.js';
+export { isGraphAiModelConfig, isPartialGraphAiModelConfig, isModelConfigSelection, isEmptyConditionWhen, conditionWhenSignature, countDefaultModelConfigCases, } from './runtime/modelConfigSelection.js';
 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';
@@ -79,6 +79,7 @@ export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeR
 export type { ActivixQueryableClient, LogxerQueryableClient, LogxerLogLine, PackageRuntimeObjects, RuntimeObjects, BuildExellixGraphRuntimeObjectsInput, RuntimeObjectsObservabilitySummary, } from './runtime/runtimeObjects.js';
 export type { GetJobLogsInput, GetJobLogsResult, QueryableLogLine } from '@x12i/logxer';
 export { assertCanonicalGraphDocument, assertCanonicalTaskNode, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } from './runtime/validateCanonicalGraphDocument.js';
+export type { AssertCanonicalGraphDocumentOptions, CanonicalGraphDocumentValidationMode, } from './runtime/validateCanonicalGraphDocument.js';
 export { assertCanonicalGraphRuntimeObject } from './runtime/validateCanonicalGraphRuntime.js';
 export { GRAPH_ENTRY_STUDIO_ONLY_KEYS, GRAPH_METADATA_STUDIO_ONLY_KEYS, stripGraphModelStudioFields, primaryRuntimeInputFromStudioDocument, getGraphEntryStudioOnlyKeyViolations, getGraphMetadataStudioOnlyKeyViolations, getGraphEntryEmptyInputPathViolations, } from './runtime/graphModelStudioSeparation.js';
 export type { GraphStudioDocument } from './runtime/graphModelStudioSeparation.js';

package/dist/src/index.js

@@ -29,7 +29,7 @@ export { mergeMemory } from './runtime/memory.js';
 export { selectByPath, writeByPath, parsePath } from './runtime/pathExpr.js';
 export { evaluateStructuredDataFilters, evaluateDataFilterPredicate, getStructuredDataFilterPathViolations, isStructuredDataFiltersV1, } from './runtime/dataFiltersEvaluation.js';
 export { evaluateTaskNodeConditions, evaluateConditionWhen, applyConditionNegate, } from './runtime/taskNodeConditionsEvaluation.js';
-export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './runtime/resolveModelConfigForNode.js';
+export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfig, mergeGraphAiModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './runtime/resolveModelConfigForNode.js';
 export { looksLikeConcreteModelId, isGraphAiProfileName, assertGraphAiProfileNameString, } from './runtime/graphAiModelConfig.js';
 /** @deprecated Use {@link resolveGraphAiModelConfig}. */
 export { resolveGraphAiModelConfig as resolveGraphAiModelConfigAliases } from './runtime/graphAiModelConfig.js';
@@ -37,7 +37,7 @@ export { resolveGraphAiModelConfig as resolveGraphAiModelConfigAliases } from '.
 export { isGraphAiProfileName as isModelAliasString } from './runtime/graphAiModelConfig.js';
 /** @deprecated Use {@link assertGraphAiProfileNameString}. */
 export { assertGraphAiProfileNameString as assertGraphModelAliasString } from './runtime/graphAiModelConfig.js';
-export { isGraphAiModelConfig, isModelConfigSelection, isEmptyConditionWhen, conditionWhenSignature, countDefaultModelConfigCases, } from './runtime/modelConfigSelection.js';
+export { isGraphAiModelConfig, isPartialGraphAiModelConfig, isModelConfigSelection, isEmptyConditionWhen, conditionWhenSignature, countDefaultModelConfigCases, } from './runtime/modelConfigSelection.js';
 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';

package/dist/src/inspection/graphModelSelection.js

@@ -1,16 +1,17 @@
-import { isEmptyConditionWhen, isModelConfigSelection } from '../runtime/modelConfigSelection.js';
-import { DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG } from '../runtime/graphAiModelConfig.js';
+import { isEmptyConditionWhen, isModelConfigSelection, isPartialGraphAiModelConfig } from '../runtime/modelConfigSelection.js';
+import { DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, mergeGraphAiModelConfig } from '../runtime/graphAiModelConfig.js';
 function asArrayNodes(graph) {
     return Array.isArray(graph.nodes) ? graph.nodes : Object.values(graph.nodes ?? {});
 }
-/** Returns the no-`when` default case profiles from a selection, if present and valid. */
+/** Returns the no-`when` default case partial profiles from a selection, if present. */
 function defaultCaseProfiles(selection) {
     if (!isModelConfigSelection(selection))
         return undefined;
     const sel = selection;
     for (const c of sel.cases ?? []) {
-        if (isEmptyConditionWhen(c.when))
+        if (isEmptyConditionWhen(c.when) && isPartialGraphAiModelConfig(c.modelConfig)) {
             return c.modelConfig;
+        }
     }
     return undefined;
 }
@@ -36,7 +37,10 @@ function finalizerUsesModel(node) {
  * provider id resolution happens inside `@exellix/ai-tasks`.
  */
 export function inspectGraphModelSelection(graph) {
-    const graphDefaultProfiles = defaultCaseProfiles(graph.modelConfig);
+    const graphDefaultPartial = defaultCaseProfiles(graph.modelConfig);
+    const graphDefaultProfiles = graphDefaultPartial
+        ? mergeGraphAiModelConfig(DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, graphDefaultPartial)
+        : undefined;
     const nodes = [];
     const aliases = new Set();
     const addAliases = (cfg) => {
@@ -76,15 +80,12 @@ export function inspectGraphModelSelection(graph) {
         const taskNode = raw;
         const nodeSelection = taskNode.taskConfiguration?.modelConfig;
         const nodeDefault = defaultCaseProfiles(nodeSelection);
+        const graphPartial = graphDefaultPartial;
         let profiles;
         let source;
-        if (nodeDefault) {
-            profiles = nodeDefault;
-            source = 'node';
-        }
-        else if (graphDefaultProfiles) {
-            profiles = graphDefaultProfiles;
-            source = 'graph';
+        if (nodeDefault != null || graphPartial != null) {
+            profiles = mergeGraphAiModelConfig(DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, graphPartial, nodeDefault);
+            source = nodeDefault != null ? 'node' : 'graph';
         }
         else {
             profiles = DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG;

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -1175,7 +1175,7 @@ export function createExellixGraphRuntime(opts) {
         return runWithAiTasksStackLogging(merged.logging, () => runGraphWithLogContext({ jobId, taskId: graphTaskId, graphId: resolvedGraphId, runId: graphTaskId }, async () => {
             bindGraphEngineRunLogxer(runLogxer);
             try {
-                assertCanonicalGraphDocument(graph, { jobId, graphId: resolvedGraphId });
+                assertCanonicalGraphDocument(graph, { jobId, graphId: resolvedGraphId }, { mode: 'execute' });
                 assertCanonicalGraphRuntimeObject(runtime, { jobId, graphId: resolvedGraphId });
                 let runxClient = opts.runx;
                 if (graphNeedsRunxClient(graph)) {

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

@@ -1,4 +1,4 @@
-import type { GraphAiModelConfig } from '../types/refs.js';
+import type { GraphAiModelConfig, PartialGraphAiModelConfig } from '../types/refs.js';
 /** Wire shape for `@exellix/ai-tasks` `RunTaskRequest.modelConfig` (8.4+). */
 export type RunTaskModelConfigWire = {
     preActionModel: string;
@@ -38,3 +38,8 @@ export type EngineModelPhase = 'pre' | 'main' | 'post';
  * Values are profile alias names from the graph document; ai-tasks resolves and routes slots per phase.
  */
 export declare function toRunTaskModelConfig(config: GraphAiModelConfig): RunTaskModelConfigWire;
+/**
+ * Merges layered partial configs left-to-right; later layers override earlier slots.
+ * Missing slots after all layers fall back to {@link DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG}.
+ */
+export declare function mergeGraphAiModelConfig(...layers: Array<PartialGraphAiModelConfig | undefined>): GraphAiModelConfig;

package/dist/src/runtime/graphAiModelConfig.js

@@ -37,8 +37,6 @@ export function looksLikeConcreteModelId(value) {
     const trimmed = value.trim();
     if (trimmed === '')
         return false;
-    if (trimmed.includes('/'))
-        return true;
     const lower = trimmed.toLowerCase();
     return CONCRETE_MODEL_PREFIXES.some((p) => lower.startsWith(p));
 }
@@ -55,7 +53,7 @@ export function isGraphAiProfileName(value) {
 }
 export function assertGraphAiProfileNameString(value, path, context) {
     if (!isGraphAiProfileName(value)) {
-        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_MODEL_CONFIG, `${path} must be an AI profile alias (non-empty string without "/" or provider prefixes); got ${JSON.stringify(value)}`, context);
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_MODEL_CONFIG, `${path} must be an AI profile alias, profile/choice key, or shortcut (not a concrete provider model id); got ${JSON.stringify(value)}`, context);
     }
 }
 function normalizeModelSlot(slot, context) {
@@ -89,3 +87,26 @@ export function toRunTaskModelConfig(config) {
         postActionModel: config.postActionModel,
     };
 }
+/**
+ * Merges layered partial configs left-to-right; later layers override earlier slots.
+ * Missing slots after all layers fall back to {@link DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG}.
+ */
+export function mergeGraphAiModelConfig(...layers) {
+    const merged = {};
+    for (const layer of layers) {
+        if (layer == null)
+            continue;
+        if (layer.preActionModel != null)
+            merged.preActionModel = layer.preActionModel.trim();
+        if (layer.skillModel != null)
+            merged.skillModel = layer.skillModel.trim();
+        if (layer.postActionModel != null)
+            merged.postActionModel = layer.postActionModel.trim();
+    }
+    const base = DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG;
+    return {
+        preActionModel: merged.preActionModel ?? base.preActionModel,
+        skillModel: merged.skillModel ?? base.skillModel,
+        postActionModel: merged.postActionModel ?? base.postActionModel,
+    };
+}

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

@@ -1,4 +1,6 @@
-import type { GraphAiModelConfig, ModelConfigCase, ModelConfigSelection, TaskNodeConditionWhen } from '../types/refs.js';
+import type { GraphAiModelConfig, ModelConfigCase, ModelConfigSelection, PartialGraphAiModelConfig, TaskNodeConditionWhen } from '../types/refs.js';
+/** True when `value` is a non-empty subset of the three-phase model slots (partial or complete). */
+export declare function isPartialGraphAiModelConfig(value: unknown): value is PartialGraphAiModelConfig;
 export declare function isGraphAiModelConfig(value: unknown): value is GraphAiModelConfig;
 export declare function isEmptyConditionWhen(when: TaskNodeConditionWhen | undefined): boolean;
 export declare function isModelConfigSelection(value: unknown): value is ModelConfigSelection;

package/dist/src/runtime/modelConfigSelection.js

@@ -1,18 +1,23 @@
-export function isGraphAiModelConfig(value) {
+const MODEL_CONFIG_SLOT_KEYS = ['preActionModel', 'skillModel', 'postActionModel'];
+/** True when `value` is a non-empty subset of the three-phase model slots (partial or complete). */
+export function isPartialGraphAiModelConfig(value) {
     if (value == null || typeof value !== 'object' || Array.isArray(value))
         return false;
     const o = value;
     const keys = Object.keys(o);
-    return (keys.length === 3 &&
-        keys.includes('preActionModel') &&
-        keys.includes('skillModel') &&
-        keys.includes('postActionModel') &&
-        typeof o.preActionModel === 'string' &&
-        o.preActionModel.trim() !== '' &&
-        typeof o.skillModel === 'string' &&
-        o.skillModel.trim() !== '' &&
-        typeof o.postActionModel === 'string' &&
-        o.postActionModel.trim() !== '');
+    if (keys.length === 0 || keys.length > MODEL_CONFIG_SLOT_KEYS.length)
+        return false;
+    if (!keys.every((k) => MODEL_CONFIG_SLOT_KEYS.includes(k)))
+        return false;
+    return keys.every((k) => typeof o[k] === 'string' && o[k].trim() !== '');
+}
+export function isGraphAiModelConfig(value) {
+    if (!isPartialGraphAiModelConfig(value))
+        return false;
+    const o = value;
+    return (o.preActionModel != null &&
+        o.skillModel != null &&
+        o.postActionModel != null);
 }
 export function isEmptyConditionWhen(when) {
     if (when == null)

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

@@ -14,8 +14,9 @@ export type ResolveModelConfigForNodeArgs = {
 };
 /**
  * Resolves effective model config for a task node from the graph document only.
- * Precedence: `node.taskConfiguration.modelConfig` → `graph.modelConfig` → engine default profiles.
+ * Merges `node.taskConfiguration.modelConfig` (partial override) over `graph.modelConfig` (job default),
+ * then engine defaults for any remaining slots.
  */
 export declare function resolveModelConfigForNode(args: ResolveModelConfigForNodeArgs): Promise<GraphAiModelConfig>;
 export { conditionWhenSignature, isEmptyConditionWhen };
-export { resolveGraphAiModelConfig, toRunTaskModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';
+export { resolveGraphAiModelConfig, toRunTaskModelConfig, mergeGraphAiModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';

package/dist/src/runtime/resolveModelConfigForNode.js

@@ -1,6 +1,6 @@
-import { conditionWhenSignature, isEmptyConditionWhen, isGraphAiModelConfig, isModelConfigSelection, } from './modelConfigSelection.js';
+import { conditionWhenSignature, isEmptyConditionWhen, isModelConfigSelection, isPartialGraphAiModelConfig, } from './modelConfigSelection.js';
 import { evaluateConditionWhen } from './taskNodeConditionsEvaluation.js';
-import { DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';
+import { DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, mergeGraphAiModelConfig, resolveGraphAiModelConfig, } from './graphAiModelConfig.js';
 async function selectFromCases(selection, ctx, executionInput, runx) {
     const cases = selection.cases;
     if (!Array.isArray(cases) || cases.length === 0)
@@ -16,17 +16,17 @@ async function selectFromCases(selection, ctx, executionInput, runx) {
         const ev = await evaluateConditionWhen(c.when, ctx, executionInput, { runx });
         if (ev.error)
             continue;
-        if (ev.ok && isGraphAiModelConfig(c.modelConfig)) {
+        if (ev.ok && isPartialGraphAiModelConfig(c.modelConfig)) {
             return c.modelConfig;
         }
     }
-    if (defaultCase != null && isGraphAiModelConfig(defaultCase.modelConfig)) {
+    if (defaultCase != null && isPartialGraphAiModelConfig(defaultCase.modelConfig)) {
         return defaultCase.modelConfig;
     }
     return undefined;
 }
 async function resolveTier(value, ctx, executionInput, runx) {
-    if (isGraphAiModelConfig(value))
+    if (isPartialGraphAiModelConfig(value))
         return value;
     if (isModelConfigSelection(value)) {
         return selectFromCases(value, ctx, executionInput, runx);
@@ -35,17 +35,18 @@ async function resolveTier(value, ctx, executionInput, runx) {
 }
 /**
  * Resolves effective model config for a task node from the graph document only.
- * Precedence: `node.taskConfiguration.modelConfig` → `graph.modelConfig` → engine default profiles.
+ * Merges `node.taskConfiguration.modelConfig` (partial override) over `graph.modelConfig` (job default),
+ * then engine defaults for any remaining slots.
  */
 export async function resolveModelConfigForNode(args) {
-    const tiers = [args.nodeModelConfig, args.graphModelConfig];
-    for (const tier of tiers) {
-        const selected = await resolveTier(tier, args.conditionCtx, args.executionInput, args.runx);
-        if (selected != null) {
-            return selected;
-        }
-    }
-    return DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG;
+    const graphPartial = await resolveTier(args.graphModelConfig, args.conditionCtx, args.executionInput, args.runx);
+    const nodePartial = await resolveTier(args.nodeModelConfig, args.conditionCtx, args.executionInput, args.runx);
+    const merged = mergeGraphAiModelConfig(DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, graphPartial, nodePartial);
+    return resolveGraphAiModelConfig(merged, {
+        graphId: args.graphId,
+        nodeId: args.nodeId,
+        jobId: args.jobId,
+    });
 }
 export { conditionWhenSignature, isEmptyConditionWhen };
-export { resolveGraphAiModelConfig, toRunTaskModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';
+export { resolveGraphAiModelConfig, toRunTaskModelConfig, mergeGraphAiModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';

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

@@ -5,12 +5,17 @@ export declare const CANONICAL_GRAPH_TOP_LEVEL_KEYS: readonly ["id", "version",
  * Returns top-level keys on `graph` that are not part of the canonical executable document contract.
  */
 export declare function getCanonicalGraphDocumentViolations(graph: unknown): string[];
+export type CanonicalGraphDocumentValidationMode = 'persist' | 'execute';
+export type AssertCanonicalGraphDocumentOptions = {
+    /** `execute` accepts partial task overrides and profile/choice slot encoding; `persist` stays strict. */
+    mode?: CanonicalGraphDocumentValidationMode;
+};
 /** Single-node validation. Throws `NON_CANONICAL_TASK_NODE` on the first canonical violation. */
 export declare function assertCanonicalTaskNode(node: unknown, context?: {
     jobId?: string;
     graphId?: string;
     nodeIndex?: number;
-}): void;
+}, options?: AssertCanonicalGraphDocumentOptions): void;
 /**
  * Throws {@link ExellixGraphError} when the value is not a canonical graph document
  * (forbidden top-level keys, record-keyed `nodes`, root `outputConstraints`, or any
@@ -22,4 +27,4 @@ export declare function assertCanonicalTaskNode(node: unknown, context?: {
 export declare function assertCanonicalGraphDocument(graph: Graph, context?: {
     jobId?: string;
     graphId?: string;
-}): void;
+}, options?: AssertCanonicalGraphDocumentOptions): void;

package/dist/src/runtime/validateCanonicalGraphDocument.js

@@ -3,7 +3,7 @@ import { ExellixGraphError } from '../errors/ExellixGraphError.js';
 import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
 import { EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY } from '../inspection/types.js';
 import { getStructuredDataFilterPathViolations } from './dataFiltersEvaluation.js';
-import { conditionWhenSignature, countDefaultModelConfigCases, isEmptyConditionWhen, isGraphAiModelConfig, isModelConfigSelection, } from './modelConfigSelection.js';
+import { conditionWhenSignature, countDefaultModelConfigCases, isEmptyConditionWhen, isGraphAiModelConfig, isModelConfigSelection, isPartialGraphAiModelConfig, } from './modelConfigSelection.js';
 import { assertGraphAiProfileNameString } from './graphAiModelConfig.js';
 import { assertCanonicalGraphDocumentMetadata } from './graphModelStudioSeparation.js';
 /** Top-level keys permitted on a canonical exellix-graph executable graph JSON document. */
@@ -273,13 +273,20 @@ function assertOptionalTaskNodeConditions(value, nodeId, context) {
     assertTaskNodeJsCondition(value.jsConditionFunction, `Task node "${nodeId}": conditions.jsConditionFunction`, ctx);
     assertTaskNodeAiCondition(value.aiCondition, `Task node "${nodeId}": conditions.aiCondition`, ctx);
 }
-function assertModelConfigSelection(value, path, context) {
+function assertModelConfigSlotIfPresent(slot, slotPath, context) {
+    if (slot === undefined)
+        return;
+    assertGraphAiProfileNameString(slot, slotPath, context);
+}
+function assertModelConfigSelection(value, path, context, options) {
     if (value === undefined)
         return;
+    const mode = options?.mode ?? 'persist';
+    const allowPartial = mode === 'execute';
     const code = context?.nodeId
         ? ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE
         : ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT;
-    if (isGraphAiModelConfig(value)) {
+    if (isGraphAiModelConfig(value) || (allowPartial && isPartialGraphAiModelConfig(value))) {
         throw new ExellixGraphError(code, `${path}: flat modelConfig was removed. Use { cases: [{ modelConfig: { preActionModel, skillModel, postActionModel } }] } (one case with no \`when\` for a single default).`, context);
     }
     if (!isModelConfigSelection(value)) {
@@ -297,12 +304,24 @@ function assertModelConfigSelection(value, path, context) {
         if (!isPlainObject(c)) {
             throw new ExellixGraphError(code, `${casePath} must be a plain object.`, context);
         }
-        if (!isGraphAiModelConfig(c.modelConfig)) {
-            throw new ExellixGraphError(code, `${casePath}.modelConfig must be { preActionModel: string, skillModel: string, postActionModel: string } with non-empty AI profile names.`, context);
+        const mc = c.modelConfig;
+        const mcValid = allowPartial ? isPartialGraphAiModelConfig(mc) : isGraphAiModelConfig(mc);
+        if (!mcValid) {
+            throw new ExellixGraphError(code, allowPartial
+                ? `${casePath}.modelConfig must include at least one of { preActionModel, skillModel, postActionModel } with non-empty alias or profile/choice values.`
+                : `${casePath}.modelConfig must be { preActionModel: string, skillModel: string, postActionModel: string } with non-empty AI profile names.`, context);
+        }
+        const partial = mc;
+        if (!allowPartial) {
+            assertGraphAiProfileNameString(partial.preActionModel, `${casePath}.modelConfig.preActionModel`, context);
+            assertGraphAiProfileNameString(partial.skillModel, `${casePath}.modelConfig.skillModel`, context);
+            assertGraphAiProfileNameString(partial.postActionModel, `${casePath}.modelConfig.postActionModel`, context);
+        }
+        else {
+            assertModelConfigSlotIfPresent(partial.preActionModel, `${casePath}.modelConfig.preActionModel`, context);
+            assertModelConfigSlotIfPresent(partial.skillModel, `${casePath}.modelConfig.skillModel`, context);
+            assertModelConfigSlotIfPresent(partial.postActionModel, `${casePath}.modelConfig.postActionModel`, context);
         }
-        assertGraphAiProfileNameString(c.modelConfig.preActionModel, `${casePath}.modelConfig.preActionModel`, context);
-        assertGraphAiProfileNameString(c.modelConfig.skillModel, `${casePath}.modelConfig.skillModel`, context);
-        assertGraphAiProfileNameString(c.modelConfig.postActionModel, `${casePath}.modelConfig.postActionModel`, context);
         if (isEmptyConditionWhen(c.when)) {
             continue;
         }
@@ -424,7 +443,7 @@ function isTaskShape(node) {
     return true;
 }
 /** Single-node validation. Throws `NON_CANONICAL_TASK_NODE` on the first canonical violation. */
-export function assertCanonicalTaskNode(node, context) {
+export function assertCanonicalTaskNode(node, context, options) {
     if (!isPlainObject(node)) {
         throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `Graph node at index ${context?.nodeIndex ?? '?'} is not a plain object.`, { jobId: context?.jobId, graphId: context?.graphId });
     }
@@ -479,7 +498,7 @@ export function assertCanonicalTaskNode(node, context) {
         jobId: context?.jobId,
         graphId: context?.graphId,
         nodeId: String(node.id),
-    });
+    }, options);
     assertContextualKnowledgeScope(taskNode.scope, String(node.id), {
         jobId: context?.jobId,
         graphId: context?.graphId,
@@ -548,7 +567,7 @@ export function assertCanonicalTaskNode(node, context) {
  * `variables`, required `response`, and `metadata`); runtime fields belong under the execution
  * request `runtime` object.
  */
-export function assertCanonicalGraphDocument(graph, context) {
+export function assertCanonicalGraphDocument(graph, context, options) {
     const violations = getCanonicalGraphDocumentViolations(graph);
     if (violations.length > 0) {
         const graphId = context?.graphId ??
@@ -583,7 +602,7 @@ export function assertCanonicalGraphDocument(graph, context) {
     assertModelConfigSelection(graph.modelConfig, 'graph.modelConfig', {
         jobId: context?.jobId,
         graphId: resolvedGraphId,
-    });
+    }, options);
     const metadata = isPlainObject(graph.metadata)
         ? graph.metadata
         : undefined;
@@ -613,7 +632,7 @@ export function assertCanonicalGraphDocument(graph, context) {
     // Per-node canonical checks.
     const nodes = graph.nodes;
     for (let i = 0; i < nodes.length; i++) {
-        assertCanonicalTaskNode(nodes[i], { jobId: context?.jobId, graphId: resolvedGraphId, nodeIndex: i });
+        assertCanonicalTaskNode(nodes[i], { jobId: context?.jobId, graphId: resolvedGraphId, nodeIndex: i }, options);
     }
     if (!Object.prototype.hasOwnProperty.call(graph, 'response')) {
         throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `Graph "${String(resolvedGraphId ?? '?')}" must declare root graph.response. Final response shaping must not live under metadata.graphResponse.responseMapping or finalizer output selection.`, { jobId: context?.jobId, graphId: resolvedGraphId });

package/dist/src/types/refs.d.ts

@@ -21,6 +21,12 @@ export type GraphAiModelConfig = {
     skillModel: string;
     postActionModel: string;
 };
+/** Authoring / execute ingress: one or more phase slots; omitted slots inherit at runtime. */
+export type PartialGraphAiModelConfig = {
+    preActionModel?: string;
+    skillModel?: string;
+    postActionModel?: string;
+};
 /**
  * @deprecated Legacy alias map — no longer required for execute. Hosts may omit `runtime.aliasConfig`.
  */
@@ -347,7 +353,7 @@ export type TaskNodeConditions = {
 };
 export type ModelConfigCase = {
     when?: TaskNodeConditionWhen;
-    modelConfig: GraphAiModelConfig;
+    modelConfig: PartialGraphAiModelConfig;
 };
 /** Canonical authoring shape for graph and taskConfiguration model selection. */
 export type ModelConfigSelection = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exellix/graph-engine",
-  "version": "7.7.7",
+  "version": "7.8.0",
   "type": "module",
   "description": "Graph executor SDK",
   "main": "dist/src/index.js",
@@ -52,11 +52,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@exellix/ai-tasks": "^8.6.2",
+    "@exellix/ai-tasks": "^8.6.8",
     "@x12i/activix": "8.5.0",
     "@x12i/catalox": "5.1.3",
     "@x12i/env": "4.0.1",
-    "@x12i/funcx": "4.4.0",
+    "@x12i/funcx": "4.4.4",
     "@x12i/graphenix": "2.5.0",
     "@x12i/graphenix-format": "2.0.0",
     "@x12i/logxer": "^4.6.0",