@exellix/graph-engine 8.5.0 → 8.6.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # 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

package/dist/src/index.d.ts

@@ -13,7 +13,8 @@
  * {@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, 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';
@@ -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';
@@ -88,7 +90,6 @@ export type { GraphStudioDocument } from './runtime/graphModelStudioSeparation.j
 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`. */
@@ -64,7 +66,6 @@ export { assertCanonicalGraphRuntimeObject } from './runtime/validateCanonicalGr
 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/resolveNarrixForTaskNode.d.ts

@@ -1,14 +1,10 @@
 import type { NarrixPreProcessorConfig, ResolvedNarrixWirePayload } from '../types/narrix.js';
-import type { AiTaskProfileMetadata } from '../types/aiTaskProfile.js';
 /**
- * Resolves outbound `RunTaskRequest.narrix`: starts from node `taskConfiguration.narrix`,
- * shallow-merges graph-level `variables.narrix`, then applies `enableWebScope` / `webScopeQuestions`
- * via {@link applyAiTaskProfileWebScopingToNarrix}.
- *
- * Shared by {@link ExellixGraphRuntime}.
+ * Resolves discovery narrix for runtime plan patching: shallow-merge of node `taskConfiguration.narrix`
+ * with graph-level `variables.narrix`. Web scope is a PRE `webScope` unit compiled from
+ * `taskConfiguration.aiTaskProfile.webQueryTemplate` (Graphenix 2.7.x+).
  */
 export declare function resolveNarrixForTaskNode(args: {
     nodeMetadataNarrix: NarrixPreProcessorConfig | undefined;
     graphVariablesNarrix: Partial<NarrixPreProcessorConfig> | undefined;
-    aiTaskProfile: AiTaskProfileMetadata | undefined;
 }): ResolvedNarrixWirePayload | undefined;

package/dist/src/runtime/resolveNarrixForTaskNode.js

@@ -1,10 +1,7 @@
-import { applyAiTaskProfileWebScopingToNarrix } from './applyAiTaskProfileWebScopingToNarrix.js';
 /**
- * Resolves outbound `RunTaskRequest.narrix`: starts from node `taskConfiguration.narrix`,
- * shallow-merges graph-level `variables.narrix`, then applies `enableWebScope` / `webScopeQuestions`
- * via {@link applyAiTaskProfileWebScopingToNarrix}.
- *
- * Shared by {@link ExellixGraphRuntime}.
+ * Resolves discovery narrix for runtime plan patching: shallow-merge of node `taskConfiguration.narrix`
+ * with graph-level `variables.narrix`. Web scope is a PRE `webScope` unit compiled from
+ * `taskConfiguration.aiTaskProfile.webQueryTemplate` (Graphenix 2.7.x+).
  */
 export function resolveNarrixForTaskNode(args) {
     let resolved = args.nodeMetadataNarrix != null ? { ...args.nodeMetadataNarrix } : undefined;
@@ -15,5 +12,5 @@ export function resolveNarrixForTaskNode(args) {
             ...(resolved ?? {}),
         };
     }
-    return applyAiTaskProfileWebScopingToNarrix(resolved, args.aiTaskProfile);
+    return resolved;
 }

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

@@ -1,4 +1,5 @@
 import type { FinalizerExecutionPlan, NodeExecutionPlan } from '@x12i/graphenix-executable-contracts';
+import type { NarrixPreProcessorConfig } from '../types/narrix.js';
 import type { RunTaskModelConfigWire } from './graphAiModelConfig.js';
 /** Resolve the frozen node plan required by `@exellix/ai-tasks` ≥ 9. */
 export declare function resolveRunTaskNodePlan(args: {
@@ -10,6 +11,15 @@ export declare function resolveRunTaskNodePlan(args: {
 }): NodeExecutionPlan;
 /** Standalone {@link executeNode} without compile: patch MAIN unit selection from resolved graph profiles. */
 export declare function patchNodePlanMainModelFromWire(plan: NodeExecutionPlan, wire: RunTaskModelConfigWire): NodeExecutionPlan;
+/**
+ * Patches graphenix node-plan invoke pipeline with runtime narrix resolution (graph `variables.narrix`
+ * merge) and optional `taskConfiguration` narrixScope / mode / input when absent from compile.
+ */
+export declare function patchNodePlanRuntimePipeline(args: {
+    plan: NodeExecutionPlan;
+    resolvedNarrix?: NarrixPreProcessorConfig;
+    taskConfiguration?: Record<string, unknown>;
+}): NodeExecutionPlan;
 export declare function nodePlanFromFinalizerPlan(args: {
     finalizerId: string;
     utilityKey: string;

package/dist/src/runtime/runTaskNodePlan.js

@@ -1,4 +1,7 @@
 import { minimalNodePlanForSkillKey } from '@exellix/ai-tasks';
+function isPlainRecord(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
 function mainSkillUnit(plan) {
     return plan.executionUnits.find((u) => u.unitKind === 'mainSkill');
 }
@@ -7,6 +10,102 @@ function selectionFromWireSlot(value) {
         return undefined;
     return { kind: 'profileChoice', key: value.trim() };
 }
+function resolveNarrativeMode(pipeline, tc) {
+    const explicit = pipeline.narrixMode ?? tc?.narrixMode;
+    if (explicit === 'preprocessor' || explicit === 'handler')
+        return explicit;
+    if (explicit === 'off')
+        return 'off';
+    if (pipeline.narrixInput != null || tc?.narrixInput != null)
+        return 'handler';
+    if (pipeline.narrix != null || tc?.narrix != null)
+        return 'preprocessor';
+    return 'off';
+}
+function planHasNarrativeUnit(plan) {
+    return plan.executionUnits.some((u) => u.unitKind === 'narrativePreprocessor' || u.unitKind === 'narrativeHandler');
+}
+function defaultPreActionSelection(plan) {
+    const preUtility = plan.executionUnits.find((u) => u.unitKind === 'externalPreUtility');
+    if (preUtility?.modelSelection) {
+        return { selection: preUtility.modelSelection, source: preUtility.modelSource ?? 'graphDefault' };
+    }
+    return {
+        selection: { kind: 'profileChoice', key: 'cheap/default' },
+        source: 'graphDefault',
+    };
+}
+/** Standalone executeNode path: mirror Graphenix `buildNarrativeUnits` when plan was not compiled. */
+function injectRuntimeNarrativeUnitsIfAbsent(plan, pipeline, taskConfiguration) {
+    if (planHasNarrativeUnit(plan))
+        return plan;
+    const mode = resolveNarrativeMode(pipeline, taskConfiguration);
+    if (mode === 'off')
+        return plan;
+    const narrix = isPlainRecord(pipeline.narrix) ? pipeline.narrix : {};
+    const narrixInput = isPlainRecord(pipeline.narrixInput) ? pipeline.narrixInput : {};
+    const attachToField = (typeof narrix.attachToField === 'string' && narrix.attachToField) ||
+        (typeof narrixInput.attachToField === 'string' && narrixInput.attachToField) ||
+        undefined;
+    const narrativeWriteKey = attachToField ?? 'executionMemory._narrative';
+    const datasetId = (typeof narrix.datasetId === 'string' && narrix.datasetId) ||
+        (typeof narrixInput.datasetId === 'string' && narrixInput.datasetId) ||
+        undefined;
+    const preModel = defaultPreActionSelection(plan);
+    const nodeId = plan.nodeId;
+    const narrativeContract = {
+        reads: ['input'],
+        writes: [
+            {
+                destination: 'execution',
+                key: narrativeWriteKey,
+                mode: 'merge',
+            },
+        ],
+    };
+    const bumpedUnits = plan.executionUnits.map((u) => ({
+        ...u,
+        order: u.order + 1,
+    }));
+    let narrativeUnit;
+    if (mode === 'preprocessor') {
+        narrativeUnit = {
+            unitId: `unit:${nodeId}:narrative:pre`,
+            nodeId,
+            unitKind: 'narrativePreprocessor',
+            invokeMode: 'narrativePreprocessor',
+            order: 0,
+            strategyKey: 'narrative-preprocessor',
+            modelSlot: 'preActionModel',
+            modelSelection: preModel.selection,
+            modelSource: preModel.source,
+            unitParams: { datasetId, attachToField },
+            invokeContract: narrativeContract,
+            sourcePath: '/runtime/narrativePreprocessor',
+        };
+    }
+    else {
+        narrativeUnit = {
+            unitId: `unit:${nodeId}:narrative:handler`,
+            nodeId,
+            unitKind: 'narrativeHandler',
+            invokeMode: 'narrativeHandler',
+            order: 0,
+            strategyKey: 'narrative-handler',
+            modelSlot: 'preActionModel',
+            modelSelection: preModel.selection,
+            modelSource: preModel.source,
+            terminal: true,
+            unitParams: { datasetId, attachToField, narrixInput },
+            invokeContract: narrativeContract,
+            sourcePath: '/runtime/narrativeHandler',
+        };
+    }
+    return {
+        ...plan,
+        executionUnits: [narrativeUnit, ...bumpedUnits],
+    };
+}
 /** Resolve the frozen node plan required by `@exellix/ai-tasks` ≥ 9. */
 export function resolveRunTaskNodePlan(args) {
     if (args.nodePlan)
@@ -27,6 +126,39 @@ export function patchNodePlanMainModelFromWire(plan, wire) {
     }
     return next;
 }
+/**
+ * Patches graphenix node-plan invoke pipeline with runtime narrix resolution (graph `variables.narrix`
+ * merge) and optional `taskConfiguration` narrixScope / mode / input when absent from compile.
+ */
+export function patchNodePlanRuntimePipeline(args) {
+    const tc = args.taskConfiguration;
+    const narrixScope = tc?.narrixScope;
+    const narrixMode = tc?.narrixMode;
+    const narrixInput = tc?.narrixInput;
+    const hasPatch = args.resolvedNarrix != null ||
+        (narrixScope != null && typeof narrixScope === 'object' && !Array.isArray(narrixScope)) ||
+        (typeof narrixMode === 'string' && narrixMode.trim() !== '') ||
+        narrixInput != null;
+    if (!hasPatch)
+        return args.plan;
+    const next = structuredClone(args.plan);
+    const ic = next.invokeContract ?? {};
+    const pipeline = { ...(isPlainRecord(ic.pipeline) ? ic.pipeline : {}) };
+    if (args.resolvedNarrix != null) {
+        pipeline.narrix = { ...args.resolvedNarrix };
+    }
+    if (narrixScope != null && typeof narrixScope === 'object' && !Array.isArray(narrixScope)) {
+        pipeline.narrixScope = narrixScope;
+    }
+    if (pipeline.narrixMode === undefined && typeof narrixMode === 'string' && narrixMode.trim() !== '') {
+        pipeline.narrixMode = narrixMode.trim();
+    }
+    if (pipeline.narrixInput === undefined && narrixInput != null) {
+        pipeline.narrixInput = narrixInput;
+    }
+    next.invokeContract = { ...ic, pipeline };
+    return injectRuntimeNarrativeUnitsIfAbsent(next, pipeline, tc);
+}
 export function nodePlanFromFinalizerPlan(args) {
     const slots = args.finalizerPlan?.modelSlots;
     const plan = minimalNodePlanForSkillKey(args.utilityKey, args.finalizerId);

package/dist/src/runtime/taskNodeRunTaskPreflight.js

@@ -12,7 +12,7 @@ import { resolveNarrixForTaskNode } from './resolveNarrixForTaskNode.js';
 import { buildRunTaskIdentityEnvelope, shouldForwardRunTaskTraceMode, } from './runTaskAugments.js';
 import { readExecutionVariableBuckets } from './executionVariableBuckets.js';
 import { newGraphRunTaskId } from './graphRunIdentity.js';
-import { patchNodePlanMainModelFromWire, resolveRunTaskNodePlan } from './runTaskNodePlan.js';
+import { patchNodePlanMainModelFromWire, patchNodePlanRuntimePipeline, resolveRunTaskNodePlan } from './runTaskNodePlan.js';
 function isPlainRecord(v) {
     return v != null && typeof v === 'object' && !Array.isArray(v);
 }
@@ -81,7 +81,11 @@ export async function buildTaskNodeRunTaskRequest(args) {
             ? { ...node.taskConfiguration.narrix }
             : undefined,
         graphVariablesNarrix: jobVariables?.narrix,
-        aiTaskProfile: node.taskConfiguration?.aiTaskProfile,
+    });
+    runTaskNodePlan = patchNodePlanRuntimePipeline({
+        plan: runTaskNodePlan,
+        resolvedNarrix: narrix ?? undefined,
+        taskConfiguration: node.taskConfiguration,
     });
     const metaTk = node.taskConfiguration?.taskKind;
     const taskKindForward = metaTk === 'decision' || metaTk === 'utility' || metaTk === 'content' ? metaTk : undefined;
@@ -141,7 +145,6 @@ export async function buildTaskNodeRunTaskRequest(args) {
         executionMemory: executionMemoryForWire,
         jobContext,
         prevNodeId: args.prevNodeId,
-        narrix: narrix ?? undefined,
         ...extractRunTaskStrategyOverrides(node.taskConfiguration),
         outputValidation: outputValidationFromPlan ??
             (ov != null && typeof ov === 'object' && !Array.isArray(ov) && 'schema' in ov

package/dist/src/runtime/validateCanonicalGraphDocument.js

@@ -98,8 +98,9 @@ const LEGACY_METADATA_TO_TASK_CONFIGURATION = {
     executionMemory: 'runtime.executionMemory',
     outputsMemory: 'runtime.outputsMemory',
 };
-/** Web-scope keys are not allowed under `taskConfiguration.narrix` except `enableWebScope` (use `taskConfiguration.aiTaskProfile.webScoping` for questions). */
+/** Web-scope keys are not allowed under `taskConfiguration.narrix` (use `taskConfiguration.aiTaskProfile.webQueryTemplate`). */
 const FORBIDDEN_NARRIX_WEB_KEYS = [
+    'enableWebScope',
     'forceWebScope',
     'webScopeQuestions',
     'webScoping',
@@ -550,18 +551,16 @@ export function assertCanonicalTaskNode(node, context, options) {
     }
     const narrixTc = tc && isPlainObject(tc.narrix) ? tc.narrix : undefined;
     if (narrixTc) {
-        if ('enableWebScope' in narrixTc &&
-            narrixTc.enableWebScope != null &&
-            typeof narrixTc.enableWebScope !== 'boolean') {
-            throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `Task node "${String(node.id)}": taskConfiguration.narrix.enableWebScope must be a boolean when present.`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id), narrixWebKey: 'enableWebScope' });
-        }
         for (const k of FORBIDDEN_NARRIX_WEB_KEYS) {
             if (k in narrixTc) {
-                throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `Task node "${String(node.id)}": taskConfiguration.narrix.${k} is forbidden — author web scope under taskConfiguration.aiTaskProfile.webScoping.`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id), narrixWebKey: k });
+                throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `Task node "${String(node.id)}": taskConfiguration.narrix.${k} is forbidden — author web scope under taskConfiguration.aiTaskProfile.webQueryTemplate.`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id), narrixWebKey: k });
             }
         }
     }
     const profile = tc && isPlainObject(tc.aiTaskProfile) ? tc.aiTaskProfile : undefined;
+    if (profile && 'webScoping' in profile && profile.webScoping != null) {
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `Task node "${String(node.id)}": taskConfiguration.aiTaskProfile.webScoping is not allowed — use webQueryTemplate (Rendrix string).`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id) });
+    }
     const inputSynthesis = profile && isPlainObject(profile.inputSynthesis) ? profile.inputSynthesis : undefined;
     if (inputSynthesis && 'alsoWriteLegacySynthesizedContext' in inputSynthesis) {
         throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `Task node "${String(node.id)}": taskConfiguration.aiTaskProfile.inputSynthesis.alsoWriteLegacySynthesizedContext is removed in 5.x.`, { jobId: context?.jobId, graphId: context?.graphId, nodeId: String(node.id) });

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

@@ -1,13 +1,7 @@
 /**
  * Optional task metadata aligned with `@x12i/graph-composer` authoring / `reportTaskNodeProtocolGaps`.
- * Exellix-graph-engine merges {@link AiTaskProfileMetadata.webScoping} into `taskConfiguration.narrix` for execution
- * when `enabled: true` and `questions` is non-empty (see `applyAiTaskProfileWebScopingToNarrix`).
+ * Web scope is authored via {@link AiTaskProfileMetadata.webQueryTemplate} (Graphenix 2.7.3+ PRE `webScope` unit).
  */
-export type AiTaskProfileWebScoping = {
-    enabled: boolean;
-    /** When `enabled` is `true`, must be a non-empty array of non-empty strings (graph-composer contract). */
-    questions?: string[];
-};
 export type AiTaskProfileInputSynthesis = {
     enabled: boolean;
     /** Memory paths fed to PRE `synthesized-context` when `enabled` (validated against graph-engine allowlist). */
@@ -23,19 +17,20 @@ export type AiTaskProfileInputSynthesis = {
     strategyKey?: string;
 };
 /**
- * PRE/POST strategies, optional web scoping, optional input synthesis for AI task nodes.
+ * PRE/POST strategies, optional web query template, optional input synthesis for AI task nodes.
  * `@x12i/graph-composer` requires `preStrategyKey` / `postStrategyKey` for validated AI nodes.
- * Exellix-graph-engine merges `webScoping` into the resolved narrix payload for execution when active.
- *
- * **Runtime (graph-engine ≥5):** When `preStrategyKey` / `postStrategyKey` are non-empty strings, the executor issues
- * additional `@exellix/ai-tasks` **`runTask`** calls (utility `skillKey`) **before** and **after** the MAIN node task — graph-engine does **not** call the Xynthesis package directly. Results are merged under **`execution.xynthesis.pre`** / **`execution.xynthesis.post`** (historical execution-memory slot names). This is separate from `executionPipeline` PRE `synthesized-context`, which still runs inside a single ai-tasks `runTask`.
  *
- * **`inputSynthesis` runtime:** When `enabled`, graph-engine translates this block into an ai-tasks PRE
- * `synthesized-context` step inside the **same** `runTask` call (distinct from engine-level PRE/POST strategy utilities).
+ * **Web scope (Graphenix 2.7.3+):** Non-empty `webQueryTemplate` (or `webQueryTemplates[]`) compiles to a PRE
+ * `webScope` unit; graph-engine does not merge web intent into `taskConfiguration.narrix`.
  */
 export type AiTaskProfileMetadata = {
     preStrategyKey?: string;
     postStrategyKey?: string;
-    webScoping?: AiTaskProfileWebScoping;
+    /** Rendrix template for PRE webScope (e.g. `Patch status for {{input.cveId}}?`). */
+    webQueryTemplate?: string;
+    /** Pack-mode web query templates (`webQueryTemplate` optional when non-empty). */
+    webQueryTemplates?: string[];
+    webScopeOptions?: Record<string, unknown>;
     inputSynthesis?: AiTaskProfileInputSynthesis;
 };
+export declare function hasWebScopeAuthoring(profile: AiTaskProfileMetadata | undefined): boolean;

package/dist/src/types/aiTaskProfile.js

@@ -1,6 +1,14 @@
 /**
  * Optional task metadata aligned with `@x12i/graph-composer` authoring / `reportTaskNodeProtocolGaps`.
- * Exellix-graph-engine merges {@link AiTaskProfileMetadata.webScoping} into `taskConfiguration.narrix` for execution
- * when `enabled: true` and `questions` is non-empty (see `applyAiTaskProfileWebScopingToNarrix`).
+ * Web scope is authored via {@link AiTaskProfileMetadata.webQueryTemplate} (Graphenix 2.7.3+ PRE `webScope` unit).
  */
-export {};
+export function hasWebScopeAuthoring(profile) {
+    if (profile == null)
+        return false;
+    if (typeof profile.webQueryTemplate === 'string' && profile.webQueryTemplate.trim().length > 0) {
+        return true;
+    }
+    const pack = profile.webQueryTemplates;
+    return (Array.isArray(pack) &&
+        pack.some((entry) => typeof entry === 'string' && entry.trim().length > 0));
+}

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

@@ -1,22 +1,39 @@
-import type { RunTaskRequest } from '@exellix/ai-tasks';
-/** Same as `RunTaskRequest['narrix']` (ai-tasks exports `RunTaskRequest` but not this alias on the root barrel). */
-type AITasksNarrixPreProcessorConfig = NonNullable<RunTaskRequest['narrix']>;
+/** Canonical Narrix invocation modes (Graphenix plan / ai-tasks narrative units). */
+export type NarrixModeKey = 'off' | 'preprocessor' | 'handler';
+/** Filters Narrix handler output before writing to task memory. */
+export type NarrixScope = {
+    includeSignals?: string[];
+    excludeSignals?: string[];
+    includeStories?: string[];
+    excludeStories?: string[];
+    [key: string]: unknown;
+};
+/** Structured Narrix handler input (ai-tasks `NarrixRunInput` shape). */
+export type NarrixRunInput = ({
+    medium: 'record';
+    datasetId: string;
+    record: Record<string, unknown>;
+} & Record<string, unknown>) | ({
+    medium: 'text';
+    datasetId: string;
+    text: string;
+} & Record<string, unknown>) | ({
+    medium: 'docs';
+    datasetId: string;
+    document: Record<string, unknown>;
+} & Record<string, unknown>) | ({
+    medium: 'chat';
+    datasetId: string;
+    thread: Record<string, unknown>;
+} & Record<string, unknown>);
 /**
- * Graph-engine wire shape for the resolved `RunTaskRequest.narrix` payload after merging
- * `taskConfiguration.narrix` with graph variables and optional `taskConfiguration.aiTaskProfile.webScoping`.
+ * Resolved discovery narrix after merging node `taskConfiguration.narrix` with graph-level
+ * `variables.narrix`. Patched onto `nodePlan.invokeContract.pipeline.narrix` before `runTask`.
  */
-export type ResolvedNarrixWirePayload = AITasksNarrixPreProcessorConfig;
-/** One web-scope question on the resolved narrix wire payload; produced from `aiTaskProfile.webScoping.questions`. */
-export type WebScopeQuestion = {
-    id: string;
-    question: string;
-    purpose?: string;
-};
+export type ResolvedNarrixWirePayload = NarrixPreProcessorConfig;
 /**
- * Authoring shape for `taskConfiguration.narrix` on a graph task node.
- *
- * Discovery fields plus `enableWebScope` (forwarded to `RunTaskRequest.narrix.enableWebScope`).
- * Question packs for web scoping may also be supplied via `taskConfiguration.aiTaskProfile.webScoping`.
+ * Authoring shape for `taskConfiguration.narrix` on a graph task node (discovery fields only).
+ * Web scope is authored on `taskConfiguration.aiTaskProfile.webQueryTemplate` (Graphenix 2.7.3+).
  */
 export type NarrixPreProcessorConfig = {
     /** Which pack and entity type the engine runs (e.g. `"network.vuln.instances"`). */
@@ -30,13 +47,6 @@ export type NarrixPreProcessorConfig = {
     narrativeTypeIds?: string[];
     /** Framework question this node answers (e.g. q0, q1, q2, q3, q5, q6). */
     questionId?: string;
-    /** When true, ai-tasks runs `@exellix/narrix-web-scoper` after CNI and writes `executionMemory.webContext`. */
-    enableWebScope?: boolean;
-    /**
-     * When true with `enableWebScope`, skip internal web-scoper if `executionMemory.webContextMarkdown` is already set.
-     * See `@exellix/ai-tasks` `NarrixPreProcessorConfig.skipWebScopeWhenExternalWebMarkdownPresent`.
-     */
-    skipWebScopeWhenExternalWebMarkdownPresent?: boolean;
     /** Execution memory key for the Narrix attachment (default `_narrix` in ai-tasks). */
     attachToField?: string;
 };
@@ -63,4 +73,3 @@ export interface LocalTaskContext {
     masterSkillId?: string;
     masterSkillActivityId?: string;
 }
-export {};

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

@@ -1,4 +1,5 @@
-import type { InputStrategyKey, LlmCallConfig, NarrixModeKey, NarrixRunInput, RunTaskRequest } from '@exellix/ai-tasks';
+import type { InputStrategyKey, LlmCallConfig, RunTaskRequest } from '@exellix/ai-tasks';
+import type { NarrixModeKey, NarrixRunInput, NarrixScope } from './narrix.js';
 import type { ExecutionStrategyInvocation, TaskStrategyItemData } from './aiTasksDerivedTypes.js';
 import type { AiTaskProfileMetadata } from './aiTaskProfile.js';
 import type { ModelConfigSelection } from './refs.js';
@@ -49,7 +50,7 @@ export type TaskNodeTaskConfiguration = {
     identity?: Record<string, unknown>;
     runTaskIdentity?: Record<string, unknown>;
     memoryKey?: string;
-    narrixScope?: RunTaskRequest['narrixScope'];
+    narrixScope?: NarrixScope;
     aiScoping?: RunTaskRequest['aiScoping'];
     aiScopingOptions?: RunTaskRequest['aiScopingOptions'];
     timeoutMs?: number;

package/docs/handoff/graphs-studio-graphenix-2.7.3.md

@@ -0,0 +1,13 @@
+# graphs-studio — Graphenix 2.7.3 alignment handoff
+
+Shipped with **@exellix/graph-engine@8.6.0** / **@exellix/graph-composer@2.12.0**.
+
+Full checklist: see Exellix monorepo `docs/handoff/graphs-studio-graphenix-2.7.3.md` (canonical copy). Summary:
+
+1. **Web scope:** `taskConfiguration.aiTaskProfile.webQueryTemplate` — remove `webScoping` and narrix web keys.
+2. **Graph entry:** no `graphEntry.inputs` (CR-006); use `requiredExecutionPaths` + jobs-ui data sources.
+3. **Persistency:** `response.persistency` with `newRecord` + optional `link` (Graphenix 2.7.3).
+4. **Preflight:** show `nodePlan.invokeContract.pipeline`, not root `RunTaskRequest.narrix`.
+5. **CRS-FRS-005:** PRE synthesis export parity still pending in studio (separate track).
+
+Pin: `graph-engine ^8.6.0`, `graph-composer ^2.12.0`, `ai-tasks ^10.0.12+`, `graphenix ^2.7.3`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exellix/graph-engine",
-  "version": "8.5.0",
+  "version": "8.6.0",
   "type": "module",
   "description": "Graph executor SDK",
   "main": "dist/src/index.js",
@@ -20,7 +20,8 @@
     "dist/**",
     ".env.example",
     "CHANGELOG.md",
-    "README.md"
+    "README.md",
+    "docs/handoff/**"
   ],
   "scripts": {
     "prebuild": "node scripts/clean-dist.mjs",
@@ -52,27 +53,27 @@
     "access": "public"
   },
   "dependencies": {
-    "@exellix/ai-skills": "^6.12.3",
-    "@exellix/ai-tasks": "^10.0.9",
+    "@exellix/ai-skills": "^6.12.5",
+    "@exellix/ai-tasks": "^10.0.13",
     "@x12i/activix": "^8.6.3",
-    "@x12i/catalox": "^5.9.7",
+    "@x12i/catalox": "^5.9.8",
     "@x12i/env": "^4.0.1",
     "@x12i/funcx": "^4.9.13",
     "@x12i/graphenix": "^2.5.0",
-    "@x12i/graphenix-authoring-format": "^2.7.0",
-    "@x12i/graphenix-core": "^2.7.0",
-    "@x12i/graphenix-executable-contracts": "^2.7.0",
-    "@x12i/graphenix-executable-format": "^2.7.0",
-    "@x12i/graphenix-execute-envelope": "^2.7.0",
+    "@x12i/graphenix-authoring-format": "^2.7.3",
+    "@x12i/graphenix-core": "^2.7.3",
+    "@x12i/graphenix-executable-contracts": "^2.7.3",
+    "@x12i/graphenix-executable-format": "^2.7.3",
+    "@x12i/graphenix-execute-envelope": "^2.7.3",
     "@x12i/graphenix-format": "^2.0.0",
-    "@x12i/graphenix-plan-compiler": "^2.7.0",
-    "@x12i/graphenix-plan-format": "^2.7.0",
-    "@x12i/graphenix-task-node-format": "^2.7.0",
-    "@x12i/graphenix-trace-format": "^2.7.0",
+    "@x12i/graphenix-plan-compiler": "^2.7.3",
+    "@x12i/graphenix-plan-format": "^2.7.3",
+    "@x12i/graphenix-task-node-format": "^2.7.3",
+    "@x12i/graphenix-trace-format": "^2.7.3",
     "@x12i/logxer": "^4.6.0",
-    "@x12i/memorix-descriptors": "1.7.0",
-    "@x12i/memorix-retrieval": "1.12.0",
-    "@x12i/memorix-writer": "1.1.0",
+    "@x12i/memorix-descriptors": "1.10.0",
+    "@x12i/memorix-retrieval": "1.14.0",
+    "@x12i/memorix-writer": "1.3.0",
     "@x12i/rendrix": "^4.3.0",
     "@x12i/runx": "^1.3.2"
   },

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

@@ -1,15 +0,0 @@
-import type { AiTaskProfileMetadata } from '../types/aiTaskProfile.js';
-import type { NarrixPreProcessorConfig, ResolvedNarrixWirePayload, WebScopeQuestion } from '../types/narrix.js';
-/**
- * Maps graph-composer `string[]` web questions to narrix-web-scoper object shape.
- * Synthetic ids are stable per index for a given node run.
- */
-export declare function mapAiTaskProfileQuestionsToWebScopeQuestions(questions: string[]): WebScopeQuestion[];
-/**
- * Returns the resolved outbound `RunTaskRequest.narrix` payload.
- *
- * `enableWebScope` is forwarded from `taskConfiguration.narrix` (default `false`) and may be set to
- * `true` when `taskConfiguration.aiTaskProfile.webScoping` is active. `webScopeQuestions` are derived
- * only from the ai-task profile.
- */
-export declare function applyAiTaskProfileWebScopingToNarrix(narrix: NarrixPreProcessorConfig | undefined, aiTaskProfile: AiTaskProfileMetadata | undefined): ResolvedNarrixWirePayload | undefined;

package/dist/src/runtime/applyAiTaskProfileWebScopingToNarrix.js

@@ -1,43 +0,0 @@
-/**
- * Maps graph-composer `string[]` web questions to narrix-web-scoper object shape.
- * Synthetic ids are stable per index for a given node run.
- */
-export function mapAiTaskProfileQuestionsToWebScopeQuestions(questions) {
-    const out = [];
-    let i = 0;
-    for (const q of questions) {
-        const t = typeof q === 'string' ? q.trim() : '';
-        if (!t)
-            continue;
-        out.push({ id: `aiTaskProfile-q-${i}`, question: t });
-        i += 1;
-    }
-    return out;
-}
-function webScopingFromProfileIsActive(profile) {
-    if (profile?.webScoping?.enabled !== true)
-        return false;
-    const qs = profile.webScoping.questions;
-    if (!Array.isArray(qs) || qs.length === 0)
-        return false;
-    return mapAiTaskProfileQuestionsToWebScopeQuestions(qs).length > 0;
-}
-/**
- * Returns the resolved outbound `RunTaskRequest.narrix` payload.
- *
- * `enableWebScope` is forwarded from `taskConfiguration.narrix` (default `false`) and may be set to
- * `true` when `taskConfiguration.aiTaskProfile.webScoping` is active. `webScopeQuestions` are derived
- * only from the ai-task profile.
- */
-export function applyAiTaskProfileWebScopingToNarrix(narrix, aiTaskProfile) {
-    const profileActive = webScopingFromProfileIsActive(aiTaskProfile);
-    if (narrix == null && !profileActive) {
-        return undefined;
-    }
-    const wire = (narrix != null ? { ...narrix } : {});
-    wire.enableWebScope = narrix?.enableWebScope === true || profileActive;
-    if (profileActive) {
-        wire.webScopeQuestions = mapAiTaskProfileQuestionsToWebScopeQuestions(aiTaskProfile.webScoping.questions);
-    }
-    return wire;
-}