@exellix/graph-engine 7.4.3 → 7.5.1

package/README.md

@@ -383,12 +383,25 @@ Implemented deterministic finalizer types:
 
 Build an object by mapping named inputs (from `executionMemoryPath` or literals) into output keys.
 
-#### `aggregate` — `strategy: "report-schema"` (multi-section report from execution memory)
+#### `aggregate` — `strategy: "report-schema"` (output object assembled from run memory)
 
-Builds a single object whose keys come from **`config.sections`**: each section specifies a **dot-path** into `executionMemory` (`path`), optional **`title`**, and **`optional`** (when `true`, missing values become `null` instead of throwing).
+Builds the finalizer output object: **`config.sections`** maps each **output field key** to a memory read, using the same `{ type, path }` idiom as finalizer `inputs` and `response.shape` selectors:
 
-- **`collect_tags`**: when `true`, walks all section values and collects unique epistemic strings among `CONFIRMED`, `INFERRED`, `ASSUMED`, `UNKNOWN` into **`collected_tags`** (array).
-- **`meta`**: optional literal key/value pairs merged at the top level of the parsed output.
+```jsonc
+"config": {
+  "strategy": "report-schema",
+  "sections": {
+    "q1": { "type": "executionMemoryPath", "path": "answers.q1", "optional": true },
+    "summary": { "type": "outputsMemoryPath", "path": "report.summary" }
+  },
+  "collectEpistemicTags": true
+}
+```
+
+- Each section: **`type`** (`executionMemoryPath` | `outputsMemoryPath`), **`path`**, and **`optional`** (when `true`, missing values become `null` instead of throwing).
+- **`collectEpistemicTags`**: when `true`, walks all section values and collects unique epistemic strings among `CONFIRMED`, `INFERRED`, `ASSUMED`, `UNKNOWN` into the **`collectedTags`** output field (array).
+
+> **Breaking (model v8):** `sections[].path: string` → `sections[].{ type, path }`; `collect_tags` → `collectEpistemicTags`; output `collected_tags` → `collectedTags`. Section `title` and the literal-merge `meta` block were **removed** — authoring titles and studio hints belong in the studio document, and literal output fields belong in `graph.response.shape`. The validator rejects the old keys with a migration message.
 
 Bundled graphs under [`graphs/`](graphs/) (see [graphs/README.md](graphs/README.md)) use this strategy for multi-section reports, sometimes after **`scoped-answer-assembler`** and **`scoped-answer-writer`** persistence (typical store: **`x-scoped-data`** in deployments that use that collection). The graph file shape is defined in [.docs/exellix-graph-engine-format.md](.docs/exellix-graph-engine-format.md).
 

package/dist/src/index.d.ts

@@ -33,7 +33,6 @@ export { readExecutionVariableBuckets, seedGraphVariableBucketsOnExecution, mirr
 export type { ExecutionVariableBuckets } from './runtime/executionVariableBuckets.js';
 export { resolveTaskNodeInputsForRunTask, resolveTaskNodeTaskVariableForRunTask, resolveTaskNodeInputBindingsForRunTask, } from './runtime/resolveTaskNodeInputs.js';
 export { readTaskNodeInputsConfig, readTaskNodeModelInputSurface, isNodeInputsConfigSelectorType, } from './runtime/readTaskNodeInputsConfig.js';
-export type { TaskNodeInputsConfigCarrier } from './runtime/readTaskNodeInputsConfig.js';
 export { mergeMemory } from './runtime/memory.js';
 export { selectByPath, writeByPath, parsePath } from './runtime/pathExpr.js';
 export type { PathSegment } from './runtime/pathExpr.js';
@@ -51,7 +50,7 @@ export { assertGraphAiProfileNameString as assertGraphModelAliasString } from '.
 export { isGraphAiModelConfig, 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 { mirrorRuntimeInputRawOnExecutionMemory, mirrorStructuredInputOntoExecutionMemory, } from './runtime/materializeStructuredRunTaskInput.js';
+export { mirrorStructuredInputOntoExecutionMemory, } from './runtime/materializeStructuredRunTaskInput.js';
 export { buildRunTaskTaskConfigurationForward } from './runtime/buildRunTaskTaskConfigurationForward.js';
 export { normalizeSmartInputPath, collectSmartInputPaths, normalizeSmartInputConfigForRunTask, } from './runtime/smartInputPaths.js';
 export { evaluateTaskNodeMainReadiness, buildMainReadinessResolutionRoot, resolveMainReadinessPolicy, collectInputSynthesisSourcePaths, } from './runtime/taskNodeMainReadiness.js';
@@ -79,7 +78,9 @@ export type { RunTaskValidationIssue, RunTaskValidationResult, RunTaskInvokeVali
 export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground, EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME, EXELLIX_AI_TASKS_PACKAGE_NAME, } from './runtime/runtimeObjects.js';
 export type { ActivixQueryableClient, LogxerQueryableClient, LogxerLogLine, PackageRuntimeObjects, RuntimeObjects, BuildExellixGraphRuntimeObjectsInput, RuntimeObjectsObservabilitySummary, } from './runtime/runtimeObjects.js';
 export type { GetJobLogsInput, GetJobLogsResult, QueryableLogLine } from '@x12i/logxer';
-export { assertCanonicalGraphDocument, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } from './runtime/validateCanonicalGraphDocument.js';
+export { assertCanonicalGraphDocument, assertCanonicalTaskNode, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } from './runtime/validateCanonicalGraphDocument.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';
 export { computeGraphDocumentContentSha256, stableStringifyGraphDocument, } from './runtime/graphDocumentFingerprint.js';
 export { migrateLegacyGraphResponse, migrateLegacyGraphResponseDefinition, } from './runtime/graphResponseMigration.js';
 export type { MigrateGraphResponseResult } from './runtime/graphResponseMigration.js';
@@ -106,7 +107,7 @@ export type { GraphCatalogValidationIssue } from './integrations/cataloxGraphCat
 export { composeEventEmitters } from './runtime/events.js';
 export { createPlaygroundReporter } from './playground/index.js';
 export type { CreatePlaygroundReporterOptions, PlaygroundDebugArtifact, PlaygroundDebugArtifactKind, PlaygroundDebugSnapshot, PlaygroundReporter, PlaygroundStep, } from './playground/PlaygroundReporter.js';
-export { getNodeScopingQuestion, getNodeMemoryShape, getNodeNarrixDiscovery, fetchNodeScopingData, inspectNode, resolveNodeSkillKey, getGraphNodes, getGraphCatalogs, inspectGraph, collectPredicatePaths, executionMemoryPathTail, executionMemoryTailsMatch, getNodeExecutionMemoryWriteTails, getNodeControlDependencies, getNodeSideEffects, inspectFinalizer, inspectNodeContract, inspectGraphContracts, EXELLIX_VIRTUAL_GRAPH_ENTRY_NODE_ID, EXELLIX_VIRTUAL_GRAPH_RESPONSE_NODE_ID, EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY, EXELLIX_VIRTUAL_BOUNDARY_EDGE_FLAG_KEY, getVirtualGraphEntryLayer, getVirtualGraphResponseLayer, materializeVirtualBoundaryDiagram, stripMaterializedVirtualBoundaryDiagram, validateCatalogPlanning, isCatalogBinding, isCatalogRequestEntry, } from './inspection/index.js';
-export type { NodeScopingQuestion, NodeScopeSource, NodeScopeTarget, NodeScopingData, NodeMemoryShape, MemoryPath, NodeNarrixDiscovery, NodeInspection, GraphInspection, NodeIOEdge, GraphCatalogs, CatalogBindingSummary, CatalogPlanningValidationIssue, GraphVirtualIO, GraphVirtualIONode, GraphVirtualIOEdge, GraphVirtualIONodeRole, VirtualGraphEntryLayer, VirtualGraphResponseLayer, MaterializeVirtualBoundaryDiagramOptions, MaterializedVirtualBoundaryDiagram, MaterializedVirtualBoundaryDiagramMeta, InspectNodeContractOptions, LocalSkillKey, NodeExecutionType, FactProvenance, ProvenancedSection, NodeInputBindingEntry, ScopedDataDependency, NodeInputContract, ExecutionMemoryWriteSpec, NodeOutputContract, NodeSideEffects, ControlBranchEntry, NodeControlContract, NodeValidationContract, FinalizerContractInspection, NodeContractInspection, GraphContractsInspection, } from './inspection/index.js';
+export { getNodeScopingQuestion, getNodeMemoryShape, getNodeNarrixDiscovery, fetchNodeScopingData, inspectNode, resolveNodeSkillKey, getGraphNodes, getGraphCatalogs, inspectGraph, collectPredicatePaths, executionMemoryPathTail, executionMemoryTailsMatch, getNodeExecutionMemoryWriteTails, getNodeControlDependencies, getNodeSideEffects, inspectFinalizer, inspectNodeContract, inspectGraphContracts, EXELLIX_VIRTUAL_GRAPH_ENTRY_NODE_ID, EXELLIX_VIRTUAL_GRAPH_RESPONSE_NODE_ID, EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY, EXELLIX_VIRTUAL_BOUNDARY_EDGE_FLAG_KEY, getVirtualGraphEntryLayer, getVirtualGraphResponseLayer, materializeVirtualBoundaryDiagram, stripMaterializedVirtualBoundaryDiagram, validateCatalogPlanning, isCatalogBinding, isCatalogRequestEntry, inspectGraphModelSelection, } from './inspection/index.js';
+export type { GraphModelSelectionInspection, NodeModelSelection, ModelSelectionSource, NodeScopingQuestion, NodeScopeSource, NodeScopeTarget, NodeScopingData, NodeMemoryShape, MemoryPath, NodeNarrixDiscovery, NodeInspection, GraphInspection, NodeIOEdge, GraphCatalogs, CatalogBindingSummary, CatalogPlanningValidationIssue, GraphVirtualIO, GraphVirtualIONode, GraphVirtualIOEdge, GraphVirtualIONodeRole, VirtualGraphEntryLayer, VirtualGraphResponseLayer, MaterializeVirtualBoundaryDiagramOptions, MaterializedVirtualBoundaryDiagram, MaterializedVirtualBoundaryDiagramMeta, InspectNodeContractOptions, LocalSkillKey, NodeExecutionType, FactProvenance, ProvenancedSection, NodeInputBindingEntry, ScopedDataDependency, NodeInputContract, ExecutionMemoryWriteSpec, NodeOutputContract, NodeSideEffects, ControlBranchEntry, NodeControlContract, NodeValidationContract, FinalizerContractInspection, NodeContractInspection, GraphContractsInspection, } from './inspection/index.js';
 export type { NarrixPreProcessorConfig, WebScopeQuestion, LocalTaskHandler, LocalTaskContext } from './types/narrix.js';
 export type { ScopedDataReaderConfig, ScopedDataReaderOutput, ScopedDataReaderPackOutput, ScopedAnswerAssemblerConfig, ScopedAnswerAssemblerOutput, ScopedAnswerWriterConfig, ScopedAnswerWriterOutput, } from './runtime/localSkills/index.js';

package/dist/src/index.js

@@ -40,7 +40,7 @@ export { assertGraphAiProfileNameString as assertGraphModelAliasString } from '.
 export { isGraphAiModelConfig, 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 { mirrorRuntimeInputRawOnExecutionMemory, mirrorStructuredInputOntoExecutionMemory, } from './runtime/materializeStructuredRunTaskInput.js';
+export { mirrorStructuredInputOntoExecutionMemory, } from './runtime/materializeStructuredRunTaskInput.js';
 export { buildRunTaskTaskConfigurationForward } from './runtime/buildRunTaskTaskConfigurationForward.js';
 export { normalizeSmartInputPath, collectSmartInputPaths, normalizeSmartInputConfigForRunTask, } from './runtime/smartInputPaths.js';
 export { evaluateTaskNodeMainReadiness, buildMainReadinessResolutionRoot, resolveMainReadinessPolicy, collectInputSynthesisSourcePaths, } from './runtime/taskNodeMainReadiness.js';
@@ -58,7 +58,8 @@ export { buildTaskNodeRunTaskRequest, validateTaskNodeRunTaskConfig, validateTas
 /** Re-exported from `@exellix/ai-tasks` — preflight validation and analysis without `runTask`. */
 export { validateRunTaskConfig, validateRunTaskInvoke, analyzeExpectedRunTaskInput, checkExpectedInputAgainstRequest, collectSmartInputValidationIssues, buildRunTaskValidationContext, analyzeRunTaskRequest, validateParsedOutput, analyzeSkillRequest, buildSkillRequestAnalysisPacket, formatSkillRequestAnalysisMarkdown, listTokens, analyzeTemplateResolution, renderSmartInput, extractTokenNamesFromStrings, getSkillTokens, getSkillContent, } from '@exellix/ai-tasks';
 export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground, EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME, EXELLIX_AI_TASKS_PACKAGE_NAME, } from './runtime/runtimeObjects.js';
-export { assertCanonicalGraphDocument, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } from './runtime/validateCanonicalGraphDocument.js';
+export { assertCanonicalGraphDocument, assertCanonicalTaskNode, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } from './runtime/validateCanonicalGraphDocument.js';
+export { GRAPH_ENTRY_STUDIO_ONLY_KEYS, GRAPH_METADATA_STUDIO_ONLY_KEYS, stripGraphModelStudioFields, primaryRuntimeInputFromStudioDocument, getGraphEntryStudioOnlyKeyViolations, getGraphMetadataStudioOnlyKeyViolations, getGraphEntryEmptyInputPathViolations, } from './runtime/graphModelStudioSeparation.js';
 export { computeGraphDocumentContentSha256, stableStringifyGraphDocument, } from './runtime/graphDocumentFingerprint.js';
 export { migrateLegacyGraphResponse, migrateLegacyGraphResponseDefinition, } from './runtime/graphResponseMigration.js';
 export { applyAiTaskProfileWebScopingToNarrix, mapAiTaskProfileQuestionsToWebScopeQuestions, } from './runtime/applyAiTaskProfileWebScopingToNarrix.js';
@@ -81,5 +82,5 @@ export { composeEventEmitters } from './runtime/events.js';
 // Playground (full-visibility MD report)
 export { createPlaygroundReporter } from './playground/index.js';
 // Graph Inspection API
-export { getNodeScopingQuestion, getNodeMemoryShape, getNodeNarrixDiscovery, fetchNodeScopingData, inspectNode, resolveNodeSkillKey, getGraphNodes, getGraphCatalogs, inspectGraph, collectPredicatePaths, executionMemoryPathTail, executionMemoryTailsMatch, getNodeExecutionMemoryWriteTails, getNodeControlDependencies, getNodeSideEffects, inspectFinalizer, inspectNodeContract, inspectGraphContracts, EXELLIX_VIRTUAL_GRAPH_ENTRY_NODE_ID, EXELLIX_VIRTUAL_GRAPH_RESPONSE_NODE_ID, EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY, EXELLIX_VIRTUAL_BOUNDARY_EDGE_FLAG_KEY, getVirtualGraphEntryLayer, getVirtualGraphResponseLayer, materializeVirtualBoundaryDiagram, stripMaterializedVirtualBoundaryDiagram, validateCatalogPlanning, isCatalogBinding, isCatalogRequestEntry, } from './inspection/index.js';
+export { getNodeScopingQuestion, getNodeMemoryShape, getNodeNarrixDiscovery, fetchNodeScopingData, inspectNode, resolveNodeSkillKey, getGraphNodes, getGraphCatalogs, inspectGraph, collectPredicatePaths, executionMemoryPathTail, executionMemoryTailsMatch, getNodeExecutionMemoryWriteTails, getNodeControlDependencies, getNodeSideEffects, inspectFinalizer, inspectNodeContract, inspectGraphContracts, EXELLIX_VIRTUAL_GRAPH_ENTRY_NODE_ID, EXELLIX_VIRTUAL_GRAPH_RESPONSE_NODE_ID, EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY, EXELLIX_VIRTUAL_BOUNDARY_EDGE_FLAG_KEY, getVirtualGraphEntryLayer, getVirtualGraphResponseLayer, materializeVirtualBoundaryDiagram, stripMaterializedVirtualBoundaryDiagram, validateCatalogPlanning, isCatalogBinding, isCatalogRequestEntry, inspectGraphModelSelection, } from './inspection/index.js';
 // Web context rendering — consume execution.webContext → markdown for prompts (Layer 04)

package/dist/src/inspection/graphModelSelection.d.ts

@@ -0,0 +1,33 @@
+import type { Graph, GraphAiModelConfig } from '../types/refs.js';
+/** Where the effective model-profile triplet for a node came from. */
+export type ModelSelectionSource = 'node' | 'graph' | 'default' | 'none';
+export type NodeModelSelection = {
+    nodeId: string;
+    kind: 'task' | 'finalizer';
+    /** False for deterministic finalizers (aggregate / select / bundle); those call no model. */
+    usesModel: boolean;
+    /** Effective default-case profile aliases for this node (undefined when `usesModel` is false). */
+    profiles?: GraphAiModelConfig;
+    source: ModelSelectionSource;
+    /** Count of conditional (`when`-gated) cases that may override the default at runtime. */
+    conditionalCaseCount: number;
+};
+export type GraphModelSelectionInspection = {
+    /** Graph-level default profile aliases (undefined when the graph declares none). */
+    graphDefaultProfiles?: GraphAiModelConfig;
+    nodes: NodeModelSelection[];
+    /** Distinct profile alias names referenced anywhere in the model (for `runtime.aliasConfig` wiring). */
+    aliasesUsed: string[];
+};
+/**
+ * Static, runtime-free view of which model-profile aliases each node would use.
+ *
+ * Answers "where are the models (aliases) that will be used?" without executing:
+ * - task nodes resolve `node.taskConfiguration.modelConfig` (override) → graph `modelConfig` → engine default;
+ * - `synthesize` finalizers use the graph default; other finalizers call no model.
+ *
+ * Only the unconditional (`when`-less) default case is reported per tier; `conditionalCaseCount`
+ * flags nodes whose effective model may change at runtime via gated cases. Alias → concrete
+ * provider id still happens at runtime through `runtime.aliasConfig`.
+ */
+export declare function inspectGraphModelSelection(graph: Graph): GraphModelSelectionInspection;

package/dist/src/inspection/graphModelSelection.js

@@ -0,0 +1,108 @@
+import { isEmptyConditionWhen, isModelConfigSelection } from '../runtime/modelConfigSelection.js';
+import { DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG } 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. */
+function defaultCaseProfiles(selection) {
+    if (!isModelConfigSelection(selection))
+        return undefined;
+    const sel = selection;
+    for (const c of sel.cases ?? []) {
+        if (isEmptyConditionWhen(c.when))
+            return c.modelConfig;
+    }
+    return undefined;
+}
+function conditionalCaseCount(selection) {
+    if (!isModelConfigSelection(selection))
+        return 0;
+    const sel = selection;
+    return (sel.cases ?? []).filter((c) => !isEmptyConditionWhen(c.when)).length;
+}
+/** True for finalizer types that invoke a model (`synthesize`); deterministic kinds do not. */
+function finalizerUsesModel(node) {
+    return node.finalizerType === 'synthesize';
+}
+/**
+ * Static, runtime-free view of which model-profile aliases each node would use.
+ *
+ * Answers "where are the models (aliases) that will be used?" without executing:
+ * - task nodes resolve `node.taskConfiguration.modelConfig` (override) → graph `modelConfig` → engine default;
+ * - `synthesize` finalizers use the graph default; other finalizers call no model.
+ *
+ * Only the unconditional (`when`-less) default case is reported per tier; `conditionalCaseCount`
+ * flags nodes whose effective model may change at runtime via gated cases. Alias → concrete
+ * provider id still happens at runtime through `runtime.aliasConfig`.
+ */
+export function inspectGraphModelSelection(graph) {
+    const graphDefaultProfiles = defaultCaseProfiles(graph.modelConfig);
+    const nodes = [];
+    const aliases = new Set();
+    const addAliases = (cfg) => {
+        if (cfg == null)
+            return;
+        aliases.add(cfg.preActionModel);
+        aliases.add(cfg.skillModel);
+        aliases.add(cfg.postActionModel);
+    };
+    for (const raw of asArrayNodes(graph)) {
+        const node = raw;
+        const isFinalizer = node.type === 'finalizer';
+        if (isFinalizer) {
+            const fin = raw;
+            if (!finalizerUsesModel(fin)) {
+                nodes.push({
+                    nodeId: String(fin.id),
+                    kind: 'finalizer',
+                    usesModel: false,
+                    source: 'none',
+                    conditionalCaseCount: 0,
+                });
+                continue;
+            }
+            const profiles = graphDefaultProfiles ?? DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG;
+            addAliases(profiles);
+            nodes.push({
+                nodeId: String(fin.id),
+                kind: 'finalizer',
+                usesModel: true,
+                profiles,
+                source: graphDefaultProfiles ? 'graph' : 'default',
+                conditionalCaseCount: 0,
+            });
+            continue;
+        }
+        const taskNode = raw;
+        const nodeSelection = taskNode.taskConfiguration?.modelConfig;
+        const nodeDefault = defaultCaseProfiles(nodeSelection);
+        let profiles;
+        let source;
+        if (nodeDefault) {
+            profiles = nodeDefault;
+            source = 'node';
+        }
+        else if (graphDefaultProfiles) {
+            profiles = graphDefaultProfiles;
+            source = 'graph';
+        }
+        else {
+            profiles = DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG;
+            source = 'default';
+        }
+        addAliases(profiles);
+        nodes.push({
+            nodeId: String(taskNode.id),
+            kind: 'task',
+            usesModel: true,
+            profiles,
+            source,
+            conditionalCaseCount: conditionalCaseCount(nodeSelection) + conditionalCaseCount(graph.modelConfig),
+        });
+    }
+    return {
+        graphDefaultProfiles,
+        nodes,
+        aliasesUsed: [...aliases].sort(),
+    };
+}

package/dist/src/inspection/index.d.ts

@@ -15,6 +15,8 @@ export type { CatalogPlanningValidationIssue } from './validateCatalogPlanning.j
 export { collectPredicatePaths, executionMemoryPathTail, executionMemoryTailsMatch, getNodeExecutionMemoryWriteTails, getNodeControlDependencies, } from './controlInspection.js';
 export { getNodeSideEffects, inspectFinalizer, inspectNodeContract, inspectGraphContracts, } from './contractInspection.js';
 export type { InspectNodeContractOptions } from './contractInspection.js';
+export { inspectGraphModelSelection } from './graphModelSelection.js';
+export type { GraphModelSelectionInspection, NodeModelSelection, ModelSelectionSource, } from './graphModelSelection.js';
 export type { NodeScopingQuestion, NodeScopeSource, NodeScopeTarget, NodeScopingData, NodeMemoryShape, MemoryPath, NodeNarrixDiscovery, NodeInspection, GraphInspection, NodeIOEdge, GraphCatalogs, CatalogBindingSummary, GraphVirtualIO, GraphVirtualIONode, GraphVirtualIOEdge, GraphVirtualIONodeRole, VirtualGraphEntryLayer, VirtualGraphResponseLayer, MaterializeVirtualBoundaryDiagramOptions, MaterializedVirtualBoundaryDiagram, MaterializedVirtualBoundaryDiagramMeta, } from './types.js';
 export { EXELLIX_VIRTUAL_GRAPH_ENTRY_NODE_ID, EXELLIX_VIRTUAL_GRAPH_RESPONSE_NODE_ID, EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY, EXELLIX_VIRTUAL_BOUNDARY_EDGE_FLAG_KEY, } from './types.js';
 export type { GraphDocumentMetadata } from '../types/refs.js';

package/dist/src/inspection/index.js

@@ -14,4 +14,5 @@ export { getGraphNodes, getGraphCatalogs, inspectGraph, getVirtualGraphEntryLaye
 export { validateCatalogPlanning, isCatalogBinding, isCatalogRequestEntry, } from './validateCatalogPlanning.js';
 export { collectPredicatePaths, executionMemoryPathTail, executionMemoryTailsMatch, getNodeExecutionMemoryWriteTails, getNodeControlDependencies, } from './controlInspection.js';
 export { getNodeSideEffects, inspectFinalizer, inspectNodeContract, inspectGraphContracts, } from './contractInspection.js';
+export { inspectGraphModelSelection } from './graphModelSelection.js';
 export { EXELLIX_VIRTUAL_GRAPH_ENTRY_NODE_ID, EXELLIX_VIRTUAL_GRAPH_RESPONSE_NODE_ID, EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY, EXELLIX_VIRTUAL_BOUNDARY_EDGE_FLAG_KEY, } from './types.js';

package/dist/src/inspection/nodeInspection.js

@@ -52,7 +52,7 @@ function finalizerRuntimeReadSources(node, graph) {
         for (const [key, spec] of Object.entries(cfg.sections)) {
             if (!isPlainObject(spec))
                 continue;
-            pushDedupedRead(reads, spec.path, `config.sections.${key}`, 'executionMemory');
+            pushDedupedRead(reads, spec.path, `config.sections.${key}`, spec.type === 'outputsMemoryPath' ? 'outputsMemory' : 'executionMemory');
         }
         return reads;
     }
@@ -240,10 +240,8 @@ export function getNodeScopingQuestion(node) {
     const task = node;
     const readability = task.metadata?.graphReadability;
     const name = readability?.title;
-    const legacyInputsConfig = readTaskNodeInputsConfig(task);
     const question = readability?.asks ??
-        (typeof task.taskVariable?.question === 'string' ? task.taskVariable.question : undefined) ??
-        (typeof legacyInputsConfig.question === 'string' ? legacyInputsConfig.question : undefined);
+        (typeof task.taskVariable?.question === 'string' ? task.taskVariable.question : undefined);
     const kind = readability?.kind;
     // Sources
     const sources = [];

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -8,7 +8,7 @@ import { resolveExecutionPipelineForTaskNode } from "./resolveExecutionPipelineF
 import { resolveTaskNodeInputsForRunTask } from "./resolveTaskNodeInputs.js";
 import { assertAiTasksNodeExtensionsValid } from "../inspection/validateAiTasksNodeExtensions.js";
 import { buildRunTaskMainInput, extractCallerInputsBag } from "./resolveGraphEngineMemoryPaths.js";
-import { mirrorRuntimeInputRawOnExecutionMemory, mirrorStructuredInputOntoExecutionMemory, } from "./materializeStructuredRunTaskInput.js";
+import { mirrorStructuredInputOntoExecutionMemory, } from "./materializeStructuredRunTaskInput.js";
 import { buildMainReadinessResolutionRoot, evaluateTaskNodeMainReadiness, resolveMainReadinessPolicy, } from "./taskNodeMainReadiness.js";
 import { mergeXynthesizedPatchIntoExecution, seedGraphRunExecutionState, xynthesizedOutboundForNode, } from "./graphRunExecutionSeed.js";
 import { buildTaskNodeJobContext } from "./buildTaskNodeJobContext.js";
@@ -253,7 +253,6 @@ function normalizeRuntimeExecutionMemory(runtime) {
     if (isPlainRecord(runtime.inputs)) {
         execution.inputs = { ...runtime.inputs };
     }
-    mirrorRuntimeInputRawOnExecutionMemory(execution);
     return execution;
 }
 function normalizeRuntimeOutputsMemory(runtime) {
@@ -681,7 +680,6 @@ export function createExellixGraphRuntime(opts) {
         const clearSynthForTask = input.clearSynthesizedContextPerNode === true &&
             hasSynthesizedContextPreStep &&
             hasExistingSynthesizedContext;
-        mirrorRuntimeInputRawOnExecutionMemory(executionRec);
         const nodeBindings = resolveTaskNodeInputsForRunTask({
             node: input.node,
             execution: executionRec,

package/dist/src/runtime/finalizers/executeFinalizer.js

@@ -171,7 +171,7 @@ function executeAggregateQuestionDriven(args) {
                 path: `config.items.${outKey}.nodeId`,
             });
         }
-        const questionPath = spec.questionPath ?? 'inputs.question';
+        const questionPath = spec.questionPath ?? 'taskVariable.question';
         const question = getByDotPath(node, questionPath);
         if (typeof question !== 'string' || question.length === 0) {
             throw createFinalizerError({
@@ -284,11 +284,12 @@ function collectEpistemicTags(value, found) {
     }
 }
 function executeReportSchema(args) {
-    const { cfg, executionMemory } = args;
+    const { cfg, executionMemory, outputsMemory } = args;
     const finalizerNodeId = String(args.finalizer.id);
     const out = {};
     for (const [key, spec] of Object.entries(cfg.sections ?? {})) {
-        let v = getByDotPath(executionMemory, spec.path);
+        const root = spec.type === 'outputsMemoryPath' ? outputsMemory : executionMemory;
+        let v = getByDotPath(root, spec.path);
         if (isNodeFailureMarker(v)) {
             if (spec.optional === true) {
                 out[key] = null;
@@ -296,7 +297,7 @@ function executeReportSchema(args) {
             }
             throw createFinalizerError({
                 code: 'GRAPH_FINALIZER_NODE_FAILED',
-                message: `report-schema: section "${key}" points at a failed graph node (path="${spec.path}")`,
+                message: `report-schema: section "${key}" points at a failed graph node (${spec.type}="${spec.path}")`,
                 finalizerNodeId,
                 path: `config.sections.${key}`,
                 details: { spec, marker: v },
@@ -305,7 +306,7 @@ function executeReportSchema(args) {
         if ((v === undefined || v === null) && spec.optional !== true) {
             throw createFinalizerError({
                 code: 'GRAPH_FINALIZER_INPUT_MISSING',
-                message: `report-schema: required section "${key}" not found at path "${spec.path}"`,
+                message: `report-schema: required section "${key}" not found at ${spec.type} "${spec.path}"`,
                 finalizerNodeId,
                 path: `config.sections.${key}`,
                 details: { spec },
@@ -313,16 +314,11 @@ function executeReportSchema(args) {
         }
         out[key] = v ?? null;
     }
-    if (cfg.collect_tags) {
+    if (cfg.collectEpistemicTags) {
         const tags = new Set();
         for (const v of Object.values(out))
             collectEpistemicTags(v, tags);
-        out.collected_tags = Array.from(tags);
-    }
-    if (cfg.meta) {
-        for (const [k, v] of Object.entries(cfg.meta)) {
-            out[k] = v;
-        }
+        out.collectedTags = Array.from(tags);
     }
     return out;
 }

package/dist/src/runtime/finalizers/validateFinalizer.js

@@ -55,7 +55,8 @@ export function collectRequiredFinalizerExecutionMemoryReads(finalizer, graph) {
         for (const [key, spec] of Object.entries(cfg.sections)) {
             if (!isPlainObject(spec))
                 continue;
-            pushRequiredRead(reads, 'execution', spec.path, `config.sections.${key}`, spec.optional);
+            const memory = spec.type === 'outputsMemoryPath' ? 'outputs' : 'execution';
+            pushRequiredRead(reads, memory, spec.path, `config.sections.${key}`, spec.optional);
         }
         return reads;
     }
@@ -180,6 +181,46 @@ export function assertFinalizerRequiredReadsResolvable(args) {
         }
     }
 }
+/** Validates a `{ type: executionMemoryPath | outputsMemoryPath, path, optional? }` memory read. */
+function validateMemoryRef(ref, path, finalizerNodeId, label) {
+    if (!isPlainObject(ref)) {
+        throw createFinalizerError({
+            code: 'GRAPH_FINALIZER_INVALID',
+            message: `${label} at ${path} must be an object { type, path }`,
+            finalizerNodeId,
+            path,
+            details: { ref },
+        });
+    }
+    const type = ref.type;
+    if (type !== 'executionMemoryPath' && type !== 'outputsMemoryPath') {
+        throw createFinalizerError({
+            code: 'GRAPH_FINALIZER_INVALID',
+            message: `${label} at ${path} must declare type "executionMemoryPath" or "outputsMemoryPath" (got ${String(type)})`,
+            finalizerNodeId,
+            path: `${path}.type`,
+            details: { ref },
+        });
+    }
+    const p = ref.path;
+    if (typeof p !== 'string' || p.length === 0) {
+        throw createFinalizerError({
+            code: 'GRAPH_FINALIZER_INVALID',
+            message: `${label} at ${path} requires a non-empty path`,
+            finalizerNodeId,
+            path: `${path}.path`,
+        });
+    }
+    const optional = ref.optional;
+    if (optional !== undefined && typeof optional !== 'boolean') {
+        throw createFinalizerError({
+            code: 'GRAPH_FINALIZER_INVALID',
+            message: `${label} at ${path} optional must be boolean when provided`,
+            finalizerNodeId,
+            path: `${path}.optional`,
+        });
+    }
+}
 function validateBinding(name, b, finalizerNodeId) {
     if (!isPlainObject(b)) {
         throw createFinalizerError({
@@ -245,54 +286,57 @@ function validateAggregateConfig(cfg, finalizerNodeId) {
         return;
     }
     if (strategy === 'report-schema') {
-        const sections = cfg.sections;
-        if (sections !== undefined && !isPlainObject(sections)) {
+        const REPORT_SCHEMA_ALLOWED_KEYS = new Set(['strategy', 'sections', 'collectEpistemicTags']);
+        const REPORT_SCHEMA_REMOVED_KEYS = {
+            collect_tags: 'collectEpistemicTags (boolean)',
+            meta: 'removed — put literal output fields in graph.response.shape, and authoring titles in the studio document',
+            title: 'removed from sections — authoring titles belong in the studio document',
+            schemaVersion: 'removed — not part of the executable model',
+            skeletonFromConcept: 'removed — studio authoring hint, not part of the executable model',
+        };
+        for (const key of Object.keys(cfg)) {
+            if (REPORT_SCHEMA_ALLOWED_KEYS.has(key))
+                continue;
+            const migration = REPORT_SCHEMA_REMOVED_KEYS[key];
             throw createFinalizerError({
                 code: 'GRAPH_FINALIZER_INVALID',
-                message: `report-schema aggregate finalizer config.sections must be an object when provided`,
+                message: migration
+                    ? `report-schema finalizer config.${key} is no longer supported. Use: ${migration}.`
+                    : `report-schema finalizer has unknown config key "${key}". Allowed: ${[...REPORT_SCHEMA_ALLOWED_KEYS].join(', ')}.`,
                 finalizerNodeId,
-                path: 'config.sections',
+                path: `config.${key}`,
                 details: { config: cfg },
             });
         }
-        if (isPlainObject(sections)) {
-            for (const [k, spec] of Object.entries(sections)) {
-                if (!isPlainObject(spec) || typeof spec.path !== 'string' || spec.path.length === 0) {
-                    throw createFinalizerError({
-                        code: 'GRAPH_FINALIZER_INVALID',
-                        message: `report-schema section "${k}" must have a non-empty path`,
-                        finalizerNodeId,
-                        path: `config.sections.${k}.path`,
-                        details: { spec },
-                    });
-                }
-                const optional = spec.optional;
-                if (optional !== undefined && typeof optional !== 'boolean') {
-                    throw createFinalizerError({
-                        code: 'GRAPH_FINALIZER_INVALID',
-                        message: `report-schema section "${k}" optional must be boolean when provided`,
-                        finalizerNodeId,
-                        path: `config.sections.${k}.optional`,
-                    });
-                }
-            }
-        }
-        const collectTags = cfg.collect_tags;
-        if (collectTags !== undefined && typeof collectTags !== 'boolean') {
+        const sections = cfg.sections;
+        if (!isPlainObject(sections) || Object.keys(sections).length === 0) {
             throw createFinalizerError({
                 code: 'GRAPH_FINALIZER_INVALID',
-                message: `report-schema aggregate finalizer config.collect_tags must be boolean when provided`,
+                message: `report-schema aggregate finalizer requires a non-empty config.sections object (output key → { type, path }).`,
                 finalizerNodeId,
-                path: 'config.collect_tags',
+                path: 'config.sections',
+                details: { config: cfg },
             });
         }
-        const meta = cfg.meta;
-        if (meta !== undefined && !isPlainObject(meta)) {
+        for (const [k, spec] of Object.entries(sections)) {
+            validateMemoryRef(spec, `config.sections.${k}`, finalizerNodeId, 'report-schema section');
+            const title = spec.title;
+            if (title !== undefined) {
+                throw createFinalizerError({
+                    code: 'GRAPH_FINALIZER_INVALID',
+                    message: `report-schema section "${k}" no longer accepts "title"; move authoring titles to the studio document.`,
+                    finalizerNodeId,
+                    path: `config.sections.${k}.title`,
+                });
+            }
+        }
+        const collectTags = cfg.collectEpistemicTags;
+        if (collectTags !== undefined && typeof collectTags !== 'boolean') {
             throw createFinalizerError({
                 code: 'GRAPH_FINALIZER_INVALID',
-                message: `report-schema aggregate finalizer config.meta must be an object when provided`,
+                message: `report-schema aggregate finalizer config.collectEpistemicTags must be boolean when provided`,
                 finalizerNodeId,
-                path: 'config.meta',
+                path: 'config.collectEpistemicTags',
             });
         }
         return;

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

@@ -0,0 +1,43 @@
+import type { Graph } from '../types/refs.js';
+/** Example payloads and playground request samples — studio DB only, not graph model. */
+export declare const GRAPH_ENTRY_STUDIO_ONLY_KEYS: readonly ["exampleInput", "exampleInputs", "requestExample"];
+/** Planning / UI metadata — studio DB only, not versioned executable graph model. */
+export declare const GRAPH_METADATA_STUDIO_ONLY_KEYS: readonly ["requestId", "graphConcept", "graphsStudio"];
+export type GraphEntryStudioOnlyKey = (typeof GRAPH_ENTRY_STUDIO_ONLY_KEYS)[number];
+export type GraphMetadataStudioOnlyKey = (typeof GRAPH_METADATA_STUDIO_ONLY_KEYS)[number];
+/**
+ * Studio-side companion document keyed by graph id (graphs-studio database).
+ * Not part of {@link GraphModelObject} / canonical graph JSON.
+ */
+export type GraphStudioDocument = {
+    graphId: string;
+    graphConcept?: Record<string, unknown>;
+    graphsStudio?: Record<string, unknown>;
+    /** Flat {@link GraphRuntimeObject.input} examples for playground and tests. */
+    exampleInputs?: Array<{
+        title?: string;
+        runtimeInput: Record<string, unknown>;
+    }>;
+    [key: string]: unknown;
+};
+export declare function getGraphEntryStudioOnlyKeyViolations(graphEntry: unknown): GraphEntryStudioOnlyKey[];
+export declare function getGraphMetadataStudioOnlyKeyViolations(metadata: unknown): GraphMetadataStudioOnlyKey[];
+/** Returns dot-paths under graphEntry.inputs with empty `path` for value kinds. */
+export declare function getGraphEntryEmptyInputPathViolations(graphEntry: unknown): string[];
+/**
+ * Deep-clones a graph model and removes studio-only metadata and graphEntry example fields.
+ * Use at publish time when upstream serializers still attach playground artifacts.
+ */
+export declare function stripGraphModelStudioFields(graph: Graph): Graph;
+export declare function assertCanonicalGraphEntryContract(graphEntry: unknown, context: {
+    jobId?: string;
+    graphId?: string;
+    graphLabel?: string;
+}): void;
+export declare function assertCanonicalGraphDocumentMetadata(metadata: unknown, context: {
+    jobId?: string;
+    graphId?: string;
+    graphLabel?: string;
+}): void;
+/** Primary flat runtime input from a studio companion document. */
+export declare function primaryRuntimeInputFromStudioDocument(studio: GraphStudioDocument | undefined): Record<string, unknown> | undefined;

package/dist/src/runtime/graphModelStudioSeparation.js

@@ -0,0 +1,102 @@
+import { ExellixGraphError } from '../errors/ExellixGraphError.js';
+import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
+/** Example payloads and playground request samples — studio DB only, not graph model. */
+export const GRAPH_ENTRY_STUDIO_ONLY_KEYS = [
+    'exampleInput',
+    'exampleInputs',
+    'requestExample',
+];
+/** Planning / UI metadata — studio DB only, not versioned executable graph model. */
+export const GRAPH_METADATA_STUDIO_ONLY_KEYS = [
+    'requestId',
+    'graphConcept',
+    'graphsStudio',
+];
+function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+function isValueInputSpec(spec) {
+    return spec.kind !== 'execution';
+}
+export function getGraphEntryStudioOnlyKeyViolations(graphEntry) {
+    if (!isPlainObject(graphEntry))
+        return [];
+    return GRAPH_ENTRY_STUDIO_ONLY_KEYS.filter((key) => Object.prototype.hasOwnProperty.call(graphEntry, key));
+}
+export function getGraphMetadataStudioOnlyKeyViolations(metadata) {
+    if (!isPlainObject(metadata))
+        return [];
+    return GRAPH_METADATA_STUDIO_ONLY_KEYS.filter((key) => Object.prototype.hasOwnProperty.call(metadata, key));
+}
+/** Returns dot-paths under graphEntry.inputs with empty `path` for value kinds. */
+export function getGraphEntryEmptyInputPathViolations(graphEntry) {
+    if (!isPlainObject(graphEntry))
+        return [];
+    const inputs = graphEntry.inputs;
+    if (!Array.isArray(inputs))
+        return [];
+    const bad = [];
+    for (let i = 0; i < inputs.length; i++) {
+        const spec = inputs[i];
+        if (!isPlainObject(spec))
+            continue;
+        if (spec.kind === 'execution')
+            continue;
+        const path = typeof spec.path === 'string' ? spec.path.trim() : '';
+        if (!path)
+            bad.push(`metadata.graphEntry.inputs[${i}].path`);
+    }
+    return bad;
+}
+/**
+ * Deep-clones a graph model and removes studio-only metadata and graphEntry example fields.
+ * Use at publish time when upstream serializers still attach playground artifacts.
+ */
+export function stripGraphModelStudioFields(graph) {
+    const clone = structuredClone(graph);
+    if (isPlainObject(clone.metadata)) {
+        const meta = { ...clone.metadata };
+        for (const key of GRAPH_METADATA_STUDIO_ONLY_KEYS) {
+            delete meta[key];
+        }
+        if (isPlainObject(meta.graphEntry)) {
+            const ge = { ...meta.graphEntry };
+            for (const key of GRAPH_ENTRY_STUDIO_ONLY_KEYS) {
+                delete ge[key];
+            }
+            meta.graphEntry = ge;
+        }
+        clone.metadata = meta;
+    }
+    return clone;
+}
+export function assertCanonicalGraphEntryContract(graphEntry, context) {
+    const label = context.graphLabel ?? `Graph "${String(context.graphId ?? '?')}"`;
+    const studioKeys = getGraphEntryStudioOnlyKeyViolations(graphEntry);
+    if (studioKeys.length > 0) {
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `${label}: metadata.graphEntry must not include studio-only example field(s): ${studioKeys.join(', ')}. Store example payloads in the graphs-studio database (GraphStudioDocument.exampleInputs), not in the executable graph model.`, { ...context, graphEntryStudioOnlyKeys: studioKeys });
+    }
+    const emptyPaths = getGraphEntryEmptyInputPathViolations(graphEntry);
+    if (emptyPaths.length > 0) {
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `${label}: metadata.graphEntry.inputs must declare a non-empty dot-path under merged execution (e.g. "input" or "input.subnetId"); empty path at ${emptyPaths.join(', ')}.`, { ...context, graphEntryEmptyInputPaths: emptyPaths });
+    }
+}
+export function assertCanonicalGraphDocumentMetadata(metadata, context) {
+    const label = context.graphLabel ?? `Graph "${String(context.graphId ?? '?')}"`;
+    const studioKeys = getGraphMetadataStudioOnlyKeyViolations(metadata);
+    if (studioKeys.length > 0) {
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `${label}: metadata must not include studio-only field(s): ${studioKeys.join(', ')}. Move planning and UI metadata to the graphs-studio database (GraphStudioDocument), not the executable graph model.`, { ...context, metadataStudioOnlyKeys: studioKeys });
+    }
+    if (isPlainObject(metadata) && metadata.graphEntry != null) {
+        assertCanonicalGraphEntryContract(metadata.graphEntry, context);
+    }
+}
+/** Primary flat runtime input from a studio companion document. */
+export function primaryRuntimeInputFromStudioDocument(studio) {
+    const first = studio?.exampleInputs?.[0];
+    const runtimeInput = first?.runtimeInput;
+    if (runtimeInput != null && isPlainObject(runtimeInput) && !Array.isArray(runtimeInput)) {
+        return runtimeInput;
+    }
+    return undefined;
+}

package/dist/src/runtime/graphResponseMapping.js

@@ -1,5 +1,5 @@
 import { selectByPath } from './pathExpr.js';
-import { isNodeInputsConfigSelectorType, readTaskNodeModelInputSurface, } from './readTaskNodeInputsConfig.js';
+import { readTaskNodeModelInputSurface, } from './readTaskNodeInputsConfig.js';
 const GRAPH_RESPONSE_MAPPING_ERROR_CODE = 'GRAPH_RESPONSE_MAPPING_INVALID';
 const OMIT = Symbol('graphResponseMapping.omit');
 const FORBIDDEN_GRAPH_RESPONSE_KEYS = [
@@ -30,7 +30,6 @@ function isSupportedSelector(v) {
         v.type === 'executionPath' ||
         v.type === 'nodeMetadata' ||
         v.type === 'nodeInputsConfig' ||
-        v.type === 'nodeInputs' ||
         v.type === 'literal' ||
         v.type === 'firstPresent');
 }
@@ -94,7 +93,7 @@ function resolveSelector(selector, context, path, missing) {
         }
         return presentOrMissing(selectByPath(node.metadata, sourcePath), missing);
     }
-    if (isNodeInputsConfigSelectorType(selector.type)) {
+    if (selector.type === 'nodeInputsConfig') {
         const inputSelector = selector;
         const nodeId = assertNonEmptyString(inputSelector.nodeId, `${path}.nodeId`, `${selector.type}.nodeId`);
         const sourcePath = assertNonEmptyString(inputSelector.path, `${path}.path`, `${selector.type}.path`);

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

@@ -1,8 +1,3 @@
-/**
- * Ensures `executionMemory.input.raw` holds the active MAIN payload for PRE synthesis paths
- * (e.g. `inputsConfig` bindings with `path: "input.raw"`).
- */
-export declare function mirrorRuntimeInputRawOnExecutionMemory(executionMemory: Record<string, unknown>): void;
 /**
  * Mirrors MAIN task input onto `executionMemory.input` for the current graph run.
  */

package/dist/src/runtime/materializeStructuredRunTaskInput.js

@@ -1,24 +1,6 @@
 function isPlainObject(v) {
     return v != null && typeof v === 'object' && !Array.isArray(v);
 }
-/**
- * Ensures `executionMemory.input.raw` holds the active MAIN payload for PRE synthesis paths
- * (e.g. `inputsConfig` bindings with `path: "input.raw"`).
- */
-export function mirrorRuntimeInputRawOnExecutionMemory(executionMemory) {
-    const main = executionMemory.input;
-    if (main === undefined)
-        return;
-    const raw = isPlainObject(main)
-        ? (() => {
-            const copy = { ...main };
-            delete copy.raw;
-            return copy;
-        })()
-        : main;
-    const prev = isPlainObject(executionMemory.input) ? executionMemory.input : {};
-    executionMemory.input = { ...prev, raw };
-}
 /**
  * Mirrors MAIN task input onto `executionMemory.input` for the current graph run.
  */

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

@@ -1,22 +1,11 @@
 import type { TaskNode } from '../types/refs.js';
-export type TaskNodeInputsConfigCarrier = TaskNode & {
-    /** Runtime payload bindings (`executionMemoryPath`); canonical task-node field. */
-    inputsConfig?: Record<string, unknown>;
-    /** @deprecated Prefer `inputsConfig`. */
-    inputBindings?: Record<string, unknown>;
-    /**
-     * @deprecated Prefer `inputsConfig` — collides with `runtime.inputs` (caller bag)
-     * and `RunTaskRequest.inputs` on the wire.
-     */
-    inputs?: Record<string, unknown>;
-};
 /**
- * Reads a task node's runtime binding recipe with backward-compatible fallbacks.
+ * Reads a task node's runtime binding recipe (`inputsConfig` only).
  * Finalizers use `FinalizerNode.inputs` directly; this helper is for task nodes only.
  */
 export declare function readTaskNodeInputsConfig(node: TaskNode): Record<string, unknown>;
 /**
- * Model surface for graph.response selectors (`nodeInputsConfig` / legacy `nodeInputs`):
+ * Model surface for graph.response `nodeInputsConfig` selectors:
  * runtime bindings plus `taskVariable` (taskVariable wins on key collision).
  */
 export declare function readTaskNodeModelInputSurface(node: TaskNode): Record<string, unknown>;

package/dist/src/runtime/readTaskNodeInputsConfig.js

@@ -1,17 +1,16 @@
 /**
- * Reads a task node's runtime binding recipe with backward-compatible fallbacks.
+ * Reads a task node's runtime binding recipe (`inputsConfig` only).
  * Finalizers use `FinalizerNode.inputs` directly; this helper is for task nodes only.
  */
 export function readTaskNodeInputsConfig(node) {
-    const n = node;
-    const recipe = n.inputsConfig ?? n.inputBindings ?? n.inputs;
+    const recipe = node.inputsConfig;
     if (recipe != null && typeof recipe === 'object' && !Array.isArray(recipe)) {
         return recipe;
     }
     return {};
 }
 /**
- * Model surface for graph.response selectors (`nodeInputsConfig` / legacy `nodeInputs`):
+ * Model surface for graph.response `nodeInputsConfig` selectors:
  * runtime bindings plus `taskVariable` (taskVariable wins on key collision).
  */
 export function readTaskNodeModelInputSurface(node) {
@@ -23,5 +22,5 @@ export function readTaskNodeModelInputSurface(node) {
     return bindings;
 }
 export function isNodeInputsConfigSelectorType(type) {
-    return type === 'nodeInputsConfig' || type === 'nodeInputs';
+    return type === 'nodeInputsConfig';
 }

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

@@ -8,9 +8,7 @@ export declare function resolveTaskNodeTaskVariableForRunTask(args: {
     node: TaskNode;
     buckets: ExecutionVariableBuckets;
 }): Record<string, unknown>;
-/**
- * Resolves runtime payload bindings from `node.inputsConfig` only (plus deprecated aliases).
- */
+/** Resolves runtime payload bindings from `node.inputsConfig` only. */
 export declare function resolveTaskNodeInputBindingsForRunTask(args: {
     node: TaskNode;
     execution: Record<string, unknown>;

package/dist/src/runtime/resolveTaskNodeInputs.js

@@ -81,9 +81,7 @@ function resolveTaskVariableValue(val, buckets) {
     }
     return Object.keys(nested).length > 0 ? nested : val;
 }
-/**
- * Resolves runtime payload bindings from `node.inputsConfig` only (plus deprecated aliases).
- */
+/** Resolves runtime payload bindings from `node.inputsConfig` only. */
 export function resolveTaskNodeInputBindingsForRunTask(args) {
     const recipe = readTaskNodeInputsConfig(args.node);
     const out = {};
@@ -102,39 +100,16 @@ export function resolveTaskNodeInputBindingsForRunTask(args) {
     }
     return out;
 }
-/** Legacy literals / variable refs still under deprecated `inputs`. */
-function resolveLegacyTaskVariableFromInputBindings(args) {
-    const recipe = readTaskNodeInputsConfig(args.node);
-    const out = {};
-    for (const [key, val] of Object.entries(recipe)) {
-        if (isExecutionMemoryBinding(val))
-            continue;
-        if (isPlainObject(val) && typeof val.$path === 'string') {
-            const p = val.$path.trim();
-            if (!p.startsWith('variables.') && !p.startsWith('jobVariables.') && !p.startsWith('taskVariables.')) {
-                continue;
-            }
-        }
-        const resolved = resolveTaskVariableValue(val, args.buckets);
-        if (resolved !== undefined)
-            out[key] = resolved;
-    }
-    return out;
-}
 /**
  * Resolves task-node model input for MAIN `RunTaskRequest.input`:
  * `taskVariable` plus execution-memory bindings (separate buckets, no merge).
  */
 export function resolveTaskNodeInputsForRunTask(args) {
     const buckets = readExecutionVariableBuckets(args.execution);
-    const legacyTaskVar = resolveLegacyTaskVariableFromInputBindings({
-        node: args.node,
-        buckets,
-    });
     const taskVariable = resolveTaskNodeTaskVariableForRunTask({ node: args.node, buckets });
     const bindings = resolveTaskNodeInputBindingsForRunTask({
         node: args.node,
         execution: args.execution,
     });
-    return { ...legacyTaskVar, ...taskVariable, ...bindings };
+    return { ...taskVariable, ...bindings };
 }

package/dist/src/runtime/taskNodeRunTaskPreflight.js

@@ -7,7 +7,7 @@ import { resolveExecutionPipelineForTaskNode } from './resolveExecutionPipelineF
 import { resolveTaskNodeInputsForRunTask } from './resolveTaskNodeInputs.js';
 import { assertAiTasksNodeExtensionsValid } from '../inspection/validateAiTasksNodeExtensions.js';
 import { buildRunTaskMainInput, extractCallerInputsBag } from './resolveGraphEngineMemoryPaths.js';
-import { mirrorRuntimeInputRawOnExecutionMemory, mirrorStructuredInputOntoExecutionMemory, } from './materializeStructuredRunTaskInput.js';
+import { mirrorStructuredInputOntoExecutionMemory, } from './materializeStructuredRunTaskInput.js';
 import { xynthesizedOutboundForNode } from './graphRunExecutionSeed.js';
 import { buildTaskNodeJobContext } from './buildTaskNodeJobContext.js';
 import { resolveNarrixForTaskNode } from './resolveNarrixForTaskNode.js';
@@ -76,7 +76,6 @@ export async function buildTaskNodeRunTaskRequest(args) {
     const clearSynthForTask = args.clearSynthesizedContextPerNode === true &&
         hasSynthesizedContextPreStep &&
         hasExistingSynthesizedContext;
-    mirrorRuntimeInputRawOnExecutionMemory(execution);
     const nodeBindings = resolveTaskNodeInputsForRunTask({ node, execution });
     const jobContext = buildTaskNodeJobContext({
         node,

package/dist/src/runtime/validateCanonicalGraphDocument.js

@@ -5,6 +5,7 @@ import { EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY } from '../inspection/types.
 import { getStructuredDataFilterPathViolations } from './dataFiltersEvaluation.js';
 import { conditionWhenSignature, countDefaultModelConfigCases, isEmptyConditionWhen, isGraphAiModelConfig, isModelConfigSelection, } 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. */
 export const CANONICAL_GRAPH_TOP_LEVEL_KEYS = [
     'id',
@@ -381,6 +382,34 @@ function assertGraphResponseDefinition(value, path, context) {
     if (!Object.prototype.hasOwnProperty.call(value, 'shape')) {
         throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `${path}.shape is required.`, context);
     }
+    assertGraphResponseShapeNoLegacy(value.shape, `${path}.shape`, context);
+}
+function isExecutionMemoryPathBinding(val) {
+    return isPlainObject(val) && val.type === 'executionMemoryPath' && typeof val.path === 'string';
+}
+function assertForbidInputRawExecutionPath(dotPath, label, context) {
+    if (dotPath === 'input.raw' || dotPath.endsWith('.raw')) {
+        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 assertGraphResponseShapeNoLegacy(shape, path, context) {
+    if (Array.isArray(shape)) {
+        shape.forEach((item, index) => assertGraphResponseShapeNoLegacy(item, `${path}[${index}]`, context));
+        return;
+    }
+    if (!isPlainObject(shape))
+        return;
+    if (shape.type === 'nodeInputs') {
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `${path}.type "nodeInputs" was removed; use nodeInputsConfig.`, context);
+    }
+    if (shape.type === 'firstPresent' && Array.isArray(shape.sources)) {
+        shape.sources.forEach((source, index) => assertGraphResponseShapeNoLegacy(source, `${path}.sources[${index}]`, context));
+    }
+    for (const [key, val] of Object.entries(shape)) {
+        if (key === 'type' || key === 'nodeId' || key === 'path' || key === 'value' || key === 'sources')
+            continue;
+        assertGraphResponseShapeNoLegacy(val, `${path}.${key}`, context);
+    }
 }
 function findFinalizerType(node) {
     if (!isPlainObject(node))
@@ -493,6 +522,23 @@ export function assertCanonicalTaskNode(node, context) {
             }
         }
     }
+    if ('inputs' in taskNode && taskNode.inputs !== undefined) {
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `Task node "${String(node.id)}": node.inputs was removed — use inputsConfig for executionMemoryPath bindings and taskVariable for prompt literals.`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id) });
+    }
+    if ('inputBindings' in taskNode && taskNode.inputBindings !== undefined) {
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `Task node "${String(node.id)}": node.inputBindings was removed — use inputsConfig.`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id) });
+    }
+    const inputsConfig = taskNode.inputsConfig;
+    if (inputsConfig !== undefined) {
+        if (!isPlainObject(inputsConfig) || Array.isArray(inputsConfig)) {
+            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 (isExecutionMemoryPathBinding(bindingVal)) {
+                assertForbidInputRawExecutionPath(bindingVal.path, `Task node "${String(node.id)}": inputsConfig.${bindingKey}`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id) });
+            }
+        }
+    }
 }
 /**
  * Throws {@link ExellixGraphError} when the value is not a canonical graph document
@@ -548,6 +594,10 @@ export function assertCanonicalGraphDocument(graph, context) {
                 throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `Graph "${String(resolvedGraphId ?? '?')}": metadata.${key} is not part of the static metadata block. Move this field to \`${target}\`.`, { jobId: context?.jobId, graphId: resolvedGraphId, metadataKey: key });
             }
         }
+        assertCanonicalGraphDocumentMetadata(metadata, {
+            jobId: context?.jobId,
+            graphId: resolvedGraphId,
+        });
         const graphEntry = metadata.graphEntry;
         if (graphEntry != null && typeof graphEntry === 'object' && !Array.isArray(graphEntry)) {
             const ge = graphEntry;

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

@@ -149,12 +149,6 @@ export type GraphResponseSelector = {
     type: 'nodeInputsConfig';
     nodeId: string;
     path: string;
-}
-/** @deprecated Use `nodeInputsConfig`. */
- | {
-    type: 'nodeInputs';
-    nodeId: string;
-    path: string;
 } | {
     type: 'literal';
     value: unknown;
@@ -194,7 +188,7 @@ export type QuestionDrivenItemSpec = {
     nodeId: string;
     /**
      * Dot-path under the node definition to read the question from.
-     * Default: "inputs.question"
+     * Default: "taskVariable.question"
      */
     questionPath?: string;
     /**
@@ -207,14 +201,23 @@ export type QuestionDrivenItemSpec = {
      */
     optional?: boolean;
 };
-export type ReportSchemaSectionSpec = {
-    /** Dot-path in executionMemory to pull the section value from. */
+/**
+ * A single "read one value from run memory" reference. Same idiom as
+ * {@link FinalizerInputBinding} (minus `literal`) and {@link GraphResponseSelector}
+ * memory selectors — finalizer configs reuse it so every memory read in the model
+ * looks identical: `{ type, path }`.
+ */
+export type FinalizerMemoryRef = {
+    type: 'executionMemoryPath';
+    path: string;
+    optional?: boolean;
+} | {
+    type: 'outputsMemoryPath';
     path: string;
-    /** Human-readable title for this section. */
-    title?: string;
     optional?: boolean;
 };
 export type AggregateFinalizerConfig = {
+    /** Build the output object field-by-field from named finalizer `inputs`. */
     strategy: 'object-map';
     map: Record<string, AggregateExpr>;
     omitUndefined?: boolean;
@@ -228,25 +231,23 @@ export type AggregateFinalizerConfig = {
     contractVersion?: string;
     /** Map output keys → node specs. */
     items: Record<string, QuestionDrivenItemSpec>;
-    /** Optional extra metadata to include at top-level from executionMemory or outputsMemory. */
-    meta?: Record<string, {
-        type: 'executionMemoryPath' | 'outputsMemoryPath';
-        path: string;
-        optional?: boolean;
-    }>;
+    /** Optional extra top-level fields, each read from run memory. */
+    meta?: Record<string, FinalizerMemoryRef>;
 } | {
     /**
-     * Assemble a structured multi-section report from executionMemory.
-     * Each section key maps to a dot-path.  collect_tags gathers all
-     * epistemic tags across sections.
+     * Build the graph output object by reading one run-memory value per output key.
+     * This **is** the finalizer's output: `sections` maps each output field to the
+     * memory path it is read from. (Authoring titles belong in the studio document,
+     * not here.)
      */
     strategy: 'report-schema';
-    /** Map of output key → section spec (path + optional title). */
-    sections: Record<string, ReportSchemaSectionSpec>;
-    /** When true, scan all section values for CONFIRMED/INFERRED/ASSUMED/UNKNOWN and emit collected_tags. */
-    collect_tags?: boolean;
-    /** Optional literal fields merged at top level. */
-    meta?: Record<string, unknown>;
+    /** Output field key → where its value is read from in run memory. */
+    sections: Record<string, FinalizerMemoryRef>;
+    /**
+     * When true, scan all section values for CONFIRMED/INFERRED/ASSUMED/UNKNOWN
+     * and emit them under the `collectedTags` output field.
+     */
+    collectEpistemicTags?: boolean;
 };
 export type BundleFinalizerConfig = {
     strategy: 'bundle';
@@ -275,8 +276,8 @@ export interface FinalizerNode {
     type: 'finalizer';
     finalizerType: 'aggregate' | 'compose' | 'select' | 'bundle' | 'synthesize';
     inputs: Record<string, FinalizerInputBinding>;
-    /** Transitional: runtime validation narrows by finalizerType; implemented finalizers export typed configs. */
-    config: AggregateFinalizerConfig | BundleFinalizerConfig | SelectFinalizerConfig | SynthesizeFinalizerConfig | Record<string, unknown>;
+    /** Strict per-`finalizerType` config. The runtime validator rejects unknown keys and legacy field names. */
+    config: AggregateFinalizerConfig | BundleFinalizerConfig | SelectFinalizerConfig | SynthesizeFinalizerConfig;
     /** Writes selected finalizer result fields into graph-owned outputsMemory for final response assembly. */
     outputMapping?: TaskNodeResultMapping;
     outputSchema?: OutputSchema;
@@ -416,16 +417,10 @@ export interface TaskNode {
         }>;
     };
     /**
-     * Runtime payload bindings only (`executionMemoryPath` / legacy memory `$path` refs).
+     * Runtime payload bindings only (`executionMemoryPath` / memory `$path` refs).
      * See `taskVariable` for prompts and graph-variable hooks.
      */
     inputsConfig?: Record<string, unknown>;
-    /** @deprecated Prefer `inputsConfig`. */
-    inputBindings?: Record<string, unknown>;
-    /**
-     * @deprecated Prefer `inputsConfig` — name collides with `runtime.inputs` (caller bag).
-     */
-    inputs?: Record<string, any>;
     /**
      * Dynamic task configuration: prompts, literals, and `{ "$path": "variables.*" }` refs.
      * Not execution-memory payload wires (those belong in `inputsConfig`).
@@ -612,7 +607,6 @@ export type GraphEntryContract = {
      * Optional JSON Schema (e.g. draft 2020-12) for the merged `execution` object. Validators may use it; core runtime does not.
      */
     executionSchema?: Record<string, unknown>;
-    [key: string]: unknown;
 };
 /**
  * @deprecated Use root-level {@link GraphModelObject.response}. The final response shape is executable

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exellix/graph-engine",
-  "version": "7.4.3",
+  "version": "7.5.1",
   "type": "module",
   "description": "Graph executor SDK",
   "main": "dist/src/index.js",