@exellix/graph-engine 8.5.0 → 8.7.0

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

@@ -1,5 +1,5 @@
 /**
- * Host helpers for execution-matrix style orchestrators (e.g. `@exellix/exellix-runtime`).
+ * Host helpers for execution-matrix style orchestrators (e.g. `@x12i/exellix-runtime`).
  *
  * Graph-engine does not call matrix claim APIs; the host injects `executeGraph` and supplies
  * a `{ plan, runtime }` request with per-graph `GraphEntryContract` + seeded
@@ -83,7 +83,7 @@ export declare function buildMatrixJobForGraphRun(input: {
 export declare function isExecuteGraphResultFailed(result: ExecuteGraphResult): boolean;
 /**
  * Creates a long-lived graph runtime and exposes `executeGraph` for injection into matrix claim
- * processors (`ProcessMatrixClaimDeps.executeGraph` in `@exellix/exellix-runtime`, etc.).
+ * processors (`ProcessMatrixClaimDeps.executeGraph` in `@x12i/exellix-runtime`, etc.).
  */
 export declare function createMatrixHostGraphExecutor(options: ExellixGraphRuntimeOptions): {
     executeGraph: (input: ExecuteGraphInput) => Promise<ExecuteGraphResult>;

package/dist/src/runtime/executionMatrixHost.js

@@ -1,5 +1,5 @@
 /**
- * Host helpers for execution-matrix style orchestrators (e.g. `@exellix/exellix-runtime`).
+ * Host helpers for execution-matrix style orchestrators (e.g. `@x12i/exellix-runtime`).
  *
  * Graph-engine does not call matrix claim APIs; the host injects `executeGraph` and supplies
  * a `{ plan, runtime }` request with per-graph `GraphEntryContract` + seeded
@@ -92,7 +92,7 @@ export function isExecuteGraphResultFailed(result) {
 }
 /**
  * Creates a long-lived graph runtime and exposes `executeGraph` for injection into matrix claim
- * processors (`ProcessMatrixClaimDeps.executeGraph` in `@exellix/exellix-runtime`, etc.).
+ * processors (`ProcessMatrixClaimDeps.executeGraph` in `@x12i/exellix-runtime`, etc.).
  */
 export function createMatrixHostGraphExecutor(options) {
     const { executeGraph } = createExellixGraphRuntime(options);

package/dist/src/runtime/graphEngineLogMeta.js

@@ -1,10 +1,10 @@
-import { EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME } from './runtimeObjects.js';
+import { X12I_GRAPH_RUNTIME_PACKAGE_NAME } from './runtimeObjects.js';
 /** Canonical filter key for graph-engine's own log lines. */
 export const GRAPH_ENGINE_RUNTIME_SERVICE = 'graph-engine';
 /** Wrapper attribution when graph-engine proxies a downstream Logxer record. */
 export const GRAPH_ENGINE_PROXY_RUNTIME_IDENTITY = {
     service: GRAPH_ENGINE_RUNTIME_SERVICE,
-    libraryPackage: EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME,
+    libraryPackage: X12I_GRAPH_RUNTIME_PACKAGE_NAME,
 };
 function isRecord(value) {
     return value != null && typeof value === 'object' && !Array.isArray(value);

package/dist/src/runtime/graphEngineLogxer.js

@@ -1,6 +1,6 @@
 const logxer = await import('@x12i/logxer');
 import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
-import { EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME } from './runtimeObjects.js';
+import { X12I_GRAPH_RUNTIME_PACKAGE_NAME } from './runtimeObjects.js';
 import { normalizeGraphEngineLogMeta, } from './graphEngineLogMeta.js';
 export { GRAPH_ENGINE_RUNTIME_SERVICE, GRAPH_ENGINE_PROXY_RUNTIME_IDENTITY, extractOriginRuntimeIdentity, normalizeGraphEngineLogMeta, } from './graphEngineLogMeta.js';
 /** Env prefix for package-level log level: `GRAPH_ENGINE_LOGS_LEVEL` (canonical). */
@@ -116,7 +116,7 @@ function wrapGraphEngineLogxer(inner) {
 /** Factory for a graph-engine Logxer instance (logxer 4.5+ stack pass-through). */
 export function createGraphEngineLogxer(options) {
     const inner = logxer.createLogxer({
-        packageName: EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME,
+        packageName: X12I_GRAPH_RUNTIME_PACKAGE_NAME,
         envPrefix: GRAPH_ENGINE_LOGXER_ENV_PREFIX,
         debugNamespace: 'graph-engine',
     }, buildGraphEngineLogxerConfig(options?.logging));

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/runtimeObjects.d.ts

@@ -4,9 +4,9 @@
  */
 import type { GetJobLogsInput, GetJobLogsResult, QueryableLogLine } from '@x12i/logxer';
 /** Published npm name of this package (root layer in composed observability). */
-export declare const EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME: "@exellix/graph-engine";
+export declare const X12I_GRAPH_RUNTIME_PACKAGE_NAME: "@exellix/graph-engine";
 /** Task layer package name in {@link RuntimeObjects.packagesRuntimeObjects}. */
-export declare const EXELLIX_AI_TASKS_PACKAGE_NAME: "@exellix/ai-tasks";
+export declare const X12I_AI_TASKS_PACKAGE_NAME: "@exellix/ai-tasks";
 export type ActivixQueryableClient = {
     getJobActivities(input: {
         jobId: string;
@@ -43,15 +43,15 @@ export type BuildExellixGraphRuntimeObjectsInput = {
     graphLogxerClient?: LogxerQueryableClient;
     /**
      * Partial subtree from `@exellix/ai-tasks` when that package exports `runtimeObjects`.
-     * Nested `packagesRuntimeObjects` are appended after the ai-tasks row without overwriting entries.
+     * Nested `packagesRuntimeObjects` are appended after the x12i-tasks row without overwriting entries.
      */
     aiTasksRuntimeObjects?: Pick<RuntimeObjects, 'activixClient' | 'logxerClient'> & {
         packagesRuntimeObjects?: PackageRuntimeObjects[];
     };
 };
 /**
- * Builds the composed {@link RuntimeObjects} for exellix-graph: graph-level clients at the root,
- * then an `@exellix/ai-tasks` package row plus any nested package rows from ai-tasks (flattened as siblings).
+ * Builds the composed {@link RuntimeObjects} for x12i-graph: graph-level clients at the root,
+ * then an `@exellix/ai-tasks` package row plus any nested package rows from x12i-tasks (flattened as siblings).
  */
 export declare function buildExellixGraphRuntimeObjects(input: BuildExellixGraphRuntimeObjectsInput): RuntimeObjects;
 /**

package/dist/src/runtime/runtimeObjects.js

@@ -1,17 +1,17 @@
 /** Published npm name of this package (root layer in composed observability). */
-export const EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME = '@exellix/graph-engine';
+export const X12I_GRAPH_RUNTIME_PACKAGE_NAME = '@exellix/graph-engine';
 /** Task layer package name in {@link RuntimeObjects.packagesRuntimeObjects}. */
-export const EXELLIX_AI_TASKS_PACKAGE_NAME = '@exellix/ai-tasks';
+export const X12I_AI_TASKS_PACKAGE_NAME = '@exellix/ai-tasks';
 /**
- * Builds the composed {@link RuntimeObjects} for exellix-graph: graph-level clients at the root,
- * then an `@exellix/ai-tasks` package row plus any nested package rows from ai-tasks (flattened as siblings).
+ * Builds the composed {@link RuntimeObjects} for x12i-graph: graph-level clients at the root,
+ * then an `@exellix/ai-tasks` package row plus any nested package rows from x12i-tasks (flattened as siblings).
  */
 export function buildExellixGraphRuntimeObjects(input) {
     const ai = input.aiTasksRuntimeObjects;
     const tail = [...(ai?.packagesRuntimeObjects ?? [])];
     const packagesRuntimeObjects = [
         {
-            name: EXELLIX_AI_TASKS_PACKAGE_NAME,
+            name: X12I_AI_TASKS_PACKAGE_NAME,
             activixClient: ai?.activixClient,
             logxerClient: ai?.logxerClient,
         },

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`).
+ * Optional task metadata aligned with `@exellix/graph-composer` authoring / `reportTaskNodeProtocolGaps`.
+ * 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.
- * `@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`.
+ * PRE/POST strategies, optional web query template, optional input synthesis for AI task nodes.
+ * `@exellix/graph-composer` requires `preStrategyKey` / `postStrategyKey` for validated AI nodes.
  *
- * **`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`).
+ * Optional task metadata aligned with `@exellix/graph-composer` authoring / `reportTaskNodeProtocolGaps`.
+ * 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`.