@exellix/graph-engine 8.4.0 → 8.6.0

package/dist/src/runtime/graphModelStudioSeparation.js

@@ -15,9 +15,6 @@ export const GRAPH_METADATA_STUDIO_ONLY_KEYS = [
 function isPlainObject(v) {
     return v != null && typeof v === 'object' && !Array.isArray(v);
 }
-function isValueInputSpec(spec) {
-    return spec.kind !== 'execution';
-}
 export function getGraphEntryStudioOnlyKeyViolations(graphEntry) {
     if (!isPlainObject(graphEntry))
         return [];
@@ -28,26 +25,6 @@ export function getGraphMetadataStudioOnlyKeyViolations(metadata) {
         return [];
     return GRAPH_METADATA_STUDIO_ONLY_KEYS.filter((key) => Object.prototype.hasOwnProperty.call(metadata, key));
 }
-/** Returns dot-paths under graphEntry.inputs with empty `path` for value kinds. */
-export function getGraphEntryEmptyInputPathViolations(graphEntry) {
-    if (!isPlainObject(graphEntry))
-        return [];
-    const inputs = graphEntry.inputs;
-    if (!Array.isArray(inputs))
-        return [];
-    const bad = [];
-    for (let i = 0; i < inputs.length; i++) {
-        const spec = inputs[i];
-        if (!isPlainObject(spec))
-            continue;
-        if (spec.kind === 'execution')
-            continue;
-        const path = typeof spec.path === 'string' ? spec.path.trim() : '';
-        if (!path)
-            bad.push(`metadata.graphEntry.inputs[${i}].path`);
-    }
-    return bad;
-}
 /**
  * Deep-clones a graph model and removes studio-only metadata and graphEntry example fields.
  * Use at publish time when upstream serializers still attach playground artifacts.
@@ -70,16 +47,23 @@ export function stripGraphModelStudioFields(graph) {
     }
     return clone;
 }
+/** Legacy graph-entry input declaration — removed in Graphenix 2.7.0 (CR-006). */
+export const GRAPH_ENTRY_REMOVED_KEYS = ['inputs', 'inputTypes'];
+export function getGraphEntryRemovedKeyViolations(graphEntry) {
+    if (!isPlainObject(graphEntry))
+        return [];
+    return GRAPH_ENTRY_REMOVED_KEYS.filter((key) => Object.prototype.hasOwnProperty.call(graphEntry, key));
+}
 export function assertCanonicalGraphEntryContract(graphEntry, context) {
     const label = context.graphLabel ?? `Graph "${String(context.graphId ?? '?')}"`;
+    const removedKeys = getGraphEntryRemovedKeyViolations(graphEntry);
+    if (removedKeys.length > 0) {
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `${label}: metadata.graphEntry must not include removed field(s): ${removedKeys.join(', ')}. Data source selection is an operator concern (JobDef.graphs[*].sourcePoll); use requiredExecutionPaths only.`, { ...context, graphEntryRemovedKeys: removedKeys });
+    }
     const studioKeys = getGraphEntryStudioOnlyKeyViolations(graphEntry);
     if (studioKeys.length > 0) {
         throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `${label}: metadata.graphEntry must not include studio-only example field(s): ${studioKeys.join(', ')}. Store example payloads in the graphs-studio database (GraphStudioDocument.exampleInputs), not in the executable graph model.`, { ...context, graphEntryStudioOnlyKeys: studioKeys });
     }
-    const emptyPaths = getGraphEntryEmptyInputPathViolations(graphEntry);
-    if (emptyPaths.length > 0) {
-        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT, `${label}: metadata.graphEntry.inputs must declare a non-empty dot-path under merged execution (e.g. "input" or "input.subnetId"); empty path at ${emptyPaths.join(', ')}.`, { ...context, graphEntryEmptyInputPaths: emptyPaths });
-    }
 }
 export function assertCanonicalGraphDocumentMetadata(metadata, context) {
     const label = context.graphLabel ?? `Graph "${String(context.graphId ?? '?')}"`;

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/taskNodeMainReadiness.js

@@ -32,17 +32,6 @@ function collectGraphEntryInputPaths(graphEntry) {
         if (typeof p === 'string' && p.trim() !== '')
             paths.add(p.trim());
     }
-    for (const spec of graphEntry?.inputs ?? []) {
-        if (spec == null || typeof spec !== 'object')
-            continue;
-        const rec = spec;
-        if (rec.kind === 'execution')
-            continue;
-        if (rec.required === false)
-            continue;
-        if (typeof rec.path === 'string' && rec.path.trim() !== '')
-            paths.add(rec.path.trim());
-    }
     return [...paths];
 }
 function executionInputWatchPaths(args) {
@@ -76,7 +65,7 @@ function pathRequiresDeclaredEntry(path, graphEntry) {
     const declared = collectGraphEntryInputPaths(graphEntry);
     if (declared.length > 0)
         return true;
-    return (graphEntry.inputs?.length ?? 0) > 0 || (graphEntry.requiredExecutionPaths?.length ?? 0) > 0;
+    return (graphEntry.requiredExecutionPaths?.length ?? 0) > 0;
 }
 /**
  * Evaluates MAIN-readiness before invoking the skill. Paths resolve via {@link resolveGraphEngineMemoryPathValue}

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

@@ -528,63 +528,12 @@ export type DiscoveryDefinitionCatalogRequest = DiscoveryDefinitionCatalogReques
  * Declares a required catalog item that does not exist yet (gap / feature request).
  */
 export type CatalogRequestEntry = ScopedQuestionCatalogRequestEntry | DiscoveryDefinitionCatalogRequestEntry;
-/**
- * Semantic class of data a graph expects at Layer 01. Combinations are represented
- * by multiple `GraphEntryInputSpec` entries on `metadata.graphEntry.inputs`.
- */
-export type GraphEntryInputKind = 'record' | 'query' | 'user-input' | 'content' | 'metadata' | 'execution';
-export type GraphEntryValueInputKind = Exclude<GraphEntryInputKind, 'execution'>;
-/**
- * Design-time declaration shared by graph entry inputs.
- * **Declarative only:** core runtime does not validate or coerce these specs.
- */
-export type GraphEntryInputSpecBase = {
-    /** Semantic input class, e.g. `record`, `query`, `user-input`, `content`, or `execution`. */
-    kind: GraphEntryInputKind;
-    /** Stable name for tooling/templates when the path is not enough. */
-    name?: string;
-    /** One-line label for graph authors and UIs. */
-    title?: string;
-    /** Longer human-readable description for editors, catalogs, and docs. */
-    description?: string;
-    /** Defaults to true for authoring intent; runtime does not enforce it today. */
-    required?: boolean;
-    /** Optional JSON Schema for this specific input value. Validators may use it; core runtime does not. */
-    schema?: Record<string, unknown>;
-    [key: string]: unknown;
-};
-/**
- * Design-time declaration of one caller-supplied value in the graph execution object.
- * Paths are dot-paths under the merged `execution` object, usually `input.*`.
- */
-export type GraphEntryValueInputSpec = GraphEntryInputSpecBase & {
-    kind: GraphEntryValueInputKind;
-    /** Dot-path under merged `execution` where this input is expected, e.g. `input.subnetId`. */
-    path: string;
-};
-/**
- * Design-time declaration of a prior graph execution used as this graph's input.
- * A host/orchestrator can use `graphId` and `metadataFilter` to find the source execution,
- * then materialize it at `path` before calling `executeGraph`.
- */
-export type GraphEntryExecutionInputSpec = Omit<GraphEntryInputSpecBase, 'kind'> & {
-    kind: 'execution';
-    /** Source graph id whose completed execution should be used as input. */
-    graphId: string;
-    /** Metadata fields used by host tooling to select the matching source execution. */
-    metadataFilter?: Record<string, unknown>;
-    /** Dot-path under merged `execution` where the selected graph execution is expected. */
-    path?: string;
-};
-/**
- * Design-time declaration of one graph entry input.
- */
-export type GraphEntryInputSpec = GraphEntryValueInputSpec | GraphEntryExecutionInputSpec;
 /**
  * Layer 01 (graph entry): declares what callers should supply in `ExecuteGraphOptions.execution`
  * after merge — the seed for `execution.input.*` and related paths first-wave nodes read.
  * **Declarative only:** `executeGraph` does not validate this object; it is exposed via
  * `variables.__graphModel` for tools, composers, and documentation (see `.docs/graph-io-visibility.md`).
+ * Data source selection is an operator/work-factory concern (jobs-ui), not a graph document field.
  */
 export type GraphEntryContract = {
     /** One-line summary for authors and UIs. */
@@ -599,11 +548,6 @@ export type GraphEntryContract = {
      * `input.entityId`, `input.vulnerabilityId`). Same convention as `metadata.entityIdPath` roots.
      */
     requiredExecutionPaths?: string[];
-    /**
-     * Semantic entry inputs this graph is designed to work with. Use multiple entries for combinations
-     * (for example, `record` + `query`).
-     */
-    inputs?: GraphEntryInputSpec[];
     /**
      * Optional JSON Schema (e.g. draft 2020-12) for the merged `execution` object. Validators may use it; core runtime does not.
      */

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`.