@exellix/graph-engine 8.4.0 → 8.6.0

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 8.6.0 — Graphenix 2.7.3 (no-legacy web + narrix pipeline)
+
+### Breaking
+
+- **Legacy web scope removed:** Hard-reject `taskConfiguration.aiTaskProfile.webScoping`, `narrix.enableWebScope`, `forceWebScope`, `webScopeQuestions`, and related narrix web keys. Author **`taskConfiguration.aiTaskProfile.webQueryTemplate`** (optional `webQueryTemplates[]`, `webScopeOptions`).
+- **`RunTaskRequest` wire:** Root `narrix` / `narrixMode` / `narrixInput` / `narrixScope` removed (ai-tasks **10.0.12+**). Graph-engine merges graph `variables.narrix` into **`nodePlan.invokeContract.pipeline.narrix`** via `patchNodePlanRuntimePipeline`.
+- **Deleted** `applyAiTaskProfileWebScopingToNarrix` — web scope is plan-compiler PRE `webScope` unit + ai-tasks dispatch, not host-side narrix merge.
+
+### Changed
+
+- **`@exellix/ai-tasks` ^10.0.13**, **`@exellix/ai-skills` ^6.12.5**, **`@x12i/catalox` ^5.9.8**.
+- **`@x12i/graphenix-*` ^2.7.3** — includes **`response.persistency`** (`newRecord`, `link.*`) on graph wire (GRX-NOTE-001 / MRX-FRS-002 intent).
+- **`check:no-legacy`** — floors ai-tasks ≥10.0.12, ai-skills ≥6.12.4, graphenix-* ≥2.7.3.
+
+### Added
+
+- **`patchNodePlanRuntimePipeline`**, **`resolveRunTaskNodePlan`** — runtime narrix pipeline merge + narrative unit injection on minimal/uncompiled plans.
+- **Exports:** `NarrixModeKey`, `NarrixRunInput`, `NarrixScope` types (local, compatible with plan wire).
+
+### Downstream
+
+- **graphs-studio:** see [`docs/handoff/graphs-studio-graphenix-2.7.3.md`](docs/handoff/graphs-studio-graphenix-2.7.3.md).
+
+## 8.5.0 — Graphenix 2.7.0 + CR-006 (graphEntry.inputs removed)
+
+### Breaking
+
+- **CR-006:** Removed `metadata.graphEntry.inputs`, `inputTypes`, and all related types/helpers (`GraphEntryInputSpec*`, `getGraphEntryEmptyInputPathViolations`). Data source selection is an operator concern — configure `JobDef.graphs[*].sourcePoll` in jobs-ui instead.
+- **`buildExecutionSeedFromGraphEntry`** is a no-op stub (removed in next release).
+
+### Changed
+
+- **`@xellix/ai-tasks` ^10.0.9**, **`@exellix/ai-skills` ^6.12.3**, **`@exellix/xynthesis` ^4.8.4** (transitive via ai-tasks).
+- **`@x12i/graphenix-*` ^2.7.0** — aligned with upstream CR-006 release train; fact-guard compile-time validation available when plans use factGuard units.
+- **`check:no-legacy`** — floors ai-tasks ≥10.0.9, ai-skills ≥6.12.3, graphenix-core/plan-compiler/plan-format ≥2.7.0; rejects `"inputTypes"` in graph JSON fixtures.
+
+### Removed
+
+- Graph entry input seeding, readiness paths derived from `graphEntry.inputs`, and fixture `graphEntry.inputs` blocks.
+
 ## 8.4.0 — Graphenix 2.5.0 coordinated release
 
 ### Changed

package/README.md

@@ -554,9 +554,9 @@ Execute a single node — useful for tests and for stepping through a node in th
 
 Load a graph through the injected loader and validate against the canonical document schema before returning.
 
-## Graph Entry Inputs
+## Graph Entry
 
-Graph JSON can declare the semantic type of input it is designed to work with under `metadata.graphEntry.inputs`. This is part of the graph object itself and is intended for authors, catalogs, dashboards, and future validators; the runtime does not validate or coerce it today.
+Graphs declare execution contract under `metadata.graphEntry`. **Data source selection is an operator/work-factory concern** (chosen in jobs-ui at queue time); graphs do not embed input-type or entity-id declarations.
 
 ```json
 {
@@ -564,10 +564,6 @@ Graph JSON can declare the semantic type of input it is designed to work with un
   "metadata": {
     "graphEntry": {
       "summary": "Triage one vulnerability record with an optional caller query.",
-      "inputs": [
-        { "kind": "record", "path": "input", "required": true },
-        { "kind": "query", "path": "input.query", "required": false }
-      ],
       "requiredExecutionPaths": ["input.subnetId"]
     }
   },
@@ -575,21 +571,7 @@ Graph JSON can declare the semantic type of input it is designed to work with un
 }
 ```
 
-Standard `kind` values are `record`, `query`, `user-input`, `content`, `metadata`, and `execution`. Use multiple entries for combinations, for example a graph that needs both a raw record and a user question. Paths are relative to the merged `execution` object, so `input` maps to `GraphRuntimeObject.executionMemory.input` after `runtime.input` is mirrored.
-
-Use `kind: "execution"` when the graph is designed to consume a prior graph execution. The design contract names the source `graphId` and an optional `metadataFilter` for fields such as status values:
-
-```json
-{
-  "kind": "execution",
-  "graphId": "network-vuln-group-triage.v1",
-  "metadataFilter": { "status": "completed" },
-  "path": "input.upstreamExecution",
-  "required": true
-}
-```
-
-The runtime does not perform that lookup today; host tooling resolves it and passes the selected execution under the declared path.
+Use `requiredExecutionPaths` to declare dot-paths the first-wave nodes expect under `runtime.input`. Paths are relative to `GraphRuntimeObject.executionMemory` after `runtime.input` is mirrored (`input.*` root).
 
 ## Node Inputs
 

package/dist/src/index.d.ts

@@ -13,9 +13,10 @@
  * {@link compileExellixExecutablePlan} or `@x12i/graphenix-plan-compiler`.
  */
 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 { AiTaskProfileMetadata, AiTaskProfileInputSynthesis, } from './types/aiTaskProfile.js';
+export { hasWebScopeAuthoring } from './types/aiTaskProfile.js';
 export type { ExecutionStrategyInvocation, ExecutionStrategyPhase, ExecutionStrategyWrapperKey, SmartInputConfig, TaskStrategyItemData, XynthesizedDestinationScope, XynthesizedMemory, XynthesizedOutputConfig, } from './types/aiTasksDerivedTypes.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 type { Graph, GraphModelObject, GraphAiModelConfig, PartialGraphAiModelConfig, GraphModelAliasConfig, GraphRuntimeNodeConfig, TaskNodeRuntimeObject, GraphDocumentMetadata, GraphEntryContract, 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';
@@ -71,6 +72,7 @@ export { buildAiTasksRunTaskRequest, extractRunTaskMetadataPassthrough, extractR
 export type { BuildAiTasksRunTaskRequestArgs, RunTaskMetadataPassthrough, } from './runtime/buildAiTasksRunTaskRequest.js';
 export { buildTaskNodeJobContext } from './runtime/buildTaskNodeJobContext.js';
 export { resolveNarrixForTaskNode } from './runtime/resolveNarrixForTaskNode.js';
+export { patchNodePlanMainModelFromWire, patchNodePlanRuntimePipeline, resolveRunTaskNodePlan, } from './runtime/runTaskNodePlan.js';
 export { runTaskResponseSucceeded } from './runtime/runTaskResponse.js';
 export { buildTaskNodeRunTaskRequest, validateTaskNodeRunTaskConfig, validateTaskNodeRunTaskInvoke, } from './runtime/taskNodeRunTaskPreflight.js';
 export type { BuildTaskNodeRunTaskRequestArgs, BuildTaskNodeRunTaskRequestResult, TaskNodeRunTaskPreflightSkipReason, ValidateTaskNodeRunTaskConfigArgs, ValidateTaskNodeRunTaskConfigResult, ValidateTaskNodeRunTaskInvokeArgs, ValidateTaskNodeRunTaskInvokeResult, } from './runtime/taskNodeRunTaskPreflight.js';
@@ -83,12 +85,11 @@ export type { GetJobLogsInput, GetJobLogsResult, QueryableLogLine } from '@x12i/
 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 { GRAPH_ENTRY_STUDIO_ONLY_KEYS, GRAPH_METADATA_STUDIO_ONLY_KEYS, stripGraphModelStudioFields, primaryRuntimeInputFromStudioDocument, getGraphEntryStudioOnlyKeyViolations, getGraphMetadataStudioOnlyKeyViolations, } from './runtime/graphModelStudioSeparation.js';
 export type { GraphStudioDocument } from './runtime/graphModelStudioSeparation.js';
 export { STUDIO_GRAPH_EXECUTE_REMOVED_KEYS, getStudioGraphExecuteRemovedKeyViolations, assertCanonicalStudioGraphExecuteRequest, buildGraphExecutionRequestFromStudioExecute, } from './runtime/studioGraphExecuteRequest.js';
 export type { StudioGraphExecuteRemovedKey, StudioGraphExecuteRequest, BuildGraphExecutionRequestFromStudioExecuteOptions, } from './runtime/studioGraphExecuteRequest.js';
 export { computeGraphDocumentContentSha256, stableStringifyGraphDocument, } from './runtime/graphDocumentFingerprint.js';
-export { applyAiTaskProfileWebScopingToNarrix, mapAiTaskProfileQuestionsToWebScopeQuestions, } from './runtime/applyAiTaskProfileWebScopingToNarrix.js';
 export { createExellixGraphRuntime } from './runtime/ExellixGraphRuntime.js';
 export type { ExecutableGraphPlanV2, NodeExecutionPlan, ExecutionUnitPlanV2, } from '@x12i/graphenix-executable-contracts';
 export type { AuthoringGraphDocument } from '@x12i/graphenix-executable-contracts';
@@ -118,6 +119,6 @@ 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, 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 { NarrixPreProcessorConfig, NarrixModeKey, NarrixRunInput, NarrixScope, ResolvedNarrixWirePayload, LocalTaskHandler, LocalTaskContext, } from './types/narrix.js';
 export { shutdownMemorixRuntime } from './runtime/localSkills/memorixRuntime.js';
 export type { ScopedDataReaderConfig, ScopedDataReaderOutput, ScopedDataReaderPackOutput, ScopedAnswerAssemblerConfig, ScopedAnswerAssemblerOutput, ScopedAnswerWriterConfig, ScopedAnswerWriterOutput, } from './runtime/localSkills/index.js';

package/dist/src/index.js

@@ -12,6 +12,7 @@
  * `{ executeGraph({ plan, runtime }: GraphExecutionRequest) }`. Hosts compile upstream via
  * {@link compileExellixExecutablePlan} or `@x12i/graphenix-plan-compiler`.
  */
+export { hasWebScopeAuthoring } from './types/aiTaskProfile.js';
 export { mergeGraphDocumentModel, EXELLIX_GRAPH_MODEL_VARIABLE_KEY, EXELLIX_STRUCTURED_DATA_FILTERS_V1, } from './types/refs.js';
 export { getTaskConfiguration } from './types/taskNodeConfiguration.js';
 export { AI_TASKS_RUN_LOG_METADATA_KEY, AI_TASKS_LOGXER_RUN_ID_METADATA_KEY, DEFAULT_MAX_RUN_LOG_ENTRIES, DEFAULT_MAX_RUN_LOG_DATA_JSON_CHARS, } from './types/runLog.js';
@@ -54,6 +55,7 @@ export { assertHostJobId, newGraphRunTaskId } from './runtime/graphRunIdentity.j
 export { buildAiTasksRunTaskRequest, extractRunTaskMetadataPassthrough, extractRunTaskStrategyOverrides, resolveJobTypeId, resolveTaskTypeId, } from './runtime/buildAiTasksRunTaskRequest.js';
 export { buildTaskNodeJobContext } from './runtime/buildTaskNodeJobContext.js';
 export { resolveNarrixForTaskNode } from './runtime/resolveNarrixForTaskNode.js';
+export { patchNodePlanMainModelFromWire, patchNodePlanRuntimePipeline, resolveRunTaskNodePlan, } from './runtime/runTaskNodePlan.js';
 export { runTaskResponseSucceeded } from './runtime/runTaskResponse.js';
 export { buildTaskNodeRunTaskRequest, validateTaskNodeRunTaskConfig, validateTaskNodeRunTaskInvoke, } from './runtime/taskNodeRunTaskPreflight.js';
 /** Re-exported from `@exellix/ai-tasks` — preflight validation without `runTask`. */
@@ -61,10 +63,9 @@ export { validateRunTaskConfig, validateRunTaskInvoke, analyzeExpectedRunTaskInp
 export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground, EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME, EXELLIX_AI_TASKS_PACKAGE_NAME, } from './runtime/runtimeObjects.js';
 export { assertCanonicalGraphDocument, assertCanonicalTaskNode, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } 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 { GRAPH_ENTRY_STUDIO_ONLY_KEYS, GRAPH_METADATA_STUDIO_ONLY_KEYS, stripGraphModelStudioFields, primaryRuntimeInputFromStudioDocument, getGraphEntryStudioOnlyKeyViolations, getGraphMetadataStudioOnlyKeyViolations, } from './runtime/graphModelStudioSeparation.js';
 export { STUDIO_GRAPH_EXECUTE_REMOVED_KEYS, getStudioGraphExecuteRemovedKeyViolations, assertCanonicalStudioGraphExecuteRequest, buildGraphExecutionRequestFromStudioExecute, } from './runtime/studioGraphExecuteRequest.js';
 export { computeGraphDocumentContentSha256, stableStringifyGraphDocument, } from './runtime/graphDocumentFingerprint.js';
-export { applyAiTaskProfileWebScopingToNarrix, mapAiTaskProfileQuestionsToWebScopeQuestions, } from './runtime/applyAiTaskProfileWebScopingToNarrix.js';
 // New runtime with injection seam
 export { createExellixGraphRuntime } from './runtime/ExellixGraphRuntime.js';
 export { compileExellixExecutablePlan } from './compile/compileExellixExecutablePlan.js';

package/dist/src/inspection/contractInspection.js

@@ -1,5 +1,6 @@
-import { isLocalSkillKey } from '../runtime/localSkills/index.js';
+import { hasWebScopeAuthoring } from '../types/aiTaskProfile.js';
 import { readTaskNodeInputsConfig } from '../runtime/readTaskNodeInputsConfig.js';
+import { isLocalSkillKey } from '../runtime/localSkills/index.js';
 import { getNodeMemoryShape, getNodeNarrixDiscovery, inspectNode, resolveNodeSkillKey, } from './nodeInspection.js';
 import { getGraphNodes } from './graphInspection.js';
 import { getNodeControlDependencies } from './controlInspection.js';
@@ -217,9 +218,8 @@ function buildInputContract(node, memoryShape) {
         ? [
             {
                 enabled: true,
-                entityIdPath: narrixDisc.webScope.entityIdPath,
-                entityTypePath: narrixDisc.webScope.entityTypePath,
-                questions: narrixDisc.webScope.questions,
+                webQueryTemplate: narrixDisc.webScope.webQueryTemplate,
+                webQueryTemplates: narrixDisc.webScope.webQueryTemplates,
             },
         ]
         : [];
@@ -292,19 +292,11 @@ function buildOutputContract(node) {
     }
     const tc = task.taskConfiguration;
     const webCfg = tc?.aiTaskProfile;
-    const webScoping = webCfg?.webScoping;
-    const narrixCfg = tc?.narrix;
     const webWrites = [];
-    if (narrixCfg?.enableWebScope === true) {
-        webWrites.push({
-            path: 'webContext',
-            source: 'taskConfiguration.narrix.enableWebScope → @exellix/ai-tasks (runtime-known)',
-        });
-    }
-    else if (webScoping && webScoping.enabled === true) {
+    if (hasWebScopeAuthoring(webCfg)) {
         webWrites.push({
             path: 'webContext',
-            source: 'taskConfiguration.aiTaskProfile.webScoping → executeNode (runtime-known)',
+            source: 'taskConfiguration.aiTaskProfile.webQueryTemplate → PRE webScope unit (runtime-known)',
         });
     }
     const synthWrites = [];
@@ -356,8 +348,7 @@ export function getNodeSideEffects(node) {
         const tc = node.taskConfiguration;
         runsNarrix = tc?.narrix != null && typeof tc.narrix === 'object';
         const web = tc?.aiTaskProfile;
-        const ws = web?.webScoping;
-        runsLocalWebScope = ws?.enabled === true;
+        runsLocalWebScope = hasWebScopeAuthoring(web);
         const inputSynth = web?.inputSynthesis;
         runsPreSynthesis = inputSynth?.enabled === true;
     }

package/dist/src/inspection/controlInspection.js

@@ -1,5 +1,6 @@
 import { getGraphNodes } from './graphInspection.js';
 import { getNodeNarrixDiscovery } from './nodeInspection.js';
+import { hasWebScopeAuthoring } from '../types/aiTaskProfile.js';
 /**
  * Recursively collects leaf `path` strings from a graph edge predicate.
  */
@@ -64,8 +65,7 @@ export function getNodeExecutionMemoryWriteTails(node) {
     }
     const tc = task.taskConfiguration;
     const profile = tc?.aiTaskProfile;
-    const ws = profile?.webScoping;
-    if (ws?.enabled === true) {
+    if (hasWebScopeAuthoring(profile)) {
         tails.add('webContext');
     }
     const inputSynth = profile?.inputSynthesis;

package/dist/src/inspection/nodeInspection.js

@@ -1,4 +1,4 @@
-import { mapAiTaskProfileQuestionsToWebScopeQuestions } from '../runtime/applyAiTaskProfileWebScopingToNarrix.js';
+import { hasWebScopeAuthoring } from '../types/aiTaskProfile.js';
 import { readTaskNodeInputsConfig } from '../runtime/readTaskNodeInputsConfig.js';
 import { runScopedDataReader } from '../runtime/localSkills/scopedDataReader.js';
 // ---------------------------------------------------------------------------
@@ -364,8 +364,8 @@ export function getNodeNarrixDiscovery(node) {
     if (!narrix || typeof narrix !== 'object')
         return null;
     const n = narrix;
-    const web = task.taskConfiguration?.aiTaskProfile?.webScoping;
-    const enableWebScope = n.enableWebScope === true || web?.enabled === true;
+    const profile = task.taskConfiguration?.aiTaskProfile;
+    const enableWebScope = hasWebScopeAuthoring(profile);
     return {
         nodeId: node.id,
         enabled: true,
@@ -374,13 +374,12 @@ export function getNodeNarrixDiscovery(node) {
         narrativeTypeIds: Array.isArray(n.narrativeTypeIds) ? n.narrativeTypeIds : undefined,
         webScope: {
             enabled: enableWebScope,
-            forced: undefined,
-            questions: Array.isArray(web?.questions) && web.questions.length > 0
-                ? mapAiTaskProfileQuestionsToWebScopeQuestions(web.questions)
-                : undefined,
-            entityIdPath: undefined,
-            entityTypePath: undefined,
-            enrichFromRaw: undefined,
+            ...(typeof profile?.webQueryTemplate === 'string'
+                ? { webQueryTemplate: profile.webQueryTemplate }
+                : {}),
+            ...(Array.isArray(profile?.webQueryTemplates) && profile.webQueryTemplates.length > 0
+                ? { webQueryTemplates: profile.webQueryTemplates }
+                : {}),
         },
         outputPaths: {
             signals: 'executionMemory._narrix.scoping.signals',

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

@@ -1,8 +1,7 @@
 import type { CatalogBinding, CatalogRequestEntry, GraphDocumentMetadata, GraphEdge, GraphNode, GraphPredicate, GraphReadabilityKind } from '../types/refs.js';
-import type { WebScopeQuestion } from '../types/narrix.js';
 import type { ScopedDataReaderOutput, ScopedDataReaderPackOutput } from '../runtime/localSkills/scopedDataReader.js';
 import type { LocalSkillKey } from '../runtime/localSkills/index.js';
-export type { GraphEdge, GraphPredicate, GraphReadabilityKind, WebScopeQuestion, LocalSkillKey };
+export type { GraphEdge, GraphPredicate, GraphReadabilityKind, LocalSkillKey };
 export type { ScopedDataReaderOutput, ScopedDataReaderPackOutput };
 /**
  * The scoping question for a single node: what it asks, where it reads its data from,
@@ -98,18 +97,10 @@ export type NodeNarrixDiscovery = {
     /** Narrative type ids the engine focuses discovery on. */
     narrativeTypeIds?: string[];
     webScope: {
-        /** Whether web scoping is enabled. */
+        /** Whether a webQueryTemplate (or pack) is authored on aiTaskProfile. */
         enabled: boolean;
-        /** When true, skips DB short-circuit and always fetches from web. */
-        forced?: boolean;
-        /** Web scope questions with stable ids and purposes. */
-        questions?: WebScopeQuestion[];
-        /** Dot-path to entity id in execution memory for web scope. */
-        entityIdPath?: string;
-        /** Dot-path to entity type in execution memory for web scope. */
-        entityTypePath?: string;
-        /** Whether CVE/vendor/product tokens are appended to the web-scope question from raw input. */
-        enrichFromRaw?: boolean;
+        webQueryTemplate?: string;
+        webQueryTemplates?: string[];
     };
     /** Fixed execution-memory paths where narrix writes its output. */
     outputPaths: {

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -26,7 +26,7 @@ import { buildRunLog, extractLogxerCorrelationFromMetadata, extractTaskRunLogFro
 import { setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground } from "./runtimeObjects.js";
 import { DebugLogAbstract, bindGraphEngineRunLogxer, clearGraphEngineRunLogxer, createGraphEngineLogxer, ensureGraphEngineLogxerOnRuntimeObjects, logGraphEngineErrorCode, patchGraphNodeLogContext, runGraphWithLogContext, traceExecutionMemory, } from "./graphEngineLogxer.js";
 import { runWithAiTasksStackLogging } from "@exellix/ai-tasks";
-import { nodePlanFromFinalizerPlan, patchNodePlanMainModelFromWire, resolveRunTaskNodePlan, } from "./runTaskNodePlan.js";
+import { nodePlanFromFinalizerPlan, patchNodePlanMainModelFromWire, patchNodePlanRuntimePipeline, resolveRunTaskNodePlan, } from "./runTaskNodePlan.js";
 import { assertHostJobId, newGraphRunTaskId } from "./graphRunIdentity.js";
 import { resolveTaskKey } from "./resolveTaskKey.js";
 import { buildPredicateEvalContextForNode, readExecutionVariableBuckets, seedGraphVariableBucketsFromRuntime, } from "./variables.js";
@@ -675,7 +675,6 @@ export function createExellixGraphRuntime(opts) {
                 ? { ...input.node.taskConfiguration.narrix }
                 : undefined,
             graphVariablesNarrix: jobVariables?.narrix,
-            aiTaskProfile: input.node?.taskConfiguration?.aiTaskProfile,
         });
         const metaTk = input.node?.taskConfiguration?.taskKind;
         const taskKindForward = metaTk === "decision" || metaTk === "utility" || metaTk === "content" ? metaTk : undefined;
@@ -689,6 +688,11 @@ export function createExellixGraphRuntime(opts) {
         if (!input.nodePlan && input.requireCompiledNodePlan !== true) {
             runTaskNodePlan = patchNodePlanMainModelFromWire(runTaskNodePlan, wireModelConfig);
         }
+        runTaskNodePlan = patchNodePlanRuntimePipeline({
+            plan: runTaskNodePlan,
+            resolvedNarrix: narrix ?? undefined,
+            taskConfiguration: input.node?.taskConfiguration,
+        });
         const startedAt = Date.now();
         const hasSynthesizedContextPreStep = runTaskNodePlan.executionUnits.some((u) => u.unitKind === "externalPreUtility" || u.unitKind === "pipelinePhase");
         const hasExistingSynthesizedContext = execution != null &&
@@ -791,7 +795,6 @@ export function createExellixGraphRuntime(opts) {
             executionMemory: executionMemoryForWire,
             jobContext,
             prevNodeId: input.prevNodeId,
-            narrix: narrix ?? undefined,
             ...extractRunTaskStrategyOverrides(input.node?.taskConfiguration),
             outputValidation: outputValidationFromPlan ??
                 (input.node?.taskConfiguration?.aiTasksOutputValidation != null &&

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

@@ -11,13 +11,12 @@ import type { RunTaskRequest } from '@exellix/ai-tasks';
 import type { GraphExecutionTraceV2, NodeExecutionPlan } from '@x12i/graphenix-executable-contracts';
 import type { SmartInputConfig, XynthesizedMemory } from '../types/aiTasksDerivedTypes.js';
 import type { Job } from '../types/refs.js';
-import type { ResolvedNarrixWirePayload } from '../types/narrix.js';
 /** Request/metadata keys that must never carry provider API secrets (env-only). */
 export declare const FORBIDDEN_RUN_TASK_SECRET_KEYS: readonly ["openrouterApiKey", "OPENROUTER_API_KEY", "OPEN_ROUTER_KEY", "apiKey", "api_key", "openRouterApiKey"];
-/** Reads task-node `taskConfiguration` keys forwarded to `@exellix/ai-tasks` `RunTaskRequest` (runtime strategy / Narrix wiring). */
-export declare function extractRunTaskStrategyOverrides(taskConfiguration: Record<string, unknown> | undefined | null): Partial<Pick<BuildAiTasksRunTaskRequestArgs, 'narrixMode' | 'inputStrategyKey' | 'narrixInput'>>;
+/** Reads task-node `taskConfiguration.inputStrategyKey` for `@exellix/ai-tasks` `RunTaskRequest`. */
+export declare function extractRunTaskStrategyOverrides(taskConfiguration: Record<string, unknown> | undefined | null): Partial<Pick<BuildAiTasksRunTaskRequestArgs, 'inputStrategyKey'>>;
 /** Optional `RunTaskRequest` fields commonly authored on task-node `taskConfiguration` (whitelist — closed merge order). */
-export type RunTaskMetadataPassthrough = Partial<Pick<RunTaskRequest, 'narrixScope' | 'aiScoping' | 'aiScopingOptions' | 'timeoutMs' | 'templateRenderOptions' | 'smartInputRenderOptions' | 'templateTokens' | 'aiEngineId' | 'sessionId' | 'agentType' | 'gatewayDiagnostics' | 'context' | 'knowledge' | 'executionStrategyCatalogItems'>>;
+export type RunTaskMetadataPassthrough = Partial<Pick<RunTaskRequest, 'aiScoping' | 'aiScopingOptions' | 'timeoutMs' | 'templateRenderOptions' | 'smartInputRenderOptions' | 'templateTokens' | 'aiEngineId' | 'sessionId' | 'agentType' | 'gatewayDiagnostics' | 'context' | 'knowledge' | 'executionStrategyCatalogItems'>>;
 /**
  * Whitelisted optional transport fields from task-node `taskConfiguration` for `@exellix/ai-tasks` ≥ 7.2.x
  * (`RunSkillRequest` / `RunTaskRequest` extras not covered by {@link extractRunTaskStrategyOverrides}).
@@ -42,7 +41,6 @@ export type BuildAiTasksRunTaskRequestArgs = {
     executionMemory?: Record<string, unknown>;
     jobContext?: Record<string, unknown>;
     prevNodeId?: string;
-    narrix?: ResolvedNarrixWirePayload;
     outputValidation?: RunTaskRequest['outputValidation'];
     diagnostics?: RunTaskRequest['diagnostics'];
     identity?: Record<string, unknown>;
@@ -51,10 +49,7 @@ export type BuildAiTasksRunTaskRequestArgs = {
     autoValidateDecisionOutput?: boolean;
     /** Overrides default `resolveTaskTypeId(skillKey, nodeId, taskConfiguration)` e.g. engine strategy phases. */
     taskTypeIdOverride?: string;
-    /** Usually from `taskConfiguration.narrixMode` via {@link extractRunTaskStrategyOverrides}. */
-    narrixMode?: RunTaskRequest['narrixMode'];
     inputStrategyKey?: RunTaskRequest['inputStrategyKey'];
-    narrixInput?: RunTaskRequest['narrixInput'];
     /** Required on every request for ai-tasks ≥ 7.1.x — use `[]` for plain MAIN. */
     executionStrategies?: RunTaskRequest['executionStrategies'];
     xynthesized?: XynthesizedMemory;

package/dist/src/runtime/buildAiTasksRunTaskRequest.js

@@ -18,25 +18,17 @@ function assertNoSecretPassthrough(taskConfiguration, context) {
         }
     }
 }
-/** Reads task-node `taskConfiguration` keys forwarded to `@exellix/ai-tasks` `RunTaskRequest` (runtime strategy / Narrix wiring). */
+/** Reads task-node `taskConfiguration.inputStrategyKey` for `@exellix/ai-tasks` `RunTaskRequest`. */
 export function extractRunTaskStrategyOverrides(taskConfiguration) {
     assertNoSecretPassthrough(taskConfiguration, 'extractRunTaskStrategyOverrides');
     if (taskConfiguration == null || typeof taskConfiguration !== 'object' || Array.isArray(taskConfiguration))
         return {};
     const m = taskConfiguration;
     const out = {};
-    const narrixMode = m.narrixMode;
-    if (typeof narrixMode === 'string' && narrixMode.trim() !== '') {
-        out.narrixMode = narrixMode.trim();
-    }
     const inputStrategyKey = m.inputStrategyKey;
     if (typeof inputStrategyKey === 'string' && inputStrategyKey.trim() !== '') {
         out.inputStrategyKey = inputStrategyKey.trim();
     }
-    const narrixInput = m.narrixInput;
-    if (narrixInput != null && typeof narrixInput === 'object' && !Array.isArray(narrixInput)) {
-        out.narrixInput = narrixInput;
-    }
     return out;
 }
 /**
@@ -49,10 +41,6 @@ export function extractRunTaskMetadataPassthrough(taskConfiguration) {
         return {};
     const m = taskConfiguration;
     const out = {};
-    const narrixScope = m.narrixScope;
-    if (narrixScope != null && typeof narrixScope === 'object' && !Array.isArray(narrixScope)) {
-        out.narrixScope = narrixScope;
-    }
     const aiScoping = m.aiScoping;
     if (Array.isArray(aiScoping)) {
         out.aiScoping = aiScoping;
@@ -162,16 +150,13 @@ export function buildAiTasksRunTaskRequest(args) {
         ...(args.executionMemory != null ? { executionMemory: args.executionMemory } : {}),
         ...(args.jobContext != null ? { jobContext: args.jobContext } : {}),
         ...(args.prevNodeId != null && args.prevNodeId !== '' ? { prevNodeId: args.prevNodeId } : {}),
-        ...(args.narrix != null ? { narrix: args.narrix } : {}),
         ...(args.outputValidation != null ? { outputValidation: args.outputValidation } : {}),
         ...(args.diagnostics != null ? { diagnostics: args.diagnostics } : {}),
         ...(args.identity != null ? { identity: args.identity } : {}),
         ...(args.executionMode != null ? { executionMode: args.executionMode } : {}),
         ...(args.taskKind != null ? { taskKind: args.taskKind } : {}),
         ...(args.autoValidateDecisionOutput !== undefined ? { autoValidateDecisionOutput: args.autoValidateDecisionOutput } : {}),
-        ...(args.narrixMode != null ? { narrixMode: args.narrixMode } : {}),
         ...(args.inputStrategyKey != null ? { inputStrategyKey: args.inputStrategyKey } : {}),
-        ...(args.narrixInput != null ? { narrixInput: args.narrixInput } : {}),
         executionStrategies,
         ...(args.xynthesized != null ? { xynthesized: args.xynthesized } : {}),
         ...(smartInputForward != null ? { smartInput: smartInputForward } : {}),

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

@@ -1,7 +1,7 @@
 /**
- * Builds the `RunTaskRequest.taskConfiguration` blob for `@exellix/ai-tasks` ≥ 7.7 compile-at-invoke.
- * Root-level fields already lifted by graph-engine are omitted; compile-only authoring (e.g.
- * `aiTaskStrategies`, `aiTaskProfile`) remains on the blob.
+ * Builds the `RunTaskRequest.taskConfiguration` blob for legacy compile-at-invoke (no `nodePlan`).
+ * With graphenix node plans, narrix / narrixMode / narrixInput / narrixScope live on
+ * `nodePlan.invokeContract.pipeline` instead — see {@link patchNodePlanRuntimePipeline}.
  */
 /**
  * Subset of node `taskConfiguration` forwarded on `RunTaskRequest.taskConfiguration` for ai-tasks compile.

package/dist/src/runtime/buildRunTaskTaskConfigurationForward.js

@@ -1,7 +1,7 @@
 /**
- * Builds the `RunTaskRequest.taskConfiguration` blob for `@exellix/ai-tasks` ≥ 7.7 compile-at-invoke.
- * Root-level fields already lifted by graph-engine are omitted; compile-only authoring (e.g.
- * `aiTaskStrategies`, `aiTaskProfile`) remains on the blob.
+ * Builds the `RunTaskRequest.taskConfiguration` blob for legacy compile-at-invoke (no `nodePlan`).
+ * With graphenix node plans, narrix / narrixMode / narrixInput / narrixScope live on
+ * `nodePlan.invokeContract.pipeline` instead — see {@link patchNodePlanRuntimePipeline}.
  */
 const RUN_TASK_LIFTED_TASK_CONFIGURATION_KEYS = new Set([
     'taskTypeId',
@@ -10,10 +10,6 @@ const RUN_TASK_LIFTED_TASK_CONFIGURATION_KEYS = new Set([
     'modelConfig',
     'llmCall',
     'timeoutMs',
-    'narrix',
-    'narrixMode',
-    'narrixInput',
-    'narrixScope',
     'inputStrategyKey',
     'aiTasksOutputValidation',
     'taskKind',

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

@@ -6,7 +6,7 @@
  * `runtime.executionMemory` objects built here.
  */
 import type { AuthoringGraphDocument } from '@x12i/graphenix-executable-contracts';
-import type { Graph, GraphEntryContract, GraphEntryExecutionInputSpec, Job } from '../types/refs.js';
+import type { Graph, GraphEntryContract, Job } from '../types/refs.js';
 import type { ExellixGraphRuntimeOptions, ExecuteGraphInput, ExecuteGraphResult, GraphRuntimeObject } from './ExellixGraphRuntime.js';
 import type { GraphLoader } from './ExellixGraphRuntime.js';
 export { resolveGraphEntryFromAuthoringDocument, authoringDocumentGraphId } from '../compile/authoringDocumentHelpers.js';
@@ -22,32 +22,21 @@ export declare function resolveGraphEntryFromGraph(graph: Graph): GraphEntryCont
  */
 export declare function createResolveGraphEntryFromLoader(loader: GraphLoader): (graphId: string) => Promise<GraphEntryContract | undefined>;
 export type BuildExecutionSeedSources = {
-    /**
-     * Highest precedence: explicit dot-path → value (paths match `GraphEntryValueInputSpec.path`).
-     */
     valuesByPath?: Record<string, unknown>;
-    /**
-     * Lower precedence: plain objects (matrix defaults, row payload, per-graph map).
-     * For each spec path, `selectByPath(layer, path)` is evaluated; later layers override earlier ones.
-     */
     layers?: unknown[];
 };
 export type BuildExecutionSeedResult = {
-    /** Shallow clone base + writes; safe to pass as `GraphRuntimeObject.executionMemory`. */
     executionMemory: Record<string, unknown>;
-    /** Backwards-readable alias for callers still naming the seed object `execution`. */
     execution: Record<string, unknown>;
-    /** Paths written for value-kind specs. */
     appliedPaths: string[];
-    /** `kind: "execution"` specs are never auto-filled — host must materialize prior runs. */
-    skippedExecutionSpecs: GraphEntryExecutionInputSpec[];
 };
 /**
- * Builds an initial `execution` object from `metadata.graphEntry.inputs` for **value** kinds only.
- * `kind: "execution"` entries are skipped (see return value); the host must merge source executions
- * using `graphId` / `metadataFilter` before calling `executeGraph`.
+ * @deprecated graphEntry.inputs was removed in Graphenix 2.7.0 (CR-006).
+ * Runtime input comes from record.input + job memory; this function is a no-op stub
+ * kept for a single release to avoid hard compile breaks in external matrix hosts.
+ * Remove callers and this stub in the next release.
  */
-export declare function buildExecutionSeedFromGraphEntry(graphEntry: GraphEntryContract | undefined, sources?: BuildExecutionSeedSources): BuildExecutionSeedResult;
+export declare function buildExecutionSeedFromGraphEntry(_graphEntry: GraphEntryContract | undefined, _sources?: BuildExecutionSeedSources): BuildExecutionSeedResult;
 /** Builds the canonical graph-engine execution request for matrix-style hosts. */
 export declare function buildGraphExecutionRequest(input: {
     doc: AuthoringGraphDocument;

package/dist/src/runtime/executionMatrixHost.js

@@ -8,13 +8,7 @@
 import { compileExellixExecutablePlan } from '../compile/compileExellixExecutablePlan.js';
 import { mergeGraphDocumentModel } from '../types/refs.js';
 import { createExellixGraphRuntime } from './ExellixGraphRuntime.js';
-import { selectByPath, writeByPath } from './pathExpr.js';
-function isExecutionInputSpec(spec) {
-    return spec.kind === 'execution';
-}
-function isValueInputSpec(spec) {
-    return spec.kind !== 'execution' && typeof spec.path === 'string';
-}
+import { selectByPath } from './pathExpr.js';
 export { resolveGraphEntryFromAuthoringDocument, authoringDocumentGraphId } from '../compile/authoringDocumentHelpers.js';
 /**
  * Reads Layer 01 contract from the canonical graph document (`metadata.graphEntry`).
@@ -36,48 +30,14 @@ export function createResolveGraphEntryFromLoader(loader) {
     };
 }
 /**
- * Builds an initial `execution` object from `metadata.graphEntry.inputs` for **value** kinds only.
- * `kind: "execution"` entries are skipped (see return value); the host must merge source executions
- * using `graphId` / `metadataFilter` before calling `executeGraph`.
+ * @deprecated graphEntry.inputs was removed in Graphenix 2.7.0 (CR-006).
+ * Runtime input comes from record.input + job memory; this function is a no-op stub
+ * kept for a single release to avoid hard compile breaks in external matrix hosts.
+ * Remove callers and this stub in the next release.
  */
-export function buildExecutionSeedFromGraphEntry(graphEntry, sources = {}) {
-    const execution = {};
-    const appliedPaths = [];
-    const skippedExecutionSpecs = [];
-    const valuesByPath = sources.valuesByPath ?? {};
-    const layers = sources.layers ?? [];
-    for (const spec of graphEntry?.inputs ?? []) {
-        if (isExecutionInputSpec(spec)) {
-            skippedExecutionSpecs.push(spec);
-            continue;
-        }
-        if (!isValueInputSpec(spec))
-            continue;
-        const path = spec.path.trim();
-        if (!path)
-            continue;
-        // Invoke payload paths belong on runtime.input (graphenix 2.1) — not executionMemory.
-        if (path === 'input' || path.startsWith('input.'))
-            continue;
-        let value = undefined;
-        if (Object.prototype.hasOwnProperty.call(valuesByPath, path)) {
-            value = valuesByPath[path];
-        }
-        else {
-            for (const layer of layers) {
-                if (layer == null || typeof layer !== 'object' || Array.isArray(layer))
-                    continue;
-                const picked = selectByPath(layer, path);
-                if (picked !== undefined)
-                    value = picked;
-            }
-        }
-        if (value !== undefined) {
-            writeByPath(execution, path, value, 'replace');
-            appliedPaths.push(path);
-        }
-    }
-    return { executionMemory: execution, execution, appliedPaths, skippedExecutionSpecs };
+export function buildExecutionSeedFromGraphEntry(_graphEntry, _sources = {}) {
+    const empty = {};
+    return { executionMemory: empty, execution: empty, appliedPaths: [] };
 }
 /** Builds the canonical graph-engine execution request for matrix-style hosts. */
 export function buildGraphExecutionRequest(input) {

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

@@ -22,13 +22,15 @@ export type GraphStudioDocument = {
 };
 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;
+/** Legacy graph-entry input declaration — removed in Graphenix 2.7.0 (CR-006). */
+export declare const GRAPH_ENTRY_REMOVED_KEYS: readonly ["inputs", "inputTypes"];
+export type GraphEntryRemovedKey = (typeof GRAPH_ENTRY_REMOVED_KEYS)[number];
+export declare function getGraphEntryRemovedKeyViolations(graphEntry: unknown): GraphEntryRemovedKey[];
 export declare function assertCanonicalGraphEntryContract(graphEntry: unknown, context: {
     jobId?: string;
     graphId?: string;