ai-data-workflow-logic 0.1.11 → 0.1.14

package/src/filesystem.ts

@@ -1,6 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import type {
+  AIDataWorkflowChildInvocationIdentity,
+  AIDataWorkflowChildInvocationRuntimePort,
+  AIDataWorkflowChildTerminalReceipt,
   AIDataWorkflowRunCheckpoint,
   AIDataWorkflowRunGraph,
 } from 'ai-data-workflow-contract';
@@ -12,10 +15,13 @@ import type {
   AIWorkflowReusePolicy,
   FlowClosedValue,
 } from 'ai-workflow-contract';
+import type { EagerDataFlowModuleImporter } from 'eager-data-flow-logic';
 import type {
-  EagerDataFlowModuleImporter,
-} from 'eager-data-flow-logic';
-import type { EagerDataFlowDurableNodeState } from 'eager-data-flow-contract';
+  EagerDataFlowDurableNodeState,
+  EagerDataFlowExecutable,
+  EagerDataFlowExecutableRegistry,
+  EagerDataFlowRecord,
+} from 'eager-data-flow-contract';
 import {
   createFilesystemCodeResolver,
   materializeEagerDataFlowPlan,
@@ -30,6 +36,7 @@ import {
 } from 'ai-workflow-logic/checkpoint-filesystem';
 import {
   createInitialRunStepExtensions,
+  FlowRunCheckpointVersionConflictError,
   normalizeAIWorkflowProfileDurableState,
   normalizeFlowClosedObject,
   normalizeFlowClosedValue,
@@ -45,14 +52,27 @@ import {
 } from 'work-ctrl-flow-logic';
 import {
   commitAIDataWorkflowCheckpoint,
+  acceptAIDataWorkflowChildTerminalReceipt,
+  createAIDataWorkflowChildInvocationIdentity,
   createAIDataWorkflowCheckpoint,
   createAIDataWorkflowRunGraph,
   createAIDataWorkflowAgentNodeRuntimeBinder,
   loadAIDataWorkflowCheckpoint,
   loadAIDataWorkflowSources,
+  normalizeAIDataWorkflowChildInvocationObservation,
+  normalizeAIDataWorkflowChildTerminalReceipt,
+  projectAIDataWorkflowRunGraphPlan,
   recordAIDataWorkflowNodeResult,
+  recordAIDataWorkflowChildFreezeReceipt,
+  reserveAIDataWorkflowChildInvocation,
 } from './index.js';
 
+export interface MaterializedAIDataWorkflowChildFlow {
+  readonly definitionRef?: `resource://${string}`;
+  readonly contractDigest?: string;
+  readonly executable: EagerDataFlowExecutable<any>;
+}
+
 export interface MaterializedAIDataWorkflowRuntime {
   readonly supportRoot: string;
   readonly workflow: AIDataWorkflowRuntime;
@@ -60,6 +80,15 @@ export interface MaterializedAIDataWorkflowRuntime {
   readonly extensionCodecs?: DefinitionStepAssemblyRuntime['extensionCodecs'];
   readonly agentEffects?: AIAgentHostEffectPort;
   readonly agentTaskProofs?: Readonly<Record<string, FrozenAIAgentTaskBinding>>;
+  /** Exact admitted child definitions keyed by their eager-data-flow id. */
+  readonly childFlows?: Readonly<Record<string, MaterializedAIDataWorkflowChildFlow>>;
+  readonly childInvocations?: AIDataWorkflowChildInvocationRuntimePort;
+  /** Read-only lifecycle observation/fault-injection seam; it owns no parent or child facts. */
+  readonly childInvocationObserver?: (event: {
+    readonly phase: 'settled-before-parent-accept';
+    readonly identity: AIDataWorkflowChildInvocationIdentity;
+    readonly receipt: AIDataWorkflowChildTerminalReceipt;
+  }) => void | Promise<void>;
   readonly checkpointObserver?: (event: {
     readonly checkpoint: AIDataWorkflowRunCheckpoint;
     readonly nodeId: string;
@@ -209,43 +238,56 @@ async function executeAIDataCheckpoint(
     nodeId: string,
     phase: 'before' | 'after' | 'failed',
   ): Promise<void> => transition(async () => {
-    const owner = await loadAIDataWorkflowCheckpoint(checkpointRuntime, {
-      instanceId: checkpoint.instanceId,
-      runId: checkpoint.runId,
-    });
-    if (!owner) throw new Error(`AI Data Workflow checkpoint ${checkpoint.runId} disappeared during node transition.`);
-    accepted = owner;
-    graph = { ...owner.profile.runGraph, binding };
-    const nextGraph = updateGraph(graph);
-    const nextStatus = graphCheckpointStatus(nextGraph);
-    accepted = await commitAIDataWorkflowCheckpoint(checkpointRuntime, {
-      expectedVersion: accepted.version,
-      checkpoint: {
-        ...accepted,
-        version: accepted.version + 1,
-        state: { status: nextStatus, generation: nextGraph.currentGeneration },
-        output: graphCheckpointOutput(nextGraph, nextStatus),
-        controllerSidecars: { status: nextStatus },
-        nodeSidecars: nodeStatuses(nextGraph),
-        profile: { ...accepted.profile, runGraph: durableGraph(nextGraph) },
-      },
-    });
-    graph = { ...accepted.profile.runGraph, binding };
-    if (runtime.checkpointObserver) {
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const owner = await loadAIDataWorkflowCheckpoint(checkpointRuntime, {
+        instanceId: checkpoint.instanceId,
+        runId: checkpoint.runId,
+      });
+      if (!owner) throw new Error(`AI Data Workflow checkpoint ${checkpoint.runId} disappeared during node transition.`);
+      accepted = owner;
+      graph = { ...owner.profile.runGraph, binding };
+      const nextGraph = updateGraph(graph);
+      if (nextGraph === graph) return;
+      const nextStatus = graphCheckpointStatus(nextGraph);
       try {
-        await runtime.checkpointObserver({ checkpoint: accepted, nodeId, phase });
+        accepted = await commitAIDataWorkflowCheckpoint(checkpointRuntime, {
+          expectedVersion: accepted.version,
+          checkpoint: {
+            ...accepted,
+            version: accepted.version + 1,
+            state: { status: nextStatus, generation: nextGraph.currentGeneration },
+            output: graphCheckpointOutput(nextGraph, nextStatus),
+            controllerSidecars: { status: nextStatus },
+            nodeSidecars: nodeStatuses(nextGraph),
+            profile: { ...accepted.profile, runGraph: durableGraph(nextGraph) },
+          },
+        });
       } catch (cause) {
-        throw new AIDataCheckpointObserverError(cause);
+        if (cause instanceof FlowRunCheckpointVersionConflictError) continue;
+        throw cause;
       }
+      graph = { ...accepted.profile.runGraph, binding };
+      if (runtime.checkpointObserver) {
+        try {
+          await runtime.checkpointObserver({ checkpoint: accepted, nodeId, phase });
+        } catch (cause) {
+          throw new AIDataCheckpointObserverError(cause);
+        }
+      }
+      return;
     }
+    throw new Error(`AI Data Workflow node ${nodeId} checkpoint CAS did not converge.`);
   });
   let output: unknown;
   try {
-    const executable = await materializeEagerDataFlowPlan(binding.definition, {
+    const executionPlan = projectAIDataWorkflowRunGraphPlan(graph);
+    const executable = await materializeEagerDataFlowPlan(executionPlan, {
       resolveCode: createFilesystemCodeResolver(runtime.importModule),
+      subflows: createMaterializedChildRegistry(runtime, () => graph),
     });
     output = await executable.invoke(runtime.workflow, invocationInput, {
       completedNodes: completedEagerNodes(graph),
+      invokeSubFlow: createMaterializedChildInvoker(runtime, () => graph, commitGraph),
       ...(runtime.agentEffects ? {
         bindNode: ((binder) => (nodeRuntime: unknown, identity: { readonly nodeId: string }) => binder(
           nodeRuntime as AIDataWorkflowRuntime,
@@ -264,6 +306,14 @@ async function executeAIDataCheckpoint(
         return commitGraph((current) => {
           const node = current.nodes[nodeId];
           if (!node) throw new Error(`AI Data Workflow node ${nodeId} does not exist in the durable graph.`);
+          if (node.tag === 'SubFlowNode' && node.subflow?.kind === 'autonomous') {
+            const identity = node.childInvocation ?? createAIDataWorkflowChildInvocationIdentity({
+              graph: current,
+              parentInstanceId: checkpoint.instanceId,
+              nodeId,
+            });
+            return reserveAIDataWorkflowChildInvocation({ graph: current, identity });
+          }
           return recordAIDataWorkflowNodeResult(current, nodeId, {
             nodeId,
             generation: node.generation,
@@ -275,6 +325,7 @@ async function executeAIDataCheckpoint(
         return commitGraph((current) => {
           const node = current.nodes[settlement.nodeId];
           if (!node) throw new Error(`AI Data Workflow node ${settlement.nodeId} does not exist in the durable graph.`);
+          if (node.tag === 'SubFlowNode' && node.childTerminalReceipt) return current;
           return recordAIDataWorkflowNodeResult(current, settlement.nodeId, {
             nodeId: settlement.nodeId,
             generation: node.generation,
@@ -284,10 +335,13 @@ async function executeAIDataCheckpoint(
           });
         }, settlement.nodeId, 'after');
       },
-      onNodeFailure: ({ nodeId }) => {
+      onNodeFailure: ({ nodeId, cause }) => {
         return commitGraph((current) => {
           const node = current.nodes[nodeId];
           if (!node) throw new Error(`AI Data Workflow node ${nodeId} does not exist in the durable graph.`);
+          if (cause instanceof AIDataChildInvocationSuspendedError
+            || cause instanceof AIDataChildInvocationTerminalFailure
+            || findCheckpointObserverError(cause)) return current;
           return recordAIDataWorkflowNodeResult(current, nodeId, {
             nodeId,
             generation: node.generation,
@@ -310,6 +364,125 @@ async function executeAIDataCheckpoint(
   return { checkpoint: accepted, graph };
 }
 
+class AIDataChildInvocationSuspendedError extends Error {
+  constructor(nodeId: string, status: string) {
+    super(`AI Data child invocation ${nodeId} is ${status}; continue the parent checkpoint to resume it.`);
+    this.name = 'AIDataChildInvocationSuspendedError';
+  }
+}
+
+class AIDataChildInvocationTerminalFailure extends Error {
+  constructor(nodeId: string, code: string, message: string) {
+    super(`AI Data child invocation ${nodeId} failed (${code}): ${message}`);
+    this.name = 'AIDataChildInvocationTerminalFailure';
+  }
+}
+
+function createMaterializedChildRegistry(
+  runtime: MaterializedAIDataWorkflowRuntime,
+  currentGraph: () => AIDataWorkflowRunGraph,
+): EagerDataFlowExecutableRegistry<any> {
+  const registry: Record<string, EagerDataFlowExecutable<any>> = {};
+  for (const nodeId of currentGraph().declarationOrder) {
+    const node = currentGraph().nodes[nodeId];
+    if (!node || node.status === 'Removed' || node.tag !== 'SubFlowNode' || !node.subflow) continue;
+    const flowId = node.subflow.flowRef.slice('eager-data-flow://'.length);
+    const admitted = runtime.childFlows?.[flowId];
+    if (!admitted || admitted.executable.plan.fqn !== flowId) {
+      throw new Error(`AI Data child flow ${flowId} is not present in the admitted executable registry.`);
+    }
+    if (node.subflow.kind === 'autonomous' && (admitted.definitionRef !== node.subflow.definitionRef
+      || admitted.contractDigest !== node.subflow.contractDigest)) {
+      throw new Error(`AI Data child flow ${flowId} does not match its frozen definition and contract.`);
+    }
+    if (node.subflow.kind === 'autonomous' && !runtime.childInvocations) {
+      throw new Error(`AI Data autonomous child flow ${flowId} requires a child invocation runtime port.`);
+    }
+    registry[flowId] = admitted.executable;
+  }
+  return Object.freeze(registry);
+}
+
+function createMaterializedChildInvoker(
+  runtime: MaterializedAIDataWorkflowRuntime,
+  currentGraph: () => AIDataWorkflowRunGraph,
+  commitGraph: (
+    updateGraph: (current: AIDataWorkflowRunGraph) => AIDataWorkflowRunGraph,
+    nodeId: string,
+    phase: 'before' | 'after' | 'failed',
+  ) => Promise<void>,
+) {
+  return async (
+    workflow: AIDataWorkflowRuntime,
+    invocation: { readonly nodeId: string; readonly flowRef: string },
+    input: Readonly<EagerDataFlowRecord>,
+    options: { readonly signal: AbortSignal },
+  ): Promise<EagerDataFlowRecord> => {
+    const node = currentGraph().nodes[invocation.nodeId];
+    if (!node || node.tag !== 'SubFlowNode' || node.subflow?.flowRef !== invocation.flowRef) {
+      throw new Error(`AI Data child dispatch ${invocation.nodeId} does not match the current RunGraph.`);
+    }
+    const flowId = invocation.flowRef.slice('eager-data-flow://'.length);
+    const admitted = runtime.childFlows?.[flowId];
+    if (!admitted) throw new Error(`AI Data child flow ${flowId} is not admitted.`);
+    if (node.subflow.kind === 'declared') {
+      return admitted.executable.invoke(workflow, input, { signal: options.signal });
+    }
+    if (!node.childInvocation || !runtime.childInvocations) {
+      throw new Error(`AI Data child node ${invocation.nodeId} was not reserved before dispatch.`);
+    }
+    const identity = node.childInvocation;
+    let freeze = node.childFreezeReceipt;
+    if (!freeze) {
+      freeze = await runtime.childInvocations.resolveAndFreeze({ identity });
+      await commitGraph(
+        (graph) => recordAIDataWorkflowChildFreezeReceipt({ graph, nodeId: node.id, receipt: freeze! }),
+        node.id,
+        'before',
+      );
+      freeze = currentGraph().nodes[node.id].childFreezeReceipt;
+    }
+    if (!freeze) throw new Error(`AI Data child node ${node.id} freeze receipt was not committed.`);
+    let observation = normalizeAIDataWorkflowChildInvocationObservation(
+      await runtime.childInvocations.startOrContinue({
+        identity,
+        freeze,
+        input: normalizeFlowClosedObject(input, `aiData.child.${node.id}.input`),
+      }),
+      identity,
+    );
+    if (observation.status === 'Reserved' || observation.status === 'Running') {
+      observation = normalizeAIDataWorkflowChildInvocationObservation(
+        await runtime.childInvocations.load({ identity, freeze }),
+        identity,
+      );
+    }
+    if (observation.status === 'Reserved' || observation.status === 'Running') {
+      throw new AIDataChildInvocationSuspendedError(node.id, observation.status);
+    }
+    const receipt = normalizeAIDataWorkflowChildTerminalReceipt(
+      await runtime.childInvocations.settle({ identity, freeze, terminalStatus: observation.status }),
+      identity,
+    );
+    if (runtime.childInvocationObserver) {
+      try {
+        await runtime.childInvocationObserver({ phase: 'settled-before-parent-accept', identity, receipt });
+      } catch (cause) {
+        throw new AIDataCheckpointObserverError(cause);
+      }
+    }
+    await commitGraph(
+      (graph) => acceptAIDataWorkflowChildTerminalReceipt({ graph, nodeId: node.id, receipt }),
+      node.id,
+      receipt.status === 'Succeeded' ? 'after' : 'failed',
+    );
+    if (receipt.status === 'Failed') {
+      throw new AIDataChildInvocationTerminalFailure(node.id, receipt.failureCode, receipt.failureMessage);
+    }
+    return receipt.output as EagerDataFlowRecord;
+  };
+}
+
 class AIDataCheckpointObserverError extends Error {
   constructor(public override readonly cause: unknown) {
     super('AI Data checkpoint observer interrupted execution.');

package/src/index.ts

@@ -11,6 +11,9 @@ import type {
   AIDataWorkflowRunNode,
   AIDataWorkflowRunNodeStatus,
   AIDataWorkflowSemanticInput,
+  AIDataWorkflowSubFlowBinding,
+  AIDataWorkflowChildInvocationIdentity,
+  AIDataWorkflowChildTerminalReceipt,
 } from 'ai-data-workflow-contract';
 import type {
   AIDataWorkflowDefinitionBinding,
@@ -62,6 +65,8 @@ import {
 import { assertFrozenAIAgentTaskBinding } from 'ai-workflow-logic/run-freeze';
 
 export * from './holon-task.js';
+export * from './autonomous-control.js';
+export * from './child-invocation.js';
 
 export interface CreateAIDataWorkflowCheckpointInput {
   readonly instanceId: string;
@@ -286,12 +291,20 @@ function cloneInvalidation(invalidation: AIDataWorkflowInvalidation): AIDataWork
   return { ...invalidation };
 }
 
+function cloneSubflow(binding: AIDataWorkflowSubFlowBinding): AIDataWorkflowSubFlowBinding {
+  return { ...binding };
+}
+
 function cloneNode(node: AIDataWorkflowRunNode): AIDataWorkflowRunNode {
   return {
     ...node,
     inputs: cloneRecord(node.inputs),
     outputs: [...node.outputs],
     config: cloneRecord(node.config),
+    ...(node.subflow ? { subflow: cloneSubflow(node.subflow) } : {}),
+    ...(node.childInvocation ? { childInvocation: cloneChildInvocation(node.childInvocation) } : {}),
+    ...(node.childFreezeReceipt ? { childFreezeReceipt: { ...node.childFreezeReceipt } } : {}),
+    ...(node.childTerminalReceipt ? { childTerminalReceipt: cloneChildTerminalReceipt(node.childTerminalReceipt) } : {}),
     dependsOn: [...node.dependsOn],
     dependents: [...node.dependents],
     reusePolicy: { ...node.reusePolicy },
@@ -301,6 +314,16 @@ function cloneNode(node: AIDataWorkflowRunNode): AIDataWorkflowRunNode {
   };
 }
 
+function cloneChildInvocation(identity: AIDataWorkflowChildInvocationIdentity): AIDataWorkflowChildInvocationIdentity {
+  return { ...identity, subflow: { ...identity.subflow } };
+}
+
+function cloneChildTerminalReceipt(receipt: AIDataWorkflowChildTerminalReceipt): AIDataWorkflowChildTerminalReceipt {
+  return receipt.status === 'Succeeded'
+    ? { ...receipt, output: { ...receipt.output } }
+    : { ...receipt };
+}
+
 function cloneNodeResult(result: AIWorkflowNodeResult): AIWorkflowNodeResult {
   return {
     ...result,
@@ -325,7 +348,27 @@ function cloneGraph(graph: AIDataWorkflowRunGraph): AIDataWorkflowRunGraph {
     declarationOrder: [...graph.declarationOrder],
     patchHistory: graph.patchHistory.map((record) => ({
       ...record,
-      operations: record.operations.map((operation) => ({ ...operation })),
+      operations: record.operations.map((operation) => {
+        if (operation.op === 'add-node') {
+          return {
+            ...operation,
+            node: {
+              ...operation.node,
+              ...(operation.node.subflow ? { subflow: cloneSubflow(operation.node.subflow) } : {}),
+            },
+          };
+        }
+        if (operation.op === 'update-node') {
+          return {
+            ...operation,
+            changes: {
+              ...operation.changes,
+              ...(operation.changes.subflow ? { subflow: cloneSubflow(operation.changes.subflow) } : {}),
+            },
+          };
+        }
+        return { ...operation };
+      }),
     })),
     invalidations: graph.invalidations.map(cloneInvalidation),
   };
@@ -353,6 +396,40 @@ function nodeConfig(node: EagerDataFlowNodePlan): AIDataWorkflowNodeConfig {
   return {};
 }
 
+function nodeSubflow(node: EagerDataFlowNodePlan): AIDataWorkflowSubFlowBinding | undefined {
+  if (node.tag !== 'SubFlowNode') return undefined;
+  return {
+    kind: 'declared',
+    flowRef: node.flow as `eager-data-flow://${string}`,
+  };
+}
+
+function assertSubflowBinding(
+  tag: AIDataWorkflowNodeTag,
+  binding: AIDataWorkflowSubFlowBinding | undefined,
+  nodeId: string,
+): void {
+  if (tag === 'SubFlowNode' && !binding) {
+    throw new AIDataWorkflowRunGraphError(`AI Data Workflow SubFlowNode ${nodeId} requires an exact subflow binding`);
+  }
+  if (tag !== 'SubFlowNode' && binding) {
+    throw new AIDataWorkflowRunGraphError(`AI Data Workflow node ${nodeId} cannot carry a subflow binding`);
+  }
+  if (!binding) return;
+  if (!binding.flowRef.startsWith('eager-data-flow://') || binding.flowRef.length === 'eager-data-flow://'.length) {
+    throw new AIDataWorkflowRunGraphError(`AI Data Workflow SubFlowNode ${nodeId} has an invalid flow reference`);
+  }
+  if (binding.kind === 'autonomous' && (
+    binding.schemaVersion !== 'depa.ai-data-subflow-binding/v1'
+    || !binding.capabilityId
+    || !binding.catalogDigest
+    || !binding.contractDigest
+    || !binding.definitionRef.startsWith('resource://')
+  )) {
+    throw new AIDataWorkflowRunGraphError(`AI Data Workflow SubFlowNode ${nodeId} has an invalid autonomous binding`);
+  }
+}
+
 function configReusePolicy(config: AIDataWorkflowNodeConfig): AIWorkflowReusePolicy | undefined {
   const raw = config.reuse_policy ?? config.reusePolicy;
   return raw === 'semantic-hash' || raw === 'never' ? raw : undefined;
@@ -547,10 +624,12 @@ export function createAIDataWorkflowRunGraph(
         inputs: nodeInputs(planNode),
         outputs: nodeOutputs(planNode),
         config,
+        ...(nodeSubflow(planNode) ? { subflow: nodeSubflow(planNode) } : {}),
         dependsOn: dependencies.get(planNode.id) ?? [],
         dependents: [],
         reusePolicy,
       };
+      assertSubflowBinding(runNode.tag, runNode.subflow, runNode.id);
       return [planNode.id, runNode];
     }),
   );
@@ -573,6 +652,96 @@ export function createAIDataWorkflowRunGraph(
   return graph;
 }
 
+function isRunGraphPortReference(value: AIDataWorkflowNodeInputs[string]): value is import('eager-data-flow-contract').FlowPortReference {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value)
+    && typeof (value as { ref?: unknown }).ref === 'string'
+    && typeof (value as { nodeId?: unknown }).nodeId === 'string'
+    && typeof (value as { port?: unknown }).port === 'string');
+}
+
+/** Projects the current admitted RunGraph, including autonomous nodes, into the canonical Eager executor plan. */
+export function projectAIDataWorkflowRunGraphPlan(graph: AIDataWorkflowRunGraph): EagerDataFlowAuthoringPlan {
+  const activeOrder = graph.declarationOrder.filter((nodeId) => graph.nodes[nodeId]?.status !== 'Removed');
+  const nodePlans = activeOrder.map((nodeId): EagerDataFlowNodePlan => {
+    const node = graph.nodes[nodeId];
+    const base = graph.binding.definition.nodeById[nodeId]
+      ?? graph.binding.definition.nodes.find((candidate) => candidate.id === nodeId);
+    const dataDependencies = new Set(Object.values(node.inputs).flatMap((binding) => (
+      isRunGraphPortReference(binding) ? [binding.nodeId] : []
+    )));
+    const waitFor = node.dependsOn
+      .filter((dependency) => !dataDependencies.has(dependency))
+      .map((dependency) => ({ ref: `flow-node://#${dependency}`, nodeId: dependency }));
+    const common = { id: node.id, declarationIndex: node.declarationIndex, waitFor };
+    if (node.tag === 'EntryNode') return { ...common, tag: 'EntryNode', outputs: [...node.outputs] };
+    if (node.tag === 'ReturnNode') {
+      return { ...common, tag: 'ReturnNode', inputs: { ...node.inputs } } as EagerDataFlowNodePlan;
+    }
+    if (node.tag === 'SubFlowNode') {
+      if (!node.subflow) throw new AIDataWorkflowRunGraphError(`SubFlowNode ${node.id} has no durable child binding.`);
+      return {
+        ...common,
+        tag: 'SubFlowNode',
+        flow: node.subflow.flowRef,
+        inputs: { ...node.inputs },
+        outputs: [...node.outputs],
+      } as EagerDataFlowNodePlan;
+    }
+    if (node.tag !== 'TransformNode' && node.tag !== 'SinkNode') {
+      throw new AIDataWorkflowRunGraphError(`RunGraph node ${node.id} has unsupported executable tag ${node.tag}.`);
+    }
+    const configuredSource = typeof node.config.src === 'string' ? node.config.src : undefined;
+    const configuredImpl = typeof node.config.impl === 'string' ? node.config.impl : undefined;
+    const baseExecutable = base && (base.tag === 'TransformNode' || base.tag === 'SinkNode') ? base : undefined;
+    const executable = {
+      ...(configuredSource ?? baseExecutable?.src ? { src: configuredSource ?? baseExecutable?.src } : {}),
+      ...(configuredImpl ?? baseExecutable?.impl ? { impl: configuredImpl ?? baseExecutable?.impl } : {}),
+    };
+    return {
+      ...common,
+      tag: node.tag,
+      inputs: { ...node.inputs },
+      ...(node.tag === 'TransformNode' ? { outputs: [...node.outputs] } : {}),
+      ...executable,
+      config: { ...node.config },
+    } as EagerDataFlowNodePlan;
+  });
+  const nodeById = Object.fromEntries(nodePlans.map((node) => [node.id, node]));
+  const dataEdges = nodePlans.flatMap((node) => node.tag === 'EntryNode' ? [] : Object.entries(node.inputs).flatMap(
+    ([input, binding]) => isRunGraphPortReference(binding) ? [{
+      kind: 'data' as const,
+      fromNodeId: binding.nodeId,
+      fromPort: binding.port,
+      toNodeId: node.id,
+      toInput: input,
+      ref: binding.ref,
+    }] : [],
+  ));
+  const waitForEdges = nodePlans.flatMap((node) => node.waitFor.map((reference) => ({
+    kind: 'waitFor' as const,
+    fromNodeId: reference.nodeId,
+    toNodeId: node.id,
+    ref: reference.ref,
+  })));
+  const subflowEdges = nodePlans.flatMap((node) => node.tag === 'SubFlowNode' ? [{
+    kind: 'subflow' as const,
+    fromFlowId: graph.binding.definition.fqn,
+    nodeId: node.id,
+    targetFlowId: node.flow.slice('eager-data-flow://'.length),
+    ref: node.flow,
+  }] : []);
+  return {
+    ...graph.binding.definition,
+    nodes: nodePlans,
+    nodeById,
+    declarationOrder: activeOrder,
+    dataEdges,
+    waitForEdges,
+    subflowEdges,
+    diagnostics: [],
+  };
+}
+
 function makePatchNode(
   spec: AIDataWorkflowGraphPatchNodeSpec,
   generation: number,
@@ -587,6 +756,8 @@ function makePatchNode(
     platformDefaultPolicy,
   });
   assertReusePolicyAuthority(reusePolicy, nodeType, config, platformDefaultPolicy, spec.id);
+  const subflow = spec.subflow ? cloneSubflow(spec.subflow) : undefined;
+  assertSubflowBinding(tag, subflow, spec.id);
   return {
     id: spec.id,
     tag,
@@ -597,6 +768,7 @@ function makePatchNode(
     inputs: cloneRecord(spec.inputs),
     outputs: [...(spec.outputs ?? [])],
     config,
+    ...(subflow ? { subflow } : {}),
     dependsOn: uniqueStrings(spec.dependsOn ?? []),
     dependents: [],
     reusePolicy,
@@ -662,6 +834,9 @@ function applyInvalidations(
       const {
         result: _staleResult,
         semanticFingerprint: _staleFingerprint,
+        childInvocation: _staleChildInvocation,
+        childFreezeReceipt: _staleChildFreezeReceipt,
+        childTerminalReceipt: _staleChildTerminalReceipt,
         ...currentFacts
       } = node;
       nextNodes = {
@@ -782,6 +957,13 @@ export function applyAIDataWorkflowGraphPatch(
         );
       }
       const config = operation.changes.config ? cloneRecord(operation.changes.config) : existing.config;
+      const tag = operation.changes.tag ?? existing.tag;
+      const subflow = Object.prototype.hasOwnProperty.call(operation.changes, 'subflow')
+        ? operation.changes.subflow === null || operation.changes.subflow === undefined
+          ? undefined
+          : cloneSubflow(operation.changes.subflow)
+        : existing.subflow;
+      assertSubflowBinding(tag, subflow, existing.id);
       const nodeType = operation.changes.nodeType ?? existing.nodeType;
       const dependsOn = operation.changes.dependsOn
         ? uniqueStrings(operation.changes.dependsOn)
@@ -797,17 +979,26 @@ export function applyAIDataWorkflowGraphPatch(
           : existing.reusePolicy
       );
       assertReusePolicyAuthority(reusePolicy, nodeType, config, graph.platformDefaultPolicy, existing.id);
+      const { subflow: _existingSubflow, ...existingWithoutSubflow } = existing;
+      const {
+        childInvocation: _staleChildInvocation,
+        childFreezeReceipt: _staleChildFreezeReceipt,
+        childTerminalReceipt: _staleChildTerminalReceipt,
+        ...existingWithoutChild
+      } = existingWithoutSubflow;
+      const { subflow: _changedSubflow, ...changesWithoutSubflow } = operation.changes;
       nodes = {
         ...nodes,
         [existing.id]: {
-          ...existing,
-          ...operation.changes,
-          tag: operation.changes.tag ?? existing.tag,
+          ...existingWithoutChild,
+          ...changesWithoutSubflow,
+          tag,
           nodeType,
           generation,
           inputs: operation.changes.inputs ? cloneRecord(operation.changes.inputs) : existing.inputs,
           outputs: operation.changes.outputs ? [...operation.changes.outputs] : existing.outputs,
           config,
+          ...(subflow ? { subflow } : {}),
           dependsOn,
           reusePolicy,
         },
@@ -833,6 +1024,9 @@ export function applyAIDataWorkflowGraphPatch(
       result: _staleResult,
       semanticFingerprint: _staleFingerprint,
       invalidatedBy: _activeInvalidation,
+      childInvocation: _staleChildInvocation,
+      childFreezeReceipt: _staleChildFreezeReceipt,
+      childTerminalReceipt: _staleChildTerminalReceipt,
       ...currentFacts
     } = existing;
     nodes = {