holarchy-eidolon-adapter 0.2.0 → 0.2.2

package/dist/HolonExecutionBindingProjection.js

@@ -0,0 +1,289 @@
+import { decodeCanonicalBase64 } from './canonicalBase64.js';
+import { HOLON_EXECUTION_BINDING_KIND, HOLON_EXECUTION_BINDING_KIND_DEFINITION_BYTES, HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN, parseHolonExecutionBindingBytes, validateHolonExecutionBindingGraph, } from "./HolonExecutionBinding.js";
+import { HOLON_EFFECTIVE_SNAPSHOT_KIND, HOLON_EFFECTIVE_SNAPSHOT_KIND_DEFINITION_BYTES, HOLON_EFFECTIVE_SNAPSHOT_KIND_DEFINITION_FQN, parseHolonEffectiveSnapshotBytes, parseHolonEffectiveSnapshotIssuanceReceiptBytes, } from "holarchy-core-contract";
+import { buildResourceDependencySnapshot, sha256Digest, } from "halfcode-compiler.xnl/resource-core";
+import { HolarchyEidolonAdapterError as EidolonResourceRegistryError } from "./HolarchyEidolonAdapterError.js";
+const authenticProjections = new WeakSet();
+const authenticFreezeReceipts = new WeakSet();
+export async function projectHolonExecutionBindings(input) {
+    const resources = [...(input.registry.byKind.get(HOLON_EXECUTION_BINDING_KIND) ?? [])]
+        .sort((left, right) => compareUtf16(left.resourceId, right.resourceId));
+    if (resources.length === 0)
+        return Object.freeze([]);
+    assertCanonicalKindDefinition(input, {
+        resourceKind: HOLON_EXECUTION_BINDING_KIND,
+        fqn: HOLON_EXECUTION_BINDING_KIND_DEFINITION_FQN,
+        bytes: HOLON_EXECUTION_BINDING_KIND_DEFINITION_BYTES,
+        code: "EIDOLON_HOLON_BINDING_KIND_DEFINITION_MISMATCH",
+    });
+    assertCanonicalKindDefinition(input, {
+        resourceKind: HOLON_EFFECTIVE_SNAPSHOT_KIND,
+        fqn: HOLON_EFFECTIVE_SNAPSHOT_KIND_DEFINITION_FQN,
+        bytes: HOLON_EFFECTIVE_SNAPSHOT_KIND_DEFINITION_BYTES,
+        code: "EIDOLON_HOLON_SNAPSHOT_KIND_DEFINITION_MISMATCH",
+    });
+    const decoded = resources.map((resource) => {
+        const bindingBytes = canonicalBase64Property(resource, "bindingBytesBase64");
+        const binding = parseHolonExecutionBindingBytes(bindingBytes);
+        if (binding.bindingRef !== resourceRef(resource.resourceId)) {
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_IDENTITY_MISMATCH", `HolonExecutionBinding '${resource.resourceId}' bytes select '${binding.bindingRef}'.`);
+        }
+        return Object.freeze({ resource, binding, bindingBytes });
+    });
+    const bindingGraph = validateHolonExecutionBindingGraph(decoded.map(({ binding }) => binding));
+    const decodedByRef = new Map(decoded.map((entry) => [entry.binding.bindingRef, entry]));
+    const projections = [];
+    for (const binding of bindingGraph) {
+        const decodedBinding = decodedByRef.get(binding.bindingRef);
+        if (!decodedBinding)
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_GRAPH_INTERNAL", `HolonExecutionBinding '${binding.bindingRef}' disappeared during projection.`);
+        const snapshotId = resourceId(binding.snapshotRef);
+        const snapshotResource = exactResource(input.registry, snapshotId);
+        if (snapshotResource.kind !== HOLON_EFFECTIVE_SNAPSHOT_KIND) {
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_SNAPSHOT_KIND_MISMATCH", `Resource '${snapshotId}' must be a canonical ${HOLON_EFFECTIVE_SNAPSHOT_KIND} Resource.`);
+        }
+        const snapshotBytes = canonicalBase64Property(snapshotResource, "snapshotBytesBase64");
+        const snapshot = await parseHolonEffectiveSnapshotBytes(snapshotBytes);
+        const receiptBytes = canonicalBase64Property(snapshotResource, "issuanceReceiptBytesBase64");
+        const receipt = parseHolonEffectiveSnapshotIssuanceReceiptBytes(receiptBytes, snapshot);
+        assertTargetExists(binding, snapshot);
+        const closureResourceIds = resolveBindingClosureResourceIds(binding, decodedByRef, input.registry);
+        for (const resourceId of closureResourceIds)
+            requiredIdentity(input.contentIdentities, resourceId);
+        requiredIdentity(input.contentIdentities, snapshotResource.resourceId);
+        const projection = Object.freeze({
+            schemaVersion: "eidolon.holon-execution-binding-projection/v1",
+            resource: decodedBinding.resource,
+            binding,
+            snapshotResource,
+            snapshot,
+            snapshotBytes,
+            receiptBytes,
+            receipt,
+            bindingBytesDigest: sha256Digest(decodedBinding.bindingBytes),
+            receiptBytesDigest: sha256Digest(receiptBytes),
+            closureResourceIds,
+            registryRevision: input.registryRevision,
+        });
+        authenticProjections.add(projection);
+        projections.push(projection);
+    }
+    return Object.freeze(projections);
+}
+export function freezeHolonExecutionBinding(input) {
+    if (!authenticProjections.has(input.projection)) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_PROJECTION_UNTRUSTED", "Binding freeze requires the exact projection produced by the shared registry.");
+    }
+    const closure = Object.freeze(input.projection.closureResourceIds.map((resourceId) => {
+        const resource = exactResource(input.registry, resourceId);
+        const identity = requiredIdentity(input.contentIdentities, resourceId);
+        return Object.freeze({
+            resourceId,
+            kind: resource.kind,
+            authorityDigest: exactSha256(identity.authorityDigest, `${resourceId}.authorityDigest`),
+            contentDigest: exactSha256(identity.contentDigest, `${resourceId}.contentDigest`),
+        });
+    }));
+    const agentProofs = Object.freeze(agentRefs(input.projection.binding, new Map((input.registry.byKind.get(HOLON_EXECUTION_BINDING_KIND) ?? []).map((resource) => {
+        const projected = resourceRef(resource.resourceId);
+        return [projected, projected === input.projection.binding.bindingRef
+                ? input.projection.binding
+                : parseHolonExecutionBindingBytes(canonicalBase64Property(resource, "bindingBytesBase64"))];
+    }))).map((agentDefinitionRef) => {
+        const agentId = resourceId(agentDefinitionRef);
+        const agent = input.agentResources.agentDefinitions.find((candidate) => candidate.resource.resourceId === agentId);
+        if (!agent)
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_AGENT_PROJECTION_MISSING", `AIAgentDefinition '${agentDefinitionRef}' has no authentic shared-registry projection.`);
+        const roots = agentClosureResourceIds(agent);
+        const dependencySnapshot = buildResourceDependencySnapshot({
+            registry: input.registry,
+            roots,
+            edges: input.agentResources.dependencyEdges,
+            contentIdentities: input.contentIdentities,
+        });
+        return Object.freeze({
+            agentDefinitionRef,
+            agentContentDigest: requiredIdentity(input.contentIdentities, agentId).contentDigest,
+            closureResourceIds: Object.freeze(dependencySnapshot.closure.map(({ resourceId }) => resourceId)),
+            snapshotRevision: dependencySnapshot.snapshotRevision,
+        });
+    }));
+    const semanticFingerprint = sha256Digest(JSON.stringify({
+        schemaVersion: "eidolon.holon-execution-binding-freeze-semantic/v1",
+        bindingRef: input.projection.binding.bindingRef,
+        snapshotRef: input.projection.binding.snapshotRef,
+        snapshotTreeDigest: input.projection.snapshot.treeDigest,
+        snapshotReceiptDigest: input.projection.receiptBytesDigest,
+        bindingBytesDigest: input.projection.bindingBytesDigest,
+        registryRevision: input.registryRevision,
+        closure,
+        agentProofs,
+    }));
+    const receipt = Object.freeze({
+        schemaVersion: "eidolon.holon-execution-binding-freeze/v1",
+        bindingRef: input.projection.binding.bindingRef,
+        snapshotRef: input.projection.binding.snapshotRef,
+        snapshotTreeDigest: input.projection.snapshot.treeDigest,
+        snapshotReceiptDigest: input.projection.receiptBytesDigest,
+        bindingBytesDigest: input.projection.bindingBytesDigest,
+        registryRevision: input.registryRevision,
+        closure,
+        agentProofs,
+        semanticFingerprint,
+    });
+    authenticFreezeReceipts.add(receipt);
+    return receipt;
+}
+export function assertHolonExecutionBindingFreezeReceipt(value) {
+    if (!authenticFreezeReceipts.has(value)) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_FREEZE_RECEIPT_UNTRUSTED", "Holon binding dispatch requires the authentic receipt produced by the shared registry freeze boundary.");
+    }
+    return value;
+}
+function agentRefs(root, byRef) {
+    const refs = new Set();
+    const visited = new Set();
+    const visit = (binding) => {
+        if (visited.has(binding.bindingRef))
+            return;
+        visited.add(binding.bindingRef);
+        if (binding.adapter.kind === "ai-agent")
+            refs.add(binding.adapter.agentDefinitionRef);
+        if (binding.adapter.kind === "hybrid") {
+            for (const candidateRef of binding.adapter.candidateBindingRefs) {
+                const candidate = byRef.get(candidateRef);
+                if (!candidate)
+                    throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_CANDIDATE_MISSING", `Hybrid candidate '${candidateRef}' disappeared before freeze.`);
+                visit(candidate);
+            }
+        }
+    };
+    visit(root);
+    return Object.freeze([...refs].sort(compareUtf16));
+}
+function agentClosureResourceIds(agent) {
+    const ids = new Set([agent.resource.resourceId]);
+    for (const message of agent.messages) {
+        ids.add(message.prompt.resource.resourceId);
+        if (message.schema)
+            ids.add(message.schema.resource.resourceId);
+    }
+    if (agent.inputSchema)
+        ids.add(agent.inputSchema.resource.resourceId);
+    if (agent.outputSchema)
+        ids.add(agent.outputSchema.resource.resourceId);
+    if (agent.effectPolicy)
+        ids.add(agent.effectPolicy.resource.resourceId);
+    for (const tool of agent.tools)
+        ids.add(tool.resource.resourceId);
+    for (const port of agent.materialPorts)
+        ids.add(port.resource.resourceId);
+    return Object.freeze([...ids].sort(compareUtf16));
+}
+function assertCanonicalKindDefinition(input, expected) {
+    const kindDefinition = input.registry.kindDefinitions.get(expected.resourceKind)?.definition;
+    if (!kindDefinition || kindDefinition.resourceId !== expected.fqn) {
+        throw new EidolonResourceRegistryError(expected.code, `Kind '${expected.resourceKind}' must be registered by canonical KindDefinition '${expected.fqn}'.`);
+    }
+    const expectedDigest = sha256Digest(Uint8Array.from(expected.bytes));
+    if (input.kindDefinitionAuthorityDigests.get(expected.resourceKind) !== expectedDigest) {
+        throw new EidolonResourceRegistryError(expected.code, `KindDefinition '${expected.fqn}' bytes do not match the canonical owner bytes.`);
+    }
+}
+function canonicalBase64Property(resource, property) {
+    const value = resource.node.properties[property];
+    if (typeof value !== "string" || value.length === 0 || value !== value.trim()) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_RESOURCE_BYTES_MISSING", `Resource '${resource.resourceId}' requires exact '${property}' base64 bytes.`);
+    }
+    let bytes;
+    try {
+        bytes = decodeCanonicalBase64(value);
+    }
+    catch {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_RESOURCE_BYTES_INVALID", `Resource '${resource.resourceId}' '${property}' is not valid base64.`);
+    }
+    return bytes;
+}
+function assertTargetExists(binding, snapshot) {
+    const expectedKind = binding.target.kind === "member" ? "Member" : "Role";
+    const targetRef = binding.target.kind === "member" ? binding.target.memberRef : binding.target.roleRef;
+    if (!snapshot.records.some((record) => record.kind === expectedKind && record.id === targetRef)) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_TARGET_MISSING", `${expectedKind} '${targetRef}' is not present in frozen snapshot '${snapshot.snapshotId}'.`);
+    }
+}
+function resolveBindingClosureResourceIds(root, bindings, registry) {
+    const selected = new Set();
+    const visited = new Set();
+    const add = (ref, expectedKind) => {
+        const id = resourceId(ref);
+        const resource = exactResource(registry, id);
+        if (expectedKind && resource.kind !== expectedKind) {
+            throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_RESOURCE_KIND_MISMATCH", `Resource '${id}' must have kind '${expectedKind}', got '${resource.kind}'.`);
+        }
+        selected.add(id);
+    };
+    const visit = (binding) => {
+        if (visited.has(binding.bindingRef))
+            return;
+        visited.add(binding.bindingRef);
+        add(binding.bindingRef, HOLON_EXECUTION_BINDING_KIND);
+        add(binding.snapshotRef, HOLON_EFFECTIVE_SNAPSHOT_KIND);
+        add(binding.policy.taskProfileRef);
+        for (const ref of binding.policy.capabilityRefs)
+            add(ref);
+        for (const ref of binding.policy.toolRefs)
+            add(ref);
+        for (const ref of binding.policy.materialRefs)
+            add(ref);
+        if (binding.adapter.kind === "ai-agent") {
+            add(binding.adapter.agentDefinitionRef, "AIAgentDefinition");
+            add(binding.adapter.runtimeProfileRef);
+        }
+        else if (binding.adapter.kind === "human-endpoint") {
+            add(binding.adapter.humanEndpointRef);
+            add(binding.adapter.inboxProfileRef);
+        }
+        else if (binding.adapter.kind === "service") {
+            add(binding.adapter.serviceAdapterRef);
+            add(binding.adapter.runtimeProfileRef);
+        }
+        else {
+            add(binding.adapter.policyRef);
+            for (const candidateRef of binding.adapter.candidateBindingRefs) {
+                const candidate = bindings.get(candidateRef);
+                if (!candidate)
+                    throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_CANDIDATE_MISSING", `Hybrid candidate '${candidateRef}' is not present in the admitted registry.`);
+                visit(candidate.binding);
+            }
+        }
+    };
+    visit(root);
+    return Object.freeze([...selected].sort(compareUtf16));
+}
+function exactResource(registry, resourceId) {
+    const resource = registry.byId.get(resourceId)?.resource;
+    if (!resource) {
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_RESOURCE_MISSING", `Resource '${resourceId}' is not present in the admitted registry.`);
+    }
+    return resource;
+}
+function requiredIdentity(identities, resourceId) {
+    const identity = identities.get(resourceId);
+    if (!identity)
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_CONTENT_IDENTITY_MISSING", `Resource '${resourceId}' has no exact content identity.`);
+    return identity;
+}
+function resourceId(ref) {
+    return ref.slice("resource://".length);
+}
+function resourceRef(resourceId) {
+    return `resource://${resourceId}`;
+}
+function compareUtf16(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function exactSha256(value, path) {
+    if (!/^sha256:[0-9a-f]{64}$/.test(value))
+        throw new EidolonResourceRegistryError("EIDOLON_HOLON_BINDING_DIGEST_INVALID", `Expected one canonical SHA-256 digest at '${path}'.`);
+    return value;
+}

package/dist/WorkbenchProtocol.d.ts

@@ -0,0 +1,12 @@
+/** A path selects a local owner operation, never a network destination. */
+export type OrganizationWorkbenchRequest = {
+    method: "GET" | "POST";
+    path: string;
+    body?: Record<string, unknown>;
+};
+export type OrganizationWorkbenchReply = {
+    status: number;
+    body: unknown;
+};
+export declare function parseOrganizationWorkbenchRequest(value: unknown): OrganizationWorkbenchRequest;
+export declare function parseOrganizationWorkbenchReply(value: unknown): OrganizationWorkbenchReply;

package/dist/WorkbenchProtocol.js

@@ -0,0 +1,102 @@
+function invalid() {
+    throw Object.assign(new Error("Invalid organization workbench request"), {
+        code: "invalid_schema",
+    });
+}
+function jsonValue(value, depth = 0) {
+    if (depth > 64)
+        invalid();
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return;
+    if (typeof value === "number" && Number.isFinite(value))
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            jsonValue(item, depth + 1);
+        return;
+    }
+    if (value &&
+        typeof value === "object" &&
+        Object.getPrototypeOf(value) === Object.prototype) {
+        for (const [key, item] of Object.entries(value)) {
+            if (["__proto__", "constructor", "prototype"].includes(key))
+                invalid();
+            jsonValue(item, depth + 1);
+        }
+        return;
+    }
+    invalid();
+}
+export function parseOrganizationWorkbenchRequest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        invalid();
+    const row = value;
+    if (Object.keys(row).some((key) => !["method", "path", "body"].includes(key)) ||
+        !["GET", "POST"].includes(String(row.method)) ||
+        typeof row.path !== "string" ||
+        row.path.length > 4096 ||
+        !row.path.startsWith("/api/") ||
+        /[\\\u0000-\u001f]/.test(row.path))
+        invalid();
+    const url = new URL(row.path, "http://workbench.local");
+    if (url.origin !== "http://workbench.local" ||
+        url.hash ||
+        url.pathname !== row.path.split("?")[0])
+        invalid();
+    const parts = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
+    if (parts.some((part) => !part || part === "." || part === ".." || part.includes("/")))
+        invalid();
+    if (row.method === "POST") {
+        if (parts.length !== 4 ||
+            parts[0] !== "api" ||
+            parts[1] !== "connections" ||
+            parts[3] !== "invoke" ||
+            [...url.searchParams].length ||
+            !row.body ||
+            typeof row.body !== "object" ||
+            Array.isArray(row.body))
+            invalid();
+    }
+    else {
+        if (row.body !== undefined)
+            invalid();
+        const top = parts.length === 2 && ["health", "connections"].includes(parts[1]);
+        const leaf = parts[1] === "connections" &&
+            parts.length >= 4 &&
+            parts.length <= 6 &&
+            [
+                "state",
+                "history",
+                "xnl",
+                "operations",
+                "issuances",
+                "projection",
+                "objects",
+                "result",
+            ].includes(parts[3]);
+        if (!top && !leaf)
+            invalid();
+        for (const [key] of url.searchParams)
+            if (!["effectiveDate", "observation"].includes(key))
+                invalid();
+    }
+    jsonValue(value);
+    if (new TextEncoder().encode(JSON.stringify(value)).length > 2 * 1024 * 1024)
+        invalid();
+    return value;
+}
+export function parseOrganizationWorkbenchReply(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        invalid();
+    const row = value;
+    if (Object.keys(row).some((key) => !["status", "body"].includes(key)) ||
+        !Number.isInteger(row.status) ||
+        Number(row.status) < 200 ||
+        Number(row.status) > 599 ||
+        !Object.hasOwn(row, "body"))
+        invalid();
+    jsonValue(row.body);
+    if (new TextEncoder().encode(JSON.stringify(value)).length > 16 * 1024 * 1024)
+        invalid();
+    return value;
+}

package/dist/WorkflowHolonTaskContract.d.ts

@@ -0,0 +1,90 @@
+import type { ImmutableJsonValue, TaskProfileEnvelope } from 'task-manager-contract';
+export declare const HOLON_TASK_TARGET_SCHEMA_VERSION: "ai-workflow.holon-task-target/v1";
+export declare const HOLON_TASK_SNAPSHOT_RECEIPT_SCHEMA_VERSION: "eidolon.holon-task-snapshot-receipt/v2";
+export declare const AI_ORGANIZATION_TASK_PROFILE_KIND: "depa.ai.organization-task";
+export type HolonTaskResourceRef = `resource://${string}`;
+export type HolonTaskDigest = `sha256:${string}`;
+type ClosedRecord<Shape> = Readonly<Record<string, ImmutableJsonValue>> & Readonly<Shape>;
+export type HolonTaskTarget = ClosedRecord<{
+    readonly kind: 'holon-task-target';
+    readonly schemaVersion: typeof HOLON_TASK_TARGET_SCHEMA_VERSION;
+    readonly invocation: ClosedRecord<{
+        readonly workflowKind: 'AICtrlWorkflow' | 'AIDataWorkflow';
+        readonly workflowRef: HolonTaskResourceRef;
+        readonly nodeId: string;
+        readonly invocationId: string;
+    }>;
+    readonly holon: ClosedRecord<{
+        readonly rootHolonRef: string;
+        readonly effectiveAt: string;
+    }>;
+    readonly executionBinding: ClosedRecord<{
+        readonly ref: HolonTaskResourceRef;
+        readonly digest: HolonTaskDigest;
+    }>;
+    readonly taskSpace: ClosedRecord<{
+        readonly profileRef: HolonTaskResourceRef;
+        readonly policyRef: HolonTaskResourceRef;
+        readonly requiredRoleRefs: readonly string[];
+        readonly requiredCapabilityRefs: readonly HolonTaskResourceRef[];
+    }>;
+    readonly output: ClosedRecord<{
+        readonly schemaRef: HolonTaskResourceRef;
+        readonly materialPortRefs: readonly HolonTaskResourceRef[];
+    }>;
+}>;
+export type HolonTaskSnapshotReceipt = ClosedRecord<{
+    readonly kind: 'holon-task-snapshot-receipt';
+    readonly schemaVersion: typeof HOLON_TASK_SNAPSHOT_RECEIPT_SCHEMA_VERSION;
+    readonly taskSpaceId: string;
+    readonly holonRef: string;
+    readonly effectiveAt: string;
+    readonly holonSnapshotRef: string;
+    readonly holonSnapshotDigest: HolonTaskDigest;
+    readonly snapshotArtifactDigest: HolonTaskDigest;
+    readonly issuerReceiptId: HolonTaskDigest;
+    readonly executionBindingRef: HolonTaskResourceRef;
+    readonly executionBindingDigest: HolonTaskDigest;
+    readonly eligibleMemberRefs: readonly string[];
+    readonly eligibleRoleRefs: readonly string[];
+}>;
+export type HolonTaskSnapshotAdoptionReceipt = ClosedRecord<{
+    readonly kind: 'holon-task-snapshot-adoption-receipt';
+    readonly schemaVersion: 'ai-workflow.holon-task-snapshot-adoption-receipt/v1';
+    readonly taskSpaceId: string;
+    readonly previousTaskId: string;
+    readonly successorTaskId: string;
+    readonly previousIssuerReceiptId: HolonTaskDigest;
+    readonly successorIssuerReceiptId: HolonTaskDigest;
+    readonly executionBindingDigest: HolonTaskDigest;
+    readonly adoptedAt: string;
+}>;
+export type AIOrganizationTaskProfileFacts = ClosedRecord<{
+    target: HolonTaskTarget;
+    snapshotReceipt: HolonTaskSnapshotReceipt;
+    assignmentReceipt: null;
+    memberRuntimeRef: null;
+    settlementReceipt: null;
+    snapshotAdoptions: readonly HolonTaskSnapshotAdoptionReceipt[];
+}>;
+export type AIOrganizationTaskProfile = TaskProfileEnvelope<typeof AI_ORGANIZATION_TASK_PROFILE_KIND, AIOrganizationTaskProfileFacts>;
+export interface WorkflowHolonTaskContext {
+    readonly target: HolonTaskTarget;
+    readonly semanticFingerprint: HolonTaskDigest;
+    readonly snapshotRevision: HolonTaskDigest;
+    readonly closureResourceIds: readonly string[];
+}
+export declare function holonTaskTargetFromNodeConfig(configInput: unknown, expected: Readonly<{
+    readonly workflowKind: 'AICtrlWorkflow' | 'AIDataWorkflow';
+    readonly workflowRef: HolonTaskResourceRef;
+    readonly nodeId: string;
+}>): HolonTaskTarget | undefined;
+export declare class HolonTaskContractError extends Error {
+    readonly path: string;
+    constructor(path: string, message: string);
+}
+export declare function normalizeHolonTaskTarget(value: unknown): HolonTaskTarget;
+export declare function normalizeHolonTaskSnapshotReceipt(value: unknown): HolonTaskSnapshotReceipt;
+export declare function createAIOrganizationTaskProfile(targetInput: unknown, receiptInput: unknown, adoptionInputs?: readonly unknown[]): AIOrganizationTaskProfile;
+export declare function normalizeHolonTaskSnapshotAdoptionReceipt(value: unknown): HolonTaskSnapshotAdoptionReceipt;
+export {};