ai-workflow-logic 0.2.1 → 0.2.3

package/src/run-freeze.ts

@@ -10,12 +10,6 @@ import type {
   CompiledAIAgentCodeExecution,
   AIAgentCodeExecutionIdentity,
 } from 'ai-workflow-contract';
-import {
-  normalizeHolonTaskTarget,
-  type AIWorkflowHolonTaskTargetFreezeReceipt,
-  type FrozenHolonTaskTarget,
-  type HolonTaskTarget,
-} from 'ai-workflow-contract';
 import {
   buildResourceDependencySnapshot,
   composeLayeredResourceRegistry,
@@ -72,125 +66,6 @@ export class AIWorkflowRunResourceFreezeError extends Error {
 const authenticFreezeReceipts = new WeakSet<object>();
 const authenticTaskBindings = new WeakSet<object>();
 const receiptByTaskBinding = new WeakMap<object, AIWorkflowRunResourceFreezeReceipt>();
-const authenticHolonTargetFreezeReceipts = new WeakSet<object>();
-const authenticFrozenHolonTargets = new WeakSet<object>();
-
-export interface FreezeAIWorkflowHolonTaskTargetInput {
-  readonly registry: EffectiveResourceRegistry;
-  readonly target: HolonTaskTarget;
-  readonly contentIdentities: ReadonlyMap<string, ResourceContentIdentity>;
-}
-
-export async function freezeAIWorkflowHolonTaskTargetFromDirectory(
-  rootDir: string,
-  target: HolonTaskTarget,
-): Promise<AIWorkflowHolonTaskTargetFreezeReceipt> {
-  const authoredTree = await loadResourceTree({ rootDir });
-  const tree = resolveAIWorkflowResourceTree(authoredTree);
-  const layers = [{ id: 'workspace', tree }] as const;
-  const registry = composeLayeredResourceRegistry({ layers });
-  return freezeAIWorkflowHolonTaskTarget({
-    registry,
-    target,
-    contentIdentities: createResolvedAIWorkflowContentIdentityIndex(tree),
-  });
-}
-
-export function freezeAIWorkflowHolonTaskTarget(
-  input: FreezeAIWorkflowHolonTaskTargetInput,
-): AIWorkflowHolonTaskTargetFreezeReceipt {
-  const target = normalizeHolonTaskTarget(input.target);
-  const references = Object.freeze([
-    target.invocation.workflowRef,
-    target.executionBinding.ref,
-    target.taskSpace.profileRef,
-    target.taskSpace.policyRef,
-    ...target.taskSpace.requiredCapabilityRefs,
-    target.output.schemaRef,
-    ...target.output.materialPortRefs,
-  ]);
-  const roots = references.map(resourceIdFromRef).filter((value): value is string => value !== undefined);
-  if (roots.length !== references.length) throw new AIWorkflowRunResourceFreezeError(Object.freeze([
-    diagnostic('AI_RUN_HOLON_TARGET_REF_INVALID', 'run-freeze:holon-target', 'Every target reference must be one exact resource:// identity.'),
-  ]));
-  const workflowId = resourceIdFromRef(target.invocation.workflowRef)!;
-  const workflow = input.registry.byId.get(workflowId)?.resource;
-  if (!workflow || workflow.kind !== target.invocation.workflowKind) throw new AIWorkflowRunResourceFreezeError(Object.freeze([
-    diagnostic('AI_RUN_HOLON_TARGET_WORKFLOW_MISSING', target.invocation.workflowRef, 'Target workflow is absent or has another kind.'),
-  ]));
-  const bindingId = resourceIdFromRef(target.executionBinding.ref)!;
-  const binding = input.registry.byId.get(bindingId)?.resource;
-  if (!binding || binding.kind !== 'HolonExecutionBinding') throw new AIWorkflowRunResourceFreezeError(Object.freeze([
-    diagnostic('AI_RUN_HOLON_EXECUTION_BINDING_MISSING', target.executionBinding.ref, 'Execution binding is absent or has another kind.'),
-  ]));
-  const bindingIdentity = input.contentIdentities.get(bindingId);
-  if (!bindingIdentity || bindingIdentity.contentDigest !== target.executionBinding.digest) {
-    throw new AIWorkflowRunResourceFreezeError(Object.freeze([
-      diagnostic('AI_RUN_HOLON_EXECUTION_BINDING_DIGEST_MISMATCH', target.executionBinding.ref, 'Execution binding digest differs from the admitted resource content identity.'),
-    ]));
-  }
-  for (const resourceId of roots) {
-    if (!input.registry.byId.get(resourceId)?.resource || !input.contentIdentities.has(resourceId)) {
-      throw new AIWorkflowRunResourceFreezeError(Object.freeze([
-        diagnostic('AI_RUN_HOLON_TARGET_CLOSURE_MISSING', `resource://${resourceId}`, 'Target closure member is absent from the admitted registry.'),
-      ]));
-    }
-  }
-  const dependencySnapshot = buildResourceDependencySnapshot({
-    registry: input.registry,
-    roots,
-    edges: references.slice(1).map((ref, index) => ({
-      fromResourceId: workflowId,
-      toResourceId: resourceIdFromRef(ref)!,
-      relation: 'workflow-holon-task-target',
-      declaredBy: `${workflowId}#${target.invocation.nodeId}:${index}`,
-    })),
-    contentIdentities: input.contentIdentities,
-  });
-  const closureResourceIds = Object.freeze(dependencySnapshot.closure.map(({ resourceId }) => resourceId));
-  const semanticFingerprint = sha256Digest(JSON.stringify({
-    schemaVersion: 'ai-workflow.holon-task-target-semantic/v1',
-    target,
-    closure: dependencySnapshot.closure.map(({ resourceId, kind, contentDigest }) => ({ resourceId, kind, contentDigest })),
-  }));
-  const receipt = Object.freeze({
-    schemaVersion: 'ai-workflow.holon-task-target-freeze/v1' as const,
-    target,
-    dependencySnapshot: Object.freeze({
-      registryRevision: dependencySnapshot.registryRevision,
-      snapshotRevision: dependencySnapshot.snapshotRevision,
-      closureResourceIds,
-    }),
-    semanticFingerprint,
-  });
-  authenticHolonTargetFreezeReceipts.add(receipt);
-  return receipt;
-}
-
-export function projectFrozenHolonTaskTarget(
-  receipt: AIWorkflowHolonTaskTargetFreezeReceipt,
-): FrozenHolonTaskTarget {
-  if (!authenticHolonTargetFreezeReceipts.has(receipt as object)) throw new AIWorkflowRunResourceFreezeError(Object.freeze([
-    diagnostic('AI_RUN_HOLON_TARGET_FREEZE_RECEIPT_UNTRUSTED', 'run-freeze:holon-target-receipt', 'Target proof requires the authentic receipt produced by run freeze.'),
-  ]));
-  const proof = Object.freeze({
-    schemaVersion: 'ai-workflow.frozen-holon-task-target/v1' as const,
-    target: receipt.target,
-    semanticFingerprint: receipt.semanticFingerprint,
-    snapshotRevision: receipt.dependencySnapshot.snapshotRevision,
-    closureResourceIds: receipt.dependencySnapshot.closureResourceIds,
-  });
-  authenticFrozenHolonTargets.add(proof);
-  return proof;
-}
-
-export function assertFrozenHolonTaskTarget(value: FrozenHolonTaskTarget): FrozenHolonTaskTarget {
-  if (!authenticFrozenHolonTargets.has(value as object)) throw new AIWorkflowRunResourceFreezeError(Object.freeze([
-    diagnostic('AI_RUN_HOLON_TARGET_PROOF_UNTRUSTED', 'run-freeze:holon-target-proof', 'Holon task target was not projected from an authentic target freeze receipt.'),
-  ]));
-  return value;
-}
-
 export function freezeAIWorkflowRunResources(
   input: FreezeAIWorkflowRunResourcesInput,
 ): AIWorkflowRunResourceFreezeReceipt {

package/src/holon-task.ts

@@ -1,199 +0,0 @@
-import {
-  createAIOrganizationTaskProfile,
-  normalizeHolonTaskTarget,
-  normalizeHolonTaskSnapshotReceipt,
-  type HolonTaskSnapshotReceipt,
-  type AIOrganizationTaskProfile,
-  type HolonTaskTarget,
-} from 'ai-workflow-contract';
-import {
-  canonicalHolonEffectiveSnapshotIssuanceReceiptBytes,
-  parseHolonEffectiveSnapshotBytes,
-  parseHolonEffectiveSnapshotIssuanceReceiptBytes,
-} from 'holarchy-core-contract';
-import { sha256Digest } from 'halfcode-compiler.xnl/resource-core';
-import type { TaskArtifactBody, TaskArtifactRef } from 'task-manager-contract';
-import { createTaskSpace, type TaskManagerRuntime, type TaskProcessorResult } from 'task-manager-logic';
-import type { TaskTransitionReceipt } from 'task-manager-contract';
-
-export interface HolonOrganizationSnapshotReadInput {
-  readonly rootHolonRef: string;
-  readonly effectiveAt: string;
-}
-
-export interface HolonOrganizationSnapshotReadResult {
-  readonly snapshotBytes: Uint8Array;
-  readonly issuanceReceiptBytes: Uint8Array;
-}
-
-export interface HolonOrganizationSnapshotReadPort {
-  readEffectiveSnapshot(input: HolonOrganizationSnapshotReadInput): Promise<HolonOrganizationSnapshotReadResult>;
-}
-
-export interface CreateHolonTaskSpaceRuntime {
-  readonly taskManager: TaskManagerRuntime;
-  readonly organizationSnapshots: HolonOrganizationSnapshotReadPort;
-}
-
-export interface CreateHolonTaskSpaceInput {
-  readonly commandId: string;
-  readonly taskSpaceId: string;
-  readonly taskId: string;
-  readonly taskName: string;
-  readonly target: HolonTaskTarget;
-  readonly createdAt: string;
-}
-
-export interface CreateHolonTaskSpaceConfig {
-  readonly maxTasks: number;
-  readonly maxRelations: number;
-  readonly maxLeaseDurationMs: number;
-}
-
-export interface CreateHolonTaskSpaceResult extends TaskProcessorResult<TaskTransitionReceipt> {
-  readonly snapshotReceipt: HolonTaskSnapshotReceipt;
-}
-
-export interface PreparedHolonTaskSnapshot {
-  readonly target: HolonTaskTarget;
-  readonly snapshotReceipt: HolonTaskSnapshotReceipt;
-  readonly profile: AIOrganizationTaskProfile;
-  readonly artifactRefs: readonly TaskArtifactRef[];
-  readonly artifactBodies: readonly TaskArtifactBody[];
-}
-
-export async function prepareHolonTaskSnapshot(
-  runtime: Pick<CreateHolonTaskSpaceRuntime, 'organizationSnapshots'>,
-  input: Readonly<{
-    readonly taskSpaceId: string;
-    readonly target: HolonTaskTarget;
-    readonly snapshotAdoptions?: readonly unknown[];
-  }>,
-): Promise<PreparedHolonTaskSnapshot> {
-  const target = normalizeHolonTaskTarget(input.target);
-  const issued = await runtime.organizationSnapshots.readEffectiveSnapshot({
-    rootHolonRef: target.holon.rootHolonRef,
-    effectiveAt: target.holon.effectiveAt,
-  });
-  const snapshotBytes = exactBytes(issued.snapshotBytes, 'snapshotBytes');
-  const receiptBytes = exactBytes(issued.issuanceReceiptBytes, 'issuanceReceiptBytes');
-  const snapshot = await parseHolonEffectiveSnapshotBytes(snapshotBytes);
-  const issuerReceipt = parseHolonEffectiveSnapshotIssuanceReceiptBytes(receiptBytes, snapshot);
-  if (snapshot.rootHolonRef !== target.holon.rootHolonRef || snapshot.effectiveAt !== target.holon.effectiveAt) {
-    throw new Error('HOLON_TASK_SNAPSHOT_TARGET_MISMATCH: issuer snapshot does not bind the requested Holon/effectiveAt');
-  }
-  const canonicalReceiptBytes = canonicalHolonEffectiveSnapshotIssuanceReceiptBytes(issuerReceipt, snapshot);
-  if (!sameBytes(receiptBytes, canonicalReceiptBytes)) {
-    throw new Error('HOLON_TASK_ISSUER_RECEIPT_NON_CANONICAL: issuer receipt bytes changed during validation');
-  }
-  const snapshotArtifact = artifact(snapshotBytes, 'application/vnd.holarchy.effective-snapshot+json', 'holon-effective-snapshot.json');
-  const receiptArtifact = artifact(receiptBytes, 'application/vnd.holarchy.snapshot-issuance-receipt+json', 'holon-effective-snapshot-receipt.json');
-  const eligibleMemberRefs = Object.freeze(snapshot.records.filter((record) => record.kind === 'Member').map((record) => record.id).sort(compareUtf16));
-  const eligibleRoleRefs = Object.freeze(snapshot.records.filter((record) => record.kind === 'Role').map((record) => record.id).sort(compareUtf16));
-  const snapshotReceipt = normalizeHolonTaskSnapshotReceipt({
-    kind: 'holon-task-snapshot-receipt',
-    schemaVersion: 'ai-workflow.holon-task-snapshot-receipt/v1',
-    taskSpaceId: exactString(input.taskSpaceId, 'taskSpaceId'),
-    holonRef: snapshot.rootHolonRef,
-    effectiveAt: snapshot.effectiveAt,
-    holonSnapshotRef: snapshot.snapshotId,
-    holonSnapshotDigest: snapshot.treeDigest,
-    snapshotArtifactDigest: snapshotArtifact.ref.digest,
-    issuerReceiptId: sha256Digest(receiptBytes),
-    issuerReceiptArtifactDigest: receiptArtifact.ref.digest,
-    executionBindingRef: target.executionBinding.ref,
-    executionBindingDigest: target.executionBinding.digest,
-    eligibleMemberRefs,
-    eligibleRoleRefs,
-  });
-  return Object.freeze({
-    target,
-    snapshotReceipt,
-    profile: createAIOrganizationTaskProfile(target, snapshotReceipt, input.snapshotAdoptions),
-    artifactRefs: Object.freeze([snapshotArtifact.ref, receiptArtifact.ref]),
-    artifactBodies: Object.freeze([snapshotArtifact.body, receiptArtifact.body]),
-  });
-}
-
-export async function createHolonTaskSpace(
-  runtime: CreateHolonTaskSpaceRuntime,
-  input: CreateHolonTaskSpaceInput,
-  config: CreateHolonTaskSpaceConfig,
-): Promise<CreateHolonTaskSpaceResult> {
-  const prepared = await prepareHolonTaskSnapshot(runtime, {
-    taskSpaceId: input.taskSpaceId,
-    target: input.target,
-  });
-  const result = await createTaskSpace(runtime.taskManager, {
-    kind: 'task-space.create',
-    commandId: exactString(input.commandId, 'commandId'),
-    taskSpaceId: prepared.snapshotReceipt.taskSpaceId,
-    createdAt: input.createdAt,
-    definition: {
-      kind: 'task-space-definition',
-      taskSpaceId: prepared.snapshotReceipt.taskSpaceId,
-      name: input.taskName,
-      schemaVersion: 1,
-      tasks: [{
-        kind: 'task',
-        taskId: exactString(input.taskId, 'taskId'),
-        name: exactString(input.taskName, 'taskName'),
-        order: 0,
-        profile: prepared.profile,
-        inputArtifacts: prepared.artifactRefs,
-      }],
-      relations: [{
-        kind: 'parent-child',
-        relationId: `root:${input.taskId}`,
-        parentTaskId: null,
-        childTaskId: input.taskId,
-        order: 0,
-      }],
-    },
-    artifactBodies: prepared.artifactBodies,
-  }, config);
-  return Object.freeze({ ...result, snapshotReceipt: prepared.snapshotReceipt });
-}
-
-function artifact(bytes: Uint8Array, mediaType: string, name: string): {
-  readonly ref: TaskArtifactRef;
-  readonly body: TaskArtifactBody;
-} {
-  const digest = sha256Digest(bytes);
-  const ref = Object.freeze({
-    kind: 'task-artifact-ref' as const,
-    digest,
-    mediaType,
-    sizeBytes: bytes.byteLength,
-    name,
-  });
-  return Object.freeze({
-    ref,
-    body: Object.freeze({
-      kind: 'task-artifact-body' as const,
-      digest,
-      mediaType,
-      sizeBytes: bytes.byteLength,
-      encoding: 'base64' as const,
-      data: Buffer.from(bytes).toString('base64'),
-    }),
-  });
-}
-
-function exactBytes(value: Uint8Array, name: string): Uint8Array {
-  if (!(value instanceof Uint8Array) || value.byteLength === 0) throw new Error(`HOLON_TASK_${name.toUpperCase()}_INVALID`);
-  return Uint8Array.from(value);
-}
-
-function exactString(value: string, name: string): string {
-  if (typeof value !== 'string' || value.length === 0 || value !== value.trim()) throw new Error(`HOLON_TASK_${name.toUpperCase()}_INVALID`);
-  return value;
-}
-
-function sameBytes(left: Uint8Array, right: Uint8Array): boolean {
-  return left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index]);
-}
-
-function compareUtf16(left: string, right: string): number {
-  return left < right ? -1 : left > right ? 1 : 0;
-}