ai-workflow-logic 0.1.9 → 0.1.11

package/src/agent-invocation.ts

@@ -121,8 +121,8 @@ function reserveName(ai: AIWorkflowProfileDurableState, receipt: AIAgentInvocati
 }
 
 function resolveSelector(ai: AIWorkflowProfileDurableState, selector: AIAgentSelector, config: AIAgentEffectConfig): AIAgentInstanceReference {
-  const instanceId = 'byInstanceId' in selector ? selector.byInstanceId : ai.instanceIdByName[selector.byInstanceName];
-  if (instanceId === undefined) fail('AI_AGENT_INSTANCE_NAME_NOT_FOUND', 'selector.byInstanceName', 'Named Agent instance does not exist.');
+  const instanceId = 'byId' in selector ? selector.byId : ai.instanceIdByName[selector.byName];
+  if (instanceId === undefined) fail('AI_AGENT_INSTANCE_NAME_NOT_FOUND', 'selector.byName', 'Named Agent instance does not exist.');
   const instance = ai.instancesById[instanceId];
   if (!instance) fail('AI_AGENT_INSTANCE_ID_NOT_FOUND', 'selector', 'Agent instance does not exist.');
   if (instance.instanceName !== undefined && ai.instanceIdByName[instance.instanceName] !== instance.instanceId) fail('AI_AGENT_INSTANCE_INDEX_CONFLICT', 'checkpoint.profile.ai', 'Agent instance indexes are not reciprocal.');

package/src/agent-resources.ts

@@ -1,5 +1,6 @@
 import type {
   AIAgentDefinitionProjection,
+  AIAgentMessagePrefixItemProjection,
   AIAgentMessageProjection,
   AIAgentMessageRole,
   AIWorkflowEffectPolicyProjection,
@@ -27,6 +28,8 @@ import { AIWorkflowResourceProjectionError } from './errors.js';
 
 const AGENT_SUBDOMAINS = Object.freeze([
   'Messages',
+  'MessagePrefix',
+  'ContextPipeline',
   'InputSchemaRef',
   'OutputSchemaRef',
   'ToolRefs',
@@ -144,12 +147,44 @@ function projectAgentDefinition(
   diagnostics: AIWorkflowResourceProjectionDiagnostic[],
 ): AIAgentDefinitionProjection | undefined {
   validateAllowedSubdomains(resource, AGENT_SUBDOMAINS, diagnostics);
-  const messagesNode = requiredSubdomain(resource, 'Messages', diagnostics);
+  const messagesNode = exactOptionalSubdomain(resource, 'Messages', diagnostics);
+  const messagePrefixNode = exactOptionalSubdomain(resource, 'MessagePrefix', diagnostics);
+  if (messagesNode && messagePrefixNode) {
+    diagnostics.push(diagnostic(
+      'AI_AGENT_MESSAGE_PREFIX_CONFLICT',
+      resource.documentUri,
+      'AIAgentDefinition must declare exactly one of legacy Messages or MessagePrefix.',
+    ));
+  } else if (!messagesNode && !messagePrefixNode) {
+    diagnostics.push(diagnostic(
+      'AI_AGENT_MESSAGE_PREFIX_MISSING',
+      resource.documentUri,
+      'AIAgentDefinition must declare legacy Messages or MessagePrefix.',
+    ));
+  }
   const toolRefsNode = requiredSubdomain(resource, 'ToolRefs', diagnostics);
   const materialPortRefsNode = requiredSubdomain(resource, 'MaterialPortRefs', diagnostics);
+  const projectedMessagePrefix = messagePrefixNode
+    ? projectMessagePrefix(resource, messagePrefixNode, resources, edges, diagnostics)
+    : undefined;
   const messages = messagesNode
     ? projectMessages(resource, messagesNode, resources, edges, diagnostics)
-    : [];
+    : projectedMessagePrefix
+      ? projectedMessagePrefix
+        .filter((item): item is Extract<AIAgentMessagePrefixItemProjection, { type: 'message' }> => item.type === 'message')
+        .map(({ type: _type, ...message }) => Object.freeze(message))
+      : [];
+  const messagePrefix = projectedMessagePrefix
+    ?? messages.map((message) => Object.freeze({ ...message, type: 'message' as const }));
+  const contextPipeline = projectOptionalTypedSubdomain(
+    resource,
+    'ContextPipeline',
+    resources,
+    'agent-context-pipeline',
+    edges,
+    diagnostics,
+    'AgentContextPipeline',
+  );
   const inputSchema = projectOptionalSchemaSubdomain(resource, 'InputSchemaRef', resources, 'agent-input-schema', edges, diagnostics);
   const outputSchema = projectOptionalSchemaSubdomain(resource, 'OutputSchemaRef', resources, 'agent-output-schema', edges, diagnostics);
   const tools = toolRefsNode
@@ -160,12 +195,14 @@ function projectAgentDefinition(
     ? projectTypedRefList(resource, materialPortRefsNode, 'MaterialPortRef', resources, 'agent-material-port', edges, diagnostics, 'MaterialPort')
     : [];
 
-  if (!messagesNode || !toolRefsNode || !materialPortRefsNode) return undefined;
+  if ((!messagesNode && !messagePrefixNode) || (messagesNode && messagePrefixNode) || !toolRefsNode || !materialPortRefsNode) return undefined;
   return Object.freeze({
     kind: 'AIAgentDefinition',
     fqn: resource.fqn ?? resource.resourceId,
     resource,
+    messagePrefix: Object.freeze(messagePrefix),
     messages: Object.freeze(messages),
+    ...(contextPipeline === undefined ? {} : { contextPipeline }),
     ...(inputSchema === undefined ? {} : { inputSchema }),
     ...(outputSchema === undefined ? {} : { outputSchema }),
     tools: Object.freeze(tools),
@@ -174,6 +211,67 @@ function projectAgentDefinition(
   });
 }
 
+function exactOptionalSubdomain(
+  resource: ResourceRecord,
+  name: string,
+  diagnostics: AIWorkflowResourceProjectionDiagnostic[],
+): ResourceNode | undefined {
+  const value = resource.node.subdomains[name];
+  if (!value) return undefined;
+  if (value.tag !== name) {
+    diagnostics.push(diagnostic(
+      'AI_RESOURCE_SUBDOMAIN_TAG_MISMATCH',
+      `${resource.documentUri}#${name}`,
+      `Subdomain ${name} must contain a ${name} node, got '${value.tag}'.`,
+    ));
+    return undefined;
+  }
+  return value;
+}
+
+function projectMessagePrefix(
+  resource: ResourceRecord,
+  prefixNode: ResourceNode,
+  resources: ReadonlyMap<string, ResourceRecord>,
+  edges: ResourceDependencyEdge[],
+  diagnostics: AIWorkflowResourceProjectionDiagnostic[],
+): AIAgentMessagePrefixItemProjection[] {
+  const output: AIAgentMessagePrefixItemProjection[] = [];
+  const ids = new Set<string>();
+  prefixNode.body.forEach((value, index) => {
+    const location = `${resource.documentUri}#MessagePrefix:${index}`;
+    if (!isResourceNode(value) || (value.tag !== 'Message' && value.tag !== 'MessageSource')) {
+      diagnostics.push(diagnostic(
+        'AI_AGENT_MESSAGE_PREFIX_NODE_INVALID',
+        location,
+        'MessagePrefix may contain only Message or MessageSource nodes.',
+      ));
+      return;
+    }
+    const id = canonicalString(value.resourceId);
+    if (!id) {
+      diagnostics.push(diagnostic('AI_AGENT_MESSAGE_ID_MISSING', location, `${value.tag} must declare an explicit #id.`));
+      return;
+    }
+    if (ids.has(id)) {
+      diagnostics.push(diagnostic('AI_AGENT_MESSAGE_ID_DUPLICATE', location, `MessagePrefix id '${id}' is declared more than once.`));
+      return;
+    }
+    ids.add(id);
+    if (value.tag === 'Message') {
+      const message = projectMessageNode(resource, value, resources, edges, diagnostics, location);
+      if (message) output.push(Object.freeze({ ...message, type: 'message' }));
+      return;
+    }
+    validateAllowedNodeSubdomains(value, [], location, diagnostics);
+    const source = projectTypedValues(value.properties.kind, value.properties.ref, resources, location, diagnostics, 'AgentMessageSource');
+    if (!source) return;
+    edges.push(edge(resource.resourceId, source.resource.resourceId, 'agent-message-source'));
+    output.push(Object.freeze({ type: 'message-source', id, source }));
+  });
+  return output;
+}
+
 function projectMessages(
   resource: ResourceRecord,
   messagesNode: ResourceNode,
@@ -189,39 +287,45 @@ function projectMessages(
       diagnostics.push(diagnostic('AI_AGENT_MESSAGE_NODE_INVALID', location, 'Messages may contain only Message nodes.'));
       return;
     }
-    validateAllowedNodeSubdomains(value, ['SchemaRef'], location, diagnostics);
     const id = canonicalString(value.resourceId);
-    const role = value.properties.role;
-    if (!id) {
-      diagnostics.push(diagnostic('AI_AGENT_MESSAGE_ID_MISSING', location, 'Message must declare an explicit #id.'));
-    } else if (ids.has(id)) {
+    if (id && ids.has(id)) {
       diagnostics.push(diagnostic('AI_AGENT_MESSAGE_ID_DUPLICATE', location, `Message id '${id}' is declared more than once.`));
-    } else {
-      ids.add(id);
+      return;
     }
-    if (!isMessageRole(role)) {
-      diagnostics.push(diagnostic('AI_AGENT_MESSAGE_ROLE_INVALID', location, 'Message role must be system, developer, user, or assistant.'));
+    if (id) {
+      ids.add(id);
     }
-    const prompt = projectTypedValues(
-      value.properties.promptKind,
-      value.properties.promptRef,
-      resources,
-      location,
-      diagnostics,
-    );
-    if (prompt) edges.push(edge(resource.resourceId, prompt.resource.resourceId, 'agent-message-prompt'));
-    const schemaNode = value.subdomains.SchemaRef;
-    const schema = schemaNode?.tag === 'SchemaRef'
-      ? projectMessageSchemaRefNode(schemaNode, resources, `${location}#SchemaRef`, diagnostics)
-      : undefined;
-    if (schemaNode && schemaNode.tag !== 'SchemaRef') diagnostics.push(diagnostic('AI_RESOURCE_SUBDOMAIN_TAG_MISMATCH', `${location}#SchemaRef`, `Subdomain SchemaRef must contain a SchemaRef node, got '${schemaNode.tag}'.`));
-    if (schema) edges.push(edge(resource.resourceId, schema.resource.resourceId, 'agent-message-schema'));
-    if (!id || !isMessageRole(role) || !prompt) return;
-    output.push(Object.freeze({ id, role, prompt, ...(schema === undefined ? {} : { schema }) }));
+    const message = projectMessageNode(resource, value, resources, edges, diagnostics, location);
+    if (message) output.push(message);
   });
   return output;
 }
 
+function projectMessageNode(
+  resource: ResourceRecord,
+  value: ResourceNode,
+  resources: ReadonlyMap<string, ResourceRecord>,
+  edges: ResourceDependencyEdge[],
+  diagnostics: AIWorkflowResourceProjectionDiagnostic[],
+  location: string,
+): AIAgentMessageProjection | undefined {
+  validateAllowedNodeSubdomains(value, ['SchemaRef'], location, diagnostics);
+  const id = canonicalString(value.resourceId);
+  const role = value.properties.role;
+  if (!id) diagnostics.push(diagnostic('AI_AGENT_MESSAGE_ID_MISSING', location, 'Message must declare an explicit #id.'));
+  if (!isMessageRole(role)) diagnostics.push(diagnostic('AI_AGENT_MESSAGE_ROLE_INVALID', location, 'Message role must be system, developer, user, or assistant.'));
+  const prompt = projectTypedValues(value.properties.promptKind, value.properties.promptRef, resources, location, diagnostics);
+  if (prompt) edges.push(edge(resource.resourceId, prompt.resource.resourceId, 'agent-message-prompt'));
+  const schemaNode = value.subdomains.SchemaRef;
+  const schema = schemaNode?.tag === 'SchemaRef'
+    ? projectMessageSchemaRefNode(schemaNode, resources, `${location}#SchemaRef`, diagnostics)
+    : undefined;
+  if (schemaNode && schemaNode.tag !== 'SchemaRef') diagnostics.push(diagnostic('AI_RESOURCE_SUBDOMAIN_TAG_MISMATCH', `${location}#SchemaRef`, `Subdomain SchemaRef must contain a SchemaRef node, got '${schemaNode.tag}'.`));
+  if (schema) edges.push(edge(resource.resourceId, schema.resource.resourceId, 'agent-message-schema'));
+  if (!id || !isMessageRole(role) || !prompt) return undefined;
+  return Object.freeze({ id, role, prompt, ...(schema === undefined ? {} : { schema }) });
+}
+
 function projectTypedRefList(
   owner: ResourceRecord,
   list: ResourceNode,
@@ -265,6 +369,7 @@ function projectOptionalTypedSubdomain(
   relation: AIWorkflowAgentResourceRelation,
   edges: ResourceDependencyEdge[],
   diagnostics: AIWorkflowResourceProjectionDiagnostic[],
+  expectedKind?: string,
 ): AIWorkflowTypedResourceRef | undefined {
   const node = owner.node.subdomains[name];
   if (!node) return undefined;
@@ -272,7 +377,7 @@ function projectOptionalTypedSubdomain(
     diagnostics.push(diagnostic('AI_RESOURCE_SUBDOMAIN_TAG_MISMATCH', `${owner.documentUri}#${name}`, `Subdomain ${name} must contain a ${name} node, got '${node.tag}'.`));
     return undefined;
   }
-  const typedRef = projectTypedRefNode(node, resources, `${owner.documentUri}#${name}`, diagnostics);
+  const typedRef = projectTypedRefNode(node, resources, `${owner.documentUri}#${name}`, diagnostics, expectedKind);
   if (typedRef) edges.push(edge(owner.resourceId, typedRef.resource.resourceId, relation));
   return typedRef;
 }

package/src/agent-state.ts

@@ -115,13 +115,13 @@ function optionalStringArray(value: unknown, location: string): readonly string[
 }
 
 export function normalizeAIAgentSelector(value: unknown, location = 'selector'): AIAgentSelector {
-  const input = record(value, [], ['byInstanceId', 'byInstanceName'], location);
-  const hasId = Object.prototype.hasOwnProperty.call(input, 'byInstanceId');
-  const hasName = Object.prototype.hasOwnProperty.call(input, 'byInstanceName');
+  const input = record(value, [], ['byId', 'byName'], location);
+  const hasId = Object.prototype.hasOwnProperty.call(input, 'byId');
+  const hasName = Object.prototype.hasOwnProperty.call(input, 'byName');
   if (hasId === hasName) fail('AI_AGENT_SELECTOR_EXACTLY_ONE', location, 'Selector must contain exactly one supported key.');
   return Object.freeze(hasId
-    ? { byInstanceId: identity(input.byInstanceId, `${location}.byInstanceId`) }
-    : { byInstanceName: identity(input.byInstanceName, `${location}.byInstanceName`) });
+    ? { byId: identity(input.byId, `${location}.byId`) }
+    : { byName: identity(input.byName, `${location}.byName`) });
 }
 
 export function normalizeAIAgentEffectConfig(value: unknown, location = 'config'): AIAgentEffectConfig {

package/src/checkpoint-store.ts

@@ -399,7 +399,9 @@ function validateAIDataProfileTransition(
         throw new FlowRunCheckpointTransitionError(`AI Data patch operation ${operation.op} is unsupported.`);
       }
       for (const [field, expected] of Object.entries(operation.changes)) {
-        if (!sameClosedValue(candidate[field as keyof typeof candidate], expected)) {
+        const actual = (candidate as Readonly<Record<string, unknown>>)[field];
+        if (field === 'subflow' && expected === null && actual === undefined) continue;
+        if (!sameClosedValue(actual, expected)) {
           throw new FlowRunCheckpointTransitionError(`AI Data update-node ${nodeId} does not project declared ${field}.`);
         }
       }

package/src/index.ts

@@ -36,6 +36,21 @@ import { AIWorkflowFoundationError, AIWorkflowResourceProjectionError } from './
 
 export { AIWorkflowFoundationError, AIWorkflowResourceProjectionError } from './errors.js';
 export { projectAIWorkflowAgentResources } from './agent-resources.js';
+export {
+  AIAgentDefinitionSelectionError,
+  admitAIAgentDefinitionSelection,
+  freezeSelectedAIAgentTaskBinding,
+  normalizeAIAgentTaskRequirement,
+  projectAIAgentDefinitionCandidates,
+  reconcileAuthoredAIAgentDefinition,
+} from './agent-definition-selection.js';
+export type {
+  AIAgentDefinitionSelectionErrorCode,
+  AdmitAIAgentDefinitionSelectionInput,
+  FreezeSelectedAIAgentTaskBindingInput,
+  ProjectAIAgentDefinitionCandidatesInput,
+  ReconcileAuthoredAIAgentDefinitionInput,
+} from './agent-definition-selection.js';
 export {
   FlowRunContractValidationError,
   normalizeAIWorkflowProfileDurableState,

package/src/run-checkpoint.ts

@@ -755,7 +755,10 @@ function normalizeAIDataRunGraph(value: unknown, runId: string, location: string
         'id', 'tag', 'nodeType', 'generation', 'status', 'declarationIndex', 'inputs',
         'outputs', 'config', 'dependsOn', 'dependents', 'reusePolicy',
       ],
-      ['semanticFingerprint', 'result', 'invalidatedBy'],
+      [
+        'subflow', 'childInvocation', 'childFreezeReceipt', 'childTerminalReceipt',
+        'semanticFingerprint', 'result', 'invalidatedBy',
+      ],
       nodeLocation,
     );
     const storedId = canonicalIdentity(dataField(node, 'id', `${nodeLocation}.id`), `${nodeLocation}.id`);
@@ -778,6 +781,46 @@ function normalizeAIDataRunGraph(value: unknown, runId: string, location: string
     normalizeAIDataInputs(dataField(node, 'inputs', `${nodeLocation}.inputs`), `${nodeLocation}.inputs`);
     uniqueIdentityArray(dataField(node, 'outputs', `${nodeLocation}.outputs`), `${nodeLocation}.outputs`);
     const config = plainRecord(dataField(node, 'config', `${nodeLocation}.config`), `${nodeLocation}.config`);
+    const tag = String(dataField(node, 'tag', `${nodeLocation}.tag`));
+    const hasSubflow = Object.prototype.hasOwnProperty.call(node, 'subflow');
+    if (tag === 'SubFlowNode' && !hasSubflow) {
+      invalid('AI_DATA_SUBFLOW_BINDING_MISSING', `${nodeLocation}.subflow`, 'SubFlowNode requires an exact durable child binding.');
+    }
+    if (tag !== 'SubFlowNode' && hasSubflow) {
+      invalid('AI_DATA_SUBFLOW_BINDING_INVALID', `${nodeLocation}.subflow`, 'Only SubFlowNode may carry a child binding.');
+    }
+    if (hasSubflow) normalizeAIDataSubflowBinding(dataField(node, 'subflow', `${nodeLocation}.subflow`), `${nodeLocation}.subflow`);
+    const hasChildInvocation = Object.prototype.hasOwnProperty.call(node, 'childInvocation');
+    const hasChildFreeze = Object.prototype.hasOwnProperty.call(node, 'childFreezeReceipt');
+    const hasChildTerminal = Object.prototype.hasOwnProperty.call(node, 'childTerminalReceipt');
+    if ((hasChildInvocation || hasChildFreeze || hasChildTerminal) && tag !== 'SubFlowNode') {
+      invalid('AI_DATA_CHILD_INVOCATION_NODE_INVALID', nodeLocation, 'Only SubFlowNode may carry child invocation facts.');
+    }
+    if ((hasChildFreeze || hasChildTerminal) && !hasChildInvocation) {
+      invalid('AI_DATA_CHILD_INVOCATION_IDENTITY_MISSING', nodeLocation, 'Child receipts require a reserved invocation identity.');
+    }
+    if (hasChildInvocation) {
+      const identity = normalizeAIDataChildInvocationIdentity(
+        dataField(node, 'childInvocation', `${nodeLocation}.childInvocation`),
+        graphRunId,
+        nodeId,
+        generation,
+        dataField(node, 'subflow', `${nodeLocation}.subflow`),
+        `${nodeLocation}.childInvocation`,
+      );
+      if (hasChildFreeze) normalizeAIDataChildFreezeReceipt(
+        dataField(node, 'childFreezeReceipt', `${nodeLocation}.childFreezeReceipt`),
+        identity,
+        `${nodeLocation}.childFreezeReceipt`,
+      );
+      if (hasChildTerminal) normalizeAIDataChildTerminalReceipt(
+        dataField(node, 'childTerminalReceipt', `${nodeLocation}.childTerminalReceipt`),
+        identity,
+        node,
+        String(status),
+        `${nodeLocation}.childTerminalReceipt`,
+      );
+    }
     const dependsOn = uniqueIdentityArray(dataField(node, 'dependsOn', `${nodeLocation}.dependsOn`), `${nodeLocation}.dependsOn`);
     const dependents = uniqueIdentityArray(dataField(node, 'dependents', `${nodeLocation}.dependents`), `${nodeLocation}.dependents`);
     normalizeReusePolicy(
@@ -811,6 +854,17 @@ function normalizeAIDataRunGraph(value: unknown, runId: string, location: string
         `${nodeLocation}.result`,
       );
       normalizeAIDataResultOutput(resultValue, node, String(status), bindingDefinition, `${nodeLocation}.result`);
+      if (hasChildTerminal) {
+        const childReceipt = plainRecord(
+          dataField(node, 'childTerminalReceipt', `${nodeLocation}.childTerminalReceipt`),
+          `${nodeLocation}.childTerminalReceipt`,
+        );
+        if (String(status) === 'Succeeded'
+          && JSON.stringify(dataField(childReceipt, 'output', `${nodeLocation}.childTerminalReceipt.output`))
+            !== JSON.stringify(dataField(plainRecord(resultValue, `${nodeLocation}.result`), 'output', `${nodeLocation}.result.output`))) {
+          invalid('AI_DATA_CHILD_PARENT_OUTPUT_MISMATCH', `${nodeLocation}.result.output`, 'Parent result must equal the accepted child output.');
+        }
+      }
     }
     const invalidationFacts: string[] = [];
     if (Object.prototype.hasOwnProperty.call(node, 'invalidatedBy')) {
@@ -988,12 +1042,176 @@ function normalizeInitialAIDataNodeProjection(
       ? dataField(definitionNode, 'config', `${location}.bindingNode.config`)
       : {},
     dependsOn: eagerDefinitionDependencies(definition, definitionNode, nodeId, location),
+    ...(dataField(definitionNode, 'tag', `${location}.bindingNode.tag`) === 'SubFlowNode'
+      ? {
+          subflow: {
+            kind: 'declared',
+            flowRef: dataField(definitionNode, 'flow', `${location}.bindingNode.flow`),
+          },
+        }
+      : {}),
   };
   for (const field of ['tag', 'declarationIndex', 'inputs', 'outputs', 'config', 'dependsOn'] as const) {
     if (JSON.stringify(dataField(node, field, `${location}.${field}`)) !== JSON.stringify(projected[field])) {
       invalid('AI_DATA_NODE_PROJECTION_MISMATCH', `${location}.${field}`, `Initial run node ${field} differs from its binding projection.`);
     }
   }
+  if (Object.prototype.hasOwnProperty.call(projected, 'subflow')
+    && JSON.stringify(dataField(node, 'subflow', `${location}.subflow`)) !== JSON.stringify(projected.subflow)) {
+    invalid('AI_DATA_NODE_PROJECTION_MISMATCH', `${location}.subflow`, 'Initial run node subflow differs from its binding projection.');
+  }
+}
+
+function normalizeAIDataSubflowBinding(value: unknown, location: string): void {
+  const binding = plainRecord(value, location);
+  const kind = dataField(binding, 'kind', `${location}.kind`);
+  if (kind === 'declared') {
+    exactRecord(value, ['kind', 'flowRef'], [], location);
+  } else if (kind === 'autonomous') {
+    const autonomous = exactRecord(
+      value,
+      ['kind', 'schemaVersion', 'capabilityId', 'catalogDigest', 'definitionRef', 'flowRef', 'contractDigest'],
+      [],
+      location,
+    );
+    if (dataField(autonomous, 'schemaVersion', `${location}.schemaVersion`) !== 'depa.ai-data-subflow-binding/v1') {
+      invalid('AI_DATA_SUBFLOW_BINDING_VERSION_INVALID', `${location}.schemaVersion`, 'Unsupported autonomous child binding version.');
+    }
+    const definitionRef = canonicalIdentity(dataField(autonomous, 'definitionRef', `${location}.definitionRef`), `${location}.definitionRef`);
+    if (!definitionRef.startsWith('resource://')) {
+      invalid('AI_DATA_SUBFLOW_DEFINITION_REF_INVALID', `${location}.definitionRef`, 'Child definition must use resource:// identity.');
+    }
+    for (const field of ['capabilityId', 'catalogDigest', 'contractDigest'] as const) {
+      canonicalIdentity(dataField(autonomous, field, `${location}.${field}`), `${location}.${field}`);
+    }
+  } else {
+    invalid('AI_DATA_SUBFLOW_BINDING_KIND_INVALID', `${location}.kind`, 'Child binding kind must be declared or autonomous.');
+  }
+  const flowRef = canonicalIdentity(dataField(binding, 'flowRef', `${location}.flowRef`), `${location}.flowRef`);
+  if (!flowRef.startsWith('eager-data-flow://')) {
+    invalid('AI_DATA_SUBFLOW_FLOW_REF_INVALID', `${location}.flowRef`, 'Child flow must use eager-data-flow:// identity.');
+  }
+}
+
+interface NormalizedAIDataChildInvocationIdentity {
+  readonly invocationKey: string;
+  readonly childInstanceId: string;
+  readonly childRunId: string;
+  readonly definitionRef: string;
+  readonly flowRef: string;
+  readonly contractDigest: string;
+}
+
+function normalizeAIDataChildInvocationIdentity(
+  value: unknown,
+  parentRunId: string,
+  parentNodeId: string,
+  parentGeneration: number,
+  subflowValue: unknown,
+  location: string,
+): NormalizedAIDataChildInvocationIdentity {
+  const identity = exactRecord(value, [
+    'schemaVersion', 'invocationKey', 'parentInstanceId', 'parentRunId', 'parentNodeId', 'parentGeneration',
+    'childInstanceId', 'childRunId', 'subflow',
+  ], [], location);
+  if (dataField(identity, 'schemaVersion', `${location}.schemaVersion`) !== 'depa.ai-data-child-invocation/v1') {
+    invalid('AI_DATA_CHILD_INVOCATION_SCHEMA_INVALID', `${location}.schemaVersion`, 'Unsupported child invocation schema.');
+  }
+  canonicalIdentity(dataField(identity, 'parentInstanceId', `${location}.parentInstanceId`), `${location}.parentInstanceId`);
+  if (canonicalIdentity(dataField(identity, 'parentRunId', `${location}.parentRunId`), `${location}.parentRunId`) !== parentRunId
+    || canonicalIdentity(dataField(identity, 'parentNodeId', `${location}.parentNodeId`), `${location}.parentNodeId`) !== parentNodeId
+    || nonNegativeSafeInteger(dataField(identity, 'parentGeneration', `${location}.parentGeneration`), `${location}.parentGeneration`) !== parentGeneration) {
+    invalid('AI_DATA_CHILD_INVOCATION_PARENT_MISMATCH', location, 'Child invocation identity must bind the owning parent node generation.');
+  }
+  const subflow = dataField(identity, 'subflow', `${location}.subflow`);
+  normalizeAIDataSubflowBinding(subflow, `${location}.subflow`);
+  if (JSON.stringify(subflow) !== JSON.stringify(subflowValue)) {
+    invalid('AI_DATA_CHILD_INVOCATION_SUBFLOW_MISMATCH', `${location}.subflow`, 'Child invocation must bind the exact node subflow.');
+  }
+  const normalizedSubflow = plainRecord(subflow, `${location}.subflow`);
+  if (dataField(normalizedSubflow, 'kind', `${location}.subflow.kind`) !== 'autonomous') {
+    invalid('AI_DATA_CHILD_INVOCATION_SUBFLOW_INVALID', `${location}.subflow`, 'Durable child invocation requires an autonomous subflow binding.');
+  }
+  return {
+    invocationKey: canonicalIdentity(dataField(identity, 'invocationKey', `${location}.invocationKey`), `${location}.invocationKey`),
+    childInstanceId: canonicalIdentity(dataField(identity, 'childInstanceId', `${location}.childInstanceId`), `${location}.childInstanceId`),
+    childRunId: canonicalIdentity(dataField(identity, 'childRunId', `${location}.childRunId`), `${location}.childRunId`),
+    definitionRef: canonicalIdentity(dataField(normalizedSubflow, 'definitionRef', `${location}.subflow.definitionRef`), `${location}.subflow.definitionRef`),
+    flowRef: canonicalIdentity(dataField(normalizedSubflow, 'flowRef', `${location}.subflow.flowRef`), `${location}.subflow.flowRef`),
+    contractDigest: canonicalIdentity(dataField(normalizedSubflow, 'contractDigest', `${location}.subflow.contractDigest`), `${location}.subflow.contractDigest`),
+  };
+}
+
+function assertAIDataChildReceiptIdentity(
+  value: Record<string, unknown>,
+  identity: NormalizedAIDataChildInvocationIdentity,
+  location: string,
+): void {
+  for (const [field, expected] of Object.entries(identity)) {
+    if (field === 'definitionRef' || field === 'flowRef' || field === 'contractDigest'
+      || field === 'invocationKey' || field === 'childInstanceId' || field === 'childRunId') {
+      if (canonicalIdentity(dataField(value, field, `${location}.${field}`), `${location}.${field}`) !== expected) {
+        invalid('AI_DATA_CHILD_RECEIPT_IDENTITY_MISMATCH', `${location}.${field}`, 'Child receipt does not match the reserved invocation.');
+      }
+    }
+  }
+}
+
+function normalizeAIDataChildFreezeReceipt(
+  value: unknown,
+  identity: NormalizedAIDataChildInvocationIdentity,
+  location: string,
+): void {
+  const receipt = exactRecord(value, [
+    'schemaVersion', 'invocationKey', 'childInstanceId', 'childRunId', 'definitionRef', 'flowRef',
+    'contractDigest', 'definitionRevision', 'definitionDigest',
+  ], [], location);
+  if (dataField(receipt, 'schemaVersion', `${location}.schemaVersion`) !== 'depa.ai-data-child-invocation/v1') {
+    invalid('AI_DATA_CHILD_FREEZE_SCHEMA_INVALID', `${location}.schemaVersion`, 'Unsupported child freeze schema.');
+  }
+  assertAIDataChildReceiptIdentity(receipt, identity, location);
+  canonicalIdentity(dataField(receipt, 'definitionRevision', `${location}.definitionRevision`), `${location}.definitionRevision`);
+  canonicalIdentity(dataField(receipt, 'definitionDigest', `${location}.definitionDigest`), `${location}.definitionDigest`);
+}
+
+function normalizeAIDataChildTerminalReceipt(
+  value: unknown,
+  identity: NormalizedAIDataChildInvocationIdentity,
+  node: Record<string, unknown>,
+  nodeStatus: string,
+  location: string,
+): void {
+  const base = plainRecord(value, location);
+  const terminalStatus = dataField(base, 'status', `${location}.status`);
+  const receipt = exactRecord(value, [
+    'schemaVersion', 'invocationKey', 'childInstanceId', 'childRunId', 'definitionRef', 'flowRef',
+    'contractDigest', 'status', 'receiptDigest',
+    ...(terminalStatus === 'Succeeded' ? ['output'] : ['failureCode', 'failureMessage']),
+  ], [], location);
+  if (dataField(receipt, 'schemaVersion', `${location}.schemaVersion`) !== 'depa.ai-data-child-invocation/v1') {
+    invalid('AI_DATA_CHILD_TERMINAL_SCHEMA_INVALID', `${location}.schemaVersion`, 'Unsupported child terminal schema.');
+  }
+  if (terminalStatus !== 'Succeeded' && terminalStatus !== 'Failed') {
+    invalid('AI_DATA_CHILD_TERMINAL_STATUS_INVALID', `${location}.status`, 'Child terminal receipt must be Succeeded or Failed.');
+  }
+  if (terminalStatus !== nodeStatus) {
+    invalid('AI_DATA_CHILD_TERMINAL_PARENT_STATUS_MISMATCH', `${location}.status`, 'Child terminal status must equal its parent node status.');
+  }
+  assertAIDataChildReceiptIdentity(receipt, identity, location);
+  canonicalIdentity(dataField(receipt, 'receiptDigest', `${location}.receiptDigest`), `${location}.receiptDigest`);
+  if (terminalStatus === 'Succeeded') {
+    const output = plainRecord(dataField(receipt, 'output', `${location}.output`), `${location}.output`);
+    const expected = [...identityArray(
+      dataField(node, 'outputs', `${location}.nodeOutputs`),
+      `${location}.nodeOutputs`,
+    )].sort(compareCodeUnits);
+    if (JSON.stringify(stringDataKeys(output, `${location}.output`).sort(compareCodeUnits)) !== JSON.stringify(expected)) {
+      invalid('AI_DATA_CHILD_TERMINAL_OUTPUT_MISMATCH', `${location}.output`, 'Child output keys must equal the parent SubFlowNode ports.');
+    }
+  } else {
+    canonicalIdentity(dataField(receipt, 'failureCode', `${location}.failureCode`), `${location}.failureCode`);
+    canonicalIdentity(dataField(receipt, 'failureMessage', `${location}.failureMessage`), `${location}.failureMessage`);
+  }
 }
 
 function eagerDefinitionDependencies(
@@ -1321,7 +1539,7 @@ function normalizeAIDataPatchNodeSpec(value: unknown, location: string): string
   const spec = exactRecord(
     value,
     ['id'],
-    ['tag', 'nodeType', 'declarationIndex', 'inputs', 'outputs', 'config', 'dependsOn', 'reusePolicy'],
+    ['tag', 'nodeType', 'declarationIndex', 'inputs', 'outputs', 'config', 'subflow', 'dependsOn', 'reusePolicy'],
     location,
   );
   const nodeId = canonicalIdentity(dataField(spec, 'id', `${location}.id`), `${location}.id`);
@@ -1333,7 +1551,7 @@ function normalizeAIDataPatchNodeChanges(value: unknown, location: string): void
   const changes = exactRecord(
     value,
     [],
-    ['tag', 'nodeType', 'inputs', 'outputs', 'config', 'dependsOn', 'reusePolicy'],
+    ['tag', 'nodeType', 'inputs', 'outputs', 'config', 'subflow', 'dependsOn', 'reusePolicy'],
     location,
   );
   normalizeAIDataPatchNodeFields(changes, location);
@@ -1349,6 +1567,10 @@ function normalizeAIDataPatchNodeFields(record: Record<string, unknown>, locatio
     if (Object.prototype.hasOwnProperty.call(record, field)) uniqueIdentityArray(dataField(record, field, `${location}.${field}`), `${location}.${field}`);
   }
   if (Object.prototype.hasOwnProperty.call(record, 'config')) plainRecord(dataField(record, 'config', `${location}.config`), `${location}.config`);
+  if (Object.prototype.hasOwnProperty.call(record, 'subflow')) {
+    const value = dataField(record, 'subflow', `${location}.subflow`);
+    if (value !== null) normalizeAIDataSubflowBinding(value, `${location}.subflow`);
+  }
   if (Object.prototype.hasOwnProperty.call(record, 'reusePolicy')) {
     const reuse = exactRecord(dataField(record, 'reusePolicy', `${location}.reusePolicy`), ['policy', 'source', 'nodeType'], [], `${location}.reusePolicy`);
     canonicalIdentity(dataField(reuse, 'nodeType', `${location}.reusePolicy.nodeType`), `${location}.reusePolicy.nodeType`);

package/src/run-freeze.ts

@@ -329,16 +329,26 @@ function semanticResourceFingerprint(
     },
     agent: {
       resourceId: agent.resource.resourceId,
-      messages: agent.messages.map((message) => ({
-        id: message.id,
-        role: message.role,
-        prompt: [message.prompt.kind, message.prompt.resource.resourceId],
-        schema: message.schema ? {
-          kind: message.schema.kind,
-          resourceId: message.schema.resource.resourceId,
-          value: message.schema.schema,
-        } : null,
-      })),
+      messagePrefix: agent.messagePrefix.map((item) => item.type === 'message'
+        ? {
+            type: item.type,
+            id: item.id,
+            role: item.role,
+            prompt: [item.prompt.kind, item.prompt.resource.resourceId],
+            schema: item.schema ? {
+              kind: item.schema.kind,
+              resourceId: item.schema.resource.resourceId,
+              value: item.schema.schema,
+            } : null,
+          }
+        : {
+            type: item.type,
+            id: item.id,
+            source: [item.source.kind, item.source.resource.resourceId],
+          }),
+      contextPipeline: agent.contextPipeline
+        ? [agent.contextPipeline.kind, agent.contextPipeline.resource.resourceId]
+        : null,
       inputSchema: agent.inputSchema ? {
         kind: agent.inputSchema.kind,
         resourceId: agent.inputSchema.resource.resourceId,