@exellix/graph-engine 8.5.0 → 8.7.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/README.md

@@ -55,7 +55,7 @@ npm install @exellix/graph-engine
 
 **Upstream tasks SDK:** This package depends on **`@exellix/ai-tasks` ^8.6.8** and **`@x12i/funcx` 4.4.4** (see **`package.json`**). Graph-engine emits **`RunTaskRequest`** shapes that match the ai-tasks **8.x** closed schema (mandatory **`executionStrategies`**, three-slot **`modelConfig`**, **`xynthesized`**, optional **`smartInput`**, no legacy root mirrors). Pin compatible versions in your app lockfile. Optional CI improvement: fail or warn when the resolved ai-tasks major/minor drifts outside an allowlist (not enforced in-repo today).
 
-### Execution matrix hosts (`@exellix/exellix-runtime`) — documentation only for the engine
+### Execution matrix hosts (`@x12i/exellix-runtime`) — documentation only for the engine
 
 Matrix **claim**, **rows**, and **retry policy** live outside this package. If your host wires **matrix → graph run**, see [.docs/execution-matrix-handoff.md](.docs/execution-matrix-handoff.md) for how **you** should inject `runtime.executeGraph`, compile **`GraphModelObject` → plan**, resolve **`metadata.graphEntry` per model**, seed **`runtime.executionMemory`**, and pass **`runtime.jobId`**. Helpers such as **`buildMatrixJobForGraphRun`** align **`id`** and **`job.jobId`** on the `job` object so you can call **`runtime.executeGraph({ plan, runtime: { jobId: job.jobId, job, … } })`**. Those exports are **optional helpers for callers**; they do **not** expand graph-engine’s role beyond **executing the single run** when invoked.
 
@@ -329,7 +329,7 @@ When **`taskConfiguration.aiTaskProfile.inputSynthesis`** is enabled, graph-engi
 
 1. **Engine PRE/POST strategy utilities (ai-tasks only):** `taskConfiguration.aiTaskProfile.preStrategyKey` / `postStrategyKey` → extra **`runTask`** calls via **`@exellix/ai-tasks`** before/after MAIN; outputs stored at **`execution.xynthesis.pre`** / **`execution.xynthesis.post`** (historical slot names).
 2. **`executionPipeline` inside ai-tasks:** e.g. PRE **`synthesized-context`** + MAIN direct — still **one** outbound MAIN `runTask` handled inside `@exellix/ai-tasks`.
-3. **Narrix web scope inside ai-tasks:** when **`taskConfiguration.aiTaskProfile.webScoping.enabled`** is true, graph-engine forwards a `narrix` payload with `enableWebScope` / `webScopeQuestions`. The actual web fetch + skip rules run **inside `@exellix/ai-tasks`** (`@exellix/narrix-web-scoper`); graph-engine has **no local web phase** in 5.x.
+3. **Narrix web scope inside ai-tasks:** when **`taskConfiguration.aiTaskProfile.webScoping.enabled`** is true, graph-engine forwards a `narrix` payload with `enableWebScope` / `webScopeQuestions`. The actual web fetch + skip rules run **inside `@exellix/ai-tasks`** (`@x12i/narrix-web-scoper`); graph-engine has **no local web phase** in 5.x.
 
 `synthesize` finalizers are a fourth outbound task-call shape: the finalizer is still a graph model node, but its terminal utility `runTask` uses the same run identity, diagnostics, `llmCall`, and resolved model config as the rest of the graph run.
 

package/dist/src/contract/graphRunContract.d.ts

@@ -0,0 +1,37 @@
+export type GraphRunPersistencyLink = {
+    /** Relation descriptor key (result entity → source entity). */
+    relationKey?: string;
+    /** Dot-path on the new record where the source recordId/entityId FK is written. */
+    fkPath?: string;
+    type?: 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany';
+    /** Content type the relation targets on the source (default: source job contentType). */
+    targetContentType?: string;
+};
+export type GraphRunPersistency = {
+    /** Target object type; default `same-as-input`. */
+    entityId: string | 'same-as-input';
+    /** Result collection content type; default {@link DEFAULT_GRAPH_RUN_PERSISTENCY_CONTENT_TYPE}. */
+    contentType: string;
+    /** When true (default), always insert a new result record with a new recordId. */
+    newRecord?: boolean;
+    /** Cross-object link intent; auto-derived when {@link entityId} differs from the job source. */
+    link?: GraphRunPersistencyLink;
+};
+export type GraphRunContract = {
+    graphId: string;
+    persistency: GraphRunPersistency | null;
+    graphVersion?: string;
+};
+/** Parse a work/job/graph persistency object (partial fields allowed). */
+export declare function parseGraphRunPersistency(raw: unknown): GraphRunPersistency | null;
+/** Work/job overrides win over graph defaults; partial overrides merge field-by-field. */
+export declare function mergeGraphRunPersistency(base: GraphRunPersistency | null, override: GraphRunPersistency | null): GraphRunPersistency | null;
+/** Apply a run/work/job persistency override onto a resolved graph contract. */
+export declare function applyGraphRunContractOverride(contract: GraphRunContract, persistencyOverride: unknown): GraphRunContract;
+/** Read graph document version from published graph JSON (`version` or `metadata.version`). */
+export declare function readGraphDocumentVersion(graphDoc: unknown): string | undefined;
+/** Resolve graph-run contract from published graph JSON (GRX-NOTE-001). */
+export declare function resolveGraphRunContract(graphId: string, graphDoc: unknown): GraphRunContract;
+export declare function loadGraphRunContracts(graphIds: string[], graphLoader: {
+    loadGraph(graphId: string): Promise<unknown>;
+}): Promise<GraphRunContract[]>;

package/dist/src/contract/graphRunContract.js

@@ -0,0 +1,130 @@
+import { DEFAULT_GRAPH_RUN_PERSISTENCY_CONTENT_TYPE } from './persistencyDefaults.js';
+const RELATION_TYPES = new Set(['oneToOne', 'oneToMany', 'manyToOne', 'manyToMany']);
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    return value;
+}
+function readLink(raw) {
+    const link = asRecord(raw);
+    if (!link)
+        return undefined;
+    const out = {};
+    if (typeof link.relationKey === 'string' && link.relationKey.length > 0) {
+        out.relationKey = link.relationKey;
+    }
+    if (typeof link.fkPath === 'string' && link.fkPath.length > 0) {
+        out.fkPath = link.fkPath;
+    }
+    if (typeof link.type === 'string' && RELATION_TYPES.has(link.type)) {
+        out.type = link.type;
+    }
+    if (typeof link.targetContentType === 'string' && link.targetContentType.length > 0) {
+        out.targetContentType = link.targetContentType;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function normalizePersistency(raw) {
+    const entityIdRaw = raw.entityId;
+    const entityId = entityIdRaw === 'same-as-input'
+        ? 'same-as-input'
+        : typeof entityIdRaw === 'string' && entityIdRaw.length > 0
+            ? entityIdRaw
+            : 'same-as-input';
+    const contentTypeRaw = raw.contentType;
+    const contentType = typeof contentTypeRaw === 'string' && contentTypeRaw.length > 0
+        ? contentTypeRaw
+        : DEFAULT_GRAPH_RUN_PERSISTENCY_CONTENT_TYPE;
+    const newRecord = raw.newRecord === false ? false : true;
+    const link = readLink(raw.link);
+    return {
+        entityId,
+        contentType,
+        newRecord,
+        ...(link ? { link } : {}),
+    };
+}
+/** Parse a work/job/graph persistency object (partial fields allowed). */
+export function parseGraphRunPersistency(raw) {
+    const rec = asRecord(raw);
+    if (!rec)
+        return null;
+    return normalizePersistency(rec);
+}
+/** Work/job overrides win over graph defaults; partial overrides merge field-by-field. */
+export function mergeGraphRunPersistency(base, override) {
+    if (!override)
+        return base;
+    if (!base)
+        return override;
+    return {
+        entityId: override.entityId,
+        contentType: override.contentType,
+        newRecord: override.newRecord !== undefined ? override.newRecord : base.newRecord,
+        link: override.link ? { ...base.link, ...override.link } : base.link,
+    };
+}
+function mergeRawPersistency(base, rawOverride) {
+    const overrideRec = asRecord(rawOverride);
+    if (!overrideRec)
+        return base;
+    const merged = {
+        ...(base
+            ? {
+                entityId: base.entityId,
+                contentType: base.contentType,
+                ...(base.newRecord === false ? { newRecord: false } : {}),
+                ...(base.link ? { link: { ...base.link } } : {}),
+            }
+            : {}),
+        ...overrideRec,
+    };
+    const overrideLink = asRecord(overrideRec.link);
+    if (base?.link && overrideLink) {
+        merged.link = { ...base.link, ...overrideLink };
+    }
+    return normalizePersistency(merged);
+}
+/** Apply a run/work/job persistency override onto a resolved graph contract. */
+export function applyGraphRunContractOverride(contract, persistencyOverride) {
+    return {
+        ...contract,
+        persistency: mergeRawPersistency(contract.persistency, persistencyOverride),
+    };
+}
+function readPersistency(graph) {
+    const response = asRecord(graph.response);
+    const fromResponse = asRecord(response?.persistency);
+    if (fromResponse) {
+        return normalizePersistency(fromResponse);
+    }
+    const metadata = asRecord(graph.metadata);
+    const graphResponse = asRecord(metadata?.graphResponse);
+    const legacy = asRecord(graphResponse?.persistency);
+    if (legacy) {
+        return normalizePersistency(legacy);
+    }
+    return null;
+}
+/** Read graph document version from published graph JSON (`version` or `metadata.version`). */
+export function readGraphDocumentVersion(graphDoc) {
+    const graph = asRecord(graphDoc) ?? {};
+    const metadata = asRecord(graph.metadata);
+    if (typeof graph.version === 'string')
+        return graph.version;
+    if (typeof metadata?.version === 'string')
+        return metadata.version;
+    return undefined;
+}
+/** Resolve graph-run contract from published graph JSON (GRX-NOTE-001). */
+export function resolveGraphRunContract(graphId, graphDoc) {
+    const graph = asRecord(graphDoc) ?? {};
+    return {
+        graphId,
+        persistency: readPersistency(graph),
+        graphVersion: readGraphDocumentVersion(graph),
+    };
+}
+export async function loadGraphRunContracts(graphIds, graphLoader) {
+    return Promise.all(graphIds.map(async (graphId) => resolveGraphRunContract(graphId, await graphLoader.loadGraph(graphId))));
+}

package/dist/src/contract/persistencyDefaults.d.ts

@@ -0,0 +1,2 @@
+/** Default result content type for graph-run persistency. */
+export declare const DEFAULT_GRAPH_RUN_PERSISTENCY_CONTENT_TYPE = "inferences";

package/dist/src/contract/persistencyDefaults.js

@@ -0,0 +1,2 @@
+/** Default result content type for graph-run persistency. */
+export const DEFAULT_GRAPH_RUN_PERSISTENCY_CONTENT_TYPE = 'inferences';

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,13 +72,14 @@ 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';
 /** Re-exported from `@exellix/ai-tasks` — preflight validation without `runTask`. */
 export { validateRunTaskConfig, validateRunTaskInvoke, analyzeExpectedRunTaskInput, checkExpectedInputAgainstRequest, collectSmartInputValidationIssues, buildRunTaskValidationContext, validateParsedOutput, listTokens, analyzeTemplateResolution, renderSmartInput, extractTokenNamesFromStrings, getSkillTokens, getSkillContent, } from '@exellix/ai-tasks';
 export type { RunTaskValidationIssue, RunTaskValidationResult, RunTaskInvokeValidationResult, ExpectedRunTaskInputPath, AnalyzeExpectedRunTaskInputResult, ValidateRunTaskInvokeParams, RunTaskTemplateResolver, OutputValidationResult, } from '@exellix/ai-tasks';
-export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground, EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME, EXELLIX_AI_TASKS_PACKAGE_NAME, } from './runtime/runtimeObjects.js';
+export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground, X12I_GRAPH_RUNTIME_PACKAGE_NAME, X12I_AI_TASKS_PACKAGE_NAME, } from './runtime/runtimeObjects.js';
 export type { ActivixQueryableClient, LogxerQueryableClient, LogxerLogLine, PackageRuntimeObjects, RuntimeObjects, BuildExellixGraphRuntimeObjectsInput, RuntimeObjectsObservabilitySummary, } from './runtime/runtimeObjects.js';
 export type { GetJobLogsInput, GetJobLogsResult, QueryableLogLine } from '@x12i/logxer';
 export { assertCanonicalGraphDocument, assertCanonicalTaskNode, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } from './runtime/validateCanonicalGraphDocument.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,8 @@ 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 { resolveGraphRunContract, loadGraphRunContracts, readGraphDocumentVersion, parseGraphRunPersistency, mergeGraphRunPersistency, applyGraphRunContractOverride, type GraphRunContract, type GraphRunPersistency, type GraphRunPersistencyLink, } from './contract/graphRunContract.js';
+export { DEFAULT_GRAPH_RUN_PERSISTENCY_CONTENT_TYPE } from './contract/persistencyDefaults.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,17 +55,17 @@ 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`. */
 export { validateRunTaskConfig, validateRunTaskInvoke, analyzeExpectedRunTaskInput, checkExpectedInputAgainstRequest, collectSmartInputValidationIssues, buildRunTaskValidationContext, validateParsedOutput, listTokens, analyzeTemplateResolution, renderSmartInput, extractTokenNamesFromStrings, getSkillTokens, getSkillContent, } from '@exellix/ai-tasks';
-export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground, EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME, EXELLIX_AI_TASKS_PACKAGE_NAME, } from './runtime/runtimeObjects.js';
+export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground, X12I_GRAPH_RUNTIME_PACKAGE_NAME, X12I_AI_TASKS_PACKAGE_NAME, } from './runtime/runtimeObjects.js';
 export { assertCanonicalGraphDocument, assertCanonicalTaskNode, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } from './runtime/validateCanonicalGraphDocument.js';
 export { assertCanonicalGraphRuntimeObject } from './runtime/validateCanonicalGraphRuntime.js';
 export { GRAPH_ENTRY_STUDIO_ONLY_KEYS, GRAPH_METADATA_STUDIO_ONLY_KEYS, stripGraphModelStudioFields, primaryRuntimeInputFromStudioDocument, getGraphEntryStudioOnlyKeyViolations, getGraphMetadataStudioOnlyKeyViolations, } 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';
@@ -87,5 +88,8 @@ export { composeEventEmitters } from './runtime/events.js';
 export { createPlaygroundReporter } from './playground/index.js';
 // Graph Inspection API
 export { getNodeScopingQuestion, getNodeMemoryShape, getNodeNarrixDiscovery, fetchNodeScopingData, inspectNode, resolveNodeSkillKey, getGraphNodes, getGraphCatalogs, inspectGraph, collectPredicatePaths, executionMemoryPathTail, executionMemoryTailsMatch, getNodeExecutionMemoryWriteTails, getNodeControlDependencies, getNodeSideEffects, inspectFinalizer, inspectNodeContract, inspectGraphContracts, EXELLIX_VIRTUAL_GRAPH_ENTRY_NODE_ID, EXELLIX_VIRTUAL_GRAPH_RESPONSE_NODE_ID, EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY, EXELLIX_VIRTUAL_BOUNDARY_EDGE_FLAG_KEY, getVirtualGraphEntryLayer, getVirtualGraphResponseLayer, materializeVirtualBoundaryDiagram, stripMaterializedVirtualBoundaryDiagram, validateCatalogPlanning, isCatalogBinding, isCatalogRequestEntry, inspectGraphModelSelection, } from './inspection/index.js';
+// Graph-run contract (GRX-NOTE-001) — persistency intent from published graph JSON
+export { resolveGraphRunContract, loadGraphRunContracts, readGraphDocumentVersion, parseGraphRunPersistency, mergeGraphRunPersistency, applyGraphRunContractOverride, } from './contract/graphRunContract.js';
+export { DEFAULT_GRAPH_RUN_PERSISTENCY_CONTENT_TYPE } from './contract/persistencyDefaults.js';
 export { shutdownMemorixRuntime } from './runtime/localSkills/memorixRuntime.js';
 // Web context rendering — consume execution.webContext → markdown for prompts (Layer 04)

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/integrations/activixExellixShared.js

@@ -1,4 +1,4 @@
-import { EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME } from '../runtime/runtimeObjects.js';
+import { X12I_GRAPH_RUNTIME_PACKAGE_NAME } from '../runtime/runtimeObjects.js';
 /** Recommended Mongo indexes for exellix-graph Activix streams (see `@x12i/activix` README). */
 export const ACTIVIX_EXELLIX_RUN_CONTEXT_INDEXES = [
     { keys: { 'runContext.jobId': 1 } },
@@ -55,5 +55,5 @@ export function buildNodeActivixRunContext(args) {
     };
 }
 export function activixExellixCollectionRegistryOwner() {
-    return { package: EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME };
+    return { package: X12I_GRAPH_RUNTIME_PACKAGE_NAME };
 }

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.