holarchy-eidolon-adapter 0.2.1 → 0.2.2

package/dist/HolonExecutionBinding.js

@@ -1,3 +1,4 @@
+import { decodeCanonicalBase64 } from './canonicalBase64.js';
 import { digestCanonical, } from "halfcode-compiler.xnl/resource-core";
 import { createKindSpecRevision, createKindSubjectOwner, } from "halfcode-compiler.xnl/kind-definition";
 export const HOLON_EXECUTION_BINDING_KIND = "HolonExecutionBinding";
@@ -343,14 +344,11 @@ function canonicalBase64SpecBytes(spec, property) {
     const value = exactString(properties[property], `$.properties.${property}`);
     let bytes;
     try {
-        bytes = Uint8Array.from(Buffer.from(value, "base64"));
+        bytes = decodeCanonicalBase64(value);
     }
     catch {
         return invalid(`$.properties.${property}`, "Expected canonical base64");
     }
-    if (bytes.byteLength === 0 || Buffer.from(bytes).toString("base64") !== value) {
-        return invalid(`$.properties.${property}`, "Expected canonical non-empty base64");
-    }
     return bytes;
 }
 export const HOLON_EXECUTION_BINDING_KIND_READER_REGISTRATION_V1 = Object.freeze({

package/dist/HolonExecutionBindingProjection.d.ts

@@ -8,6 +8,8 @@ export interface EidolonHolonExecutionBindingProjection {
     readonly binding: HolonExecutionBinding;
     readonly snapshotResource: ResourceRecord;
     readonly snapshot: HolonEffectiveSnapshot;
+    readonly snapshotBytes: Uint8Array;
+    readonly receiptBytes: Uint8Array;
     readonly receipt: HolonEffectiveSnapshotIssuanceReceipt;
     readonly bindingBytesDigest: `sha256:${string}`;
     readonly receiptBytesDigest: `sha256:${string}`;

package/dist/HolonExecutionBindingProjection.js

@@ -1,3 +1,4 @@
+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";
@@ -56,6 +57,8 @@ export async function projectHolonExecutionBindings(input) {
             binding,
             snapshotResource,
             snapshot,
+            snapshotBytes,
+            receiptBytes,
             receipt,
             bindingBytesDigest: sha256Digest(decodedBinding.bindingBytes),
             receiptBytesDigest: sha256Digest(receiptBytes),
@@ -194,14 +197,11 @@ function canonicalBase64Property(resource, property) {
     }
     let bytes;
     try {
-        bytes = Uint8Array.from(Buffer.from(value, "base64"));
+        bytes = decodeCanonicalBase64(value);
     }
     catch {
         throw new EidolonResourceRegistryError("EIDOLON_HOLON_RESOURCE_BYTES_INVALID", `Resource '${resource.resourceId}' '${property}' is not valid base64.`);
     }
-    if (bytes.byteLength === 0 || Buffer.from(bytes).toString("base64") !== value) {
-        throw new EidolonResourceRegistryError("EIDOLON_HOLON_RESOURCE_BYTES_INVALID", `Resource '${resource.resourceId}' '${property}' is not canonical base64.`);
-    }
     return bytes;
 }
 function assertTargetExists(binding, snapshot) {

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 {};

package/dist/WorkflowHolonTaskContract.js

@@ -0,0 +1,211 @@
+import { canonicalOwnDataClone } from 'task-manager-contract';
+export const HOLON_TASK_TARGET_SCHEMA_VERSION = 'ai-workflow.holon-task-target/v1';
+export const HOLON_TASK_SNAPSHOT_RECEIPT_SCHEMA_VERSION = 'eidolon.holon-task-snapshot-receipt/v2';
+export const AI_ORGANIZATION_TASK_PROFILE_KIND = 'depa.ai.organization-task';
+export function holonTaskTargetFromNodeConfig(configInput, expected) {
+    const config = record(canonicalOwnDataClone(configInput), '$config');
+    if (!Object.prototype.hasOwnProperty.call(config, 'holonTaskTarget'))
+        return undefined;
+    const target = normalizeHolonTaskTarget(config.holonTaskTarget);
+    if (target.invocation.workflowKind !== expected.workflowKind
+        || target.invocation.workflowRef !== expected.workflowRef
+        || target.invocation.nodeId !== expected.nodeId) {
+        invalid('$config.holonTaskTarget.invocation', 'Target invocation identity does not match the authored node');
+    }
+    return target;
+}
+export class HolonTaskContractError extends Error {
+    path;
+    constructor(path, message) {
+        super(`${path}: ${message}`);
+        this.path = path;
+        this.name = 'HolonTaskContractError';
+    }
+}
+export function normalizeHolonTaskTarget(value) {
+    const root = record(canonicalOwnDataClone(value), '$target');
+    exactKeys(root, ['kind', 'schemaVersion', 'invocation', 'holon', 'executionBinding', 'taskSpace', 'output'], '$target');
+    exactLiteral(root.kind, 'holon-task-target', '$target.kind');
+    exactLiteral(root.schemaVersion, HOLON_TASK_TARGET_SCHEMA_VERSION, '$target.schemaVersion');
+    const invocation = record(root.invocation, '$target.invocation');
+    exactKeys(invocation, ['workflowKind', 'workflowRef', 'nodeId', 'invocationId'], '$target.invocation');
+    const workflowKind = oneOf(invocation.workflowKind, ['AICtrlWorkflow', 'AIDataWorkflow'], '$target.invocation.workflowKind');
+    const holon = record(root.holon, '$target.holon');
+    exactKeys(holon, ['rootHolonRef', 'effectiveAt'], '$target.holon');
+    const executionBinding = record(root.executionBinding, '$target.executionBinding');
+    exactKeys(executionBinding, ['ref', 'digest'], '$target.executionBinding');
+    const taskSpace = record(root.taskSpace, '$target.taskSpace');
+    exactKeys(taskSpace, ['profileRef', 'policyRef', 'requiredRoleRefs', 'requiredCapabilityRefs'], '$target.taskSpace');
+    const output = record(root.output, '$target.output');
+    exactKeys(output, ['schemaRef', 'materialPortRefs'], '$target.output');
+    return Object.freeze({
+        kind: 'holon-task-target',
+        schemaVersion: HOLON_TASK_TARGET_SCHEMA_VERSION,
+        invocation: Object.freeze({
+            workflowKind,
+            workflowRef: resourceRef(invocation.workflowRef, '$target.invocation.workflowRef'),
+            nodeId: exactString(invocation.nodeId, '$target.invocation.nodeId'),
+            invocationId: exactString(invocation.invocationId, '$target.invocation.invocationId'),
+        }),
+        holon: Object.freeze({
+            rootHolonRef: exactString(holon.rootHolonRef, '$target.holon.rootHolonRef'),
+            effectiveAt: utcInstant(holon.effectiveAt, '$target.holon.effectiveAt'),
+        }),
+        executionBinding: Object.freeze({
+            ref: resourceRef(executionBinding.ref, '$target.executionBinding.ref'),
+            digest: digest(executionBinding.digest, '$target.executionBinding.digest'),
+        }),
+        taskSpace: Object.freeze({
+            profileRef: resourceRef(taskSpace.profileRef, '$target.taskSpace.profileRef'),
+            policyRef: resourceRef(taskSpace.policyRef, '$target.taskSpace.policyRef'),
+            requiredRoleRefs: stringArray(taskSpace.requiredRoleRefs, '$target.taskSpace.requiredRoleRefs'),
+            requiredCapabilityRefs: resourceRefArray(taskSpace.requiredCapabilityRefs, '$target.taskSpace.requiredCapabilityRefs'),
+        }),
+        output: Object.freeze({
+            schemaRef: resourceRef(output.schemaRef, '$target.output.schemaRef'),
+            materialPortRefs: resourceRefArray(output.materialPortRefs, '$target.output.materialPortRefs'),
+        }),
+    });
+}
+export function normalizeHolonTaskSnapshotReceipt(value) {
+    const root = record(canonicalOwnDataClone(value), '$snapshotReceipt');
+    const legacy = root.schemaVersion === 'ai-workflow.holon-task-snapshot-receipt/v1' || root.schemaVersion === 'eidolon.holon-task-snapshot-receipt/v1';
+    exactKeys(root, [
+        'kind', 'schemaVersion', 'taskSpaceId', 'holonRef', 'effectiveAt', 'holonSnapshotRef',
+        'holonSnapshotDigest', 'snapshotArtifactDigest', 'issuerReceiptId',
+        ...(legacy ? ['issuerReceiptArtifactDigest'] : []), 'executionBindingRef', 'executionBindingDigest',
+        'eligibleMemberRefs', 'eligibleRoleRefs',
+    ], '$snapshotReceipt');
+    exactLiteral(root.kind, 'holon-task-snapshot-receipt', '$snapshotReceipt.kind');
+    if (!legacy)
+        exactLiteral(root.schemaVersion, HOLON_TASK_SNAPSHOT_RECEIPT_SCHEMA_VERSION, '$snapshotReceipt.schemaVersion');
+    if (legacy && root.issuerReceiptArtifactDigest !== root.issuerReceiptId)
+        invalid('$snapshotReceipt', 'Conflicting legacy receipt digests');
+    return Object.freeze({
+        kind: 'holon-task-snapshot-receipt',
+        schemaVersion: HOLON_TASK_SNAPSHOT_RECEIPT_SCHEMA_VERSION,
+        taskSpaceId: exactString(root.taskSpaceId, '$snapshotReceipt.taskSpaceId'),
+        holonRef: exactString(root.holonRef, '$snapshotReceipt.holonRef'),
+        effectiveAt: utcInstant(root.effectiveAt, '$snapshotReceipt.effectiveAt'),
+        holonSnapshotRef: exactString(root.holonSnapshotRef, '$snapshotReceipt.holonSnapshotRef'),
+        holonSnapshotDigest: digest(root.holonSnapshotDigest, '$snapshotReceipt.holonSnapshotDigest'),
+        snapshotArtifactDigest: digest(root.snapshotArtifactDigest, '$snapshotReceipt.snapshotArtifactDigest'),
+        issuerReceiptId: digest(root.issuerReceiptId, '$snapshotReceipt.issuerReceiptId'),
+        executionBindingRef: resourceRef(root.executionBindingRef, '$snapshotReceipt.executionBindingRef'),
+        executionBindingDigest: digest(root.executionBindingDigest, '$snapshotReceipt.executionBindingDigest'),
+        eligibleMemberRefs: stringArray(root.eligibleMemberRefs, '$snapshotReceipt.eligibleMemberRefs'),
+        eligibleRoleRefs: stringArray(root.eligibleRoleRefs, '$snapshotReceipt.eligibleRoleRefs'),
+    });
+}
+export function createAIOrganizationTaskProfile(targetInput, receiptInput, adoptionInputs = []) {
+    const target = normalizeHolonTaskTarget(targetInput);
+    const snapshotReceipt = normalizeHolonTaskSnapshotReceipt(receiptInput);
+    if (snapshotReceipt.taskSpaceId.length === 0
+        || snapshotReceipt.holonRef !== target.holon.rootHolonRef
+        || snapshotReceipt.effectiveAt !== target.holon.effectiveAt
+        || snapshotReceipt.executionBindingRef !== target.executionBinding.ref
+        || snapshotReceipt.executionBindingDigest !== target.executionBinding.digest) {
+        invalid('$profile', 'Snapshot receipt does not bind the exact target facts');
+    }
+    return Object.freeze({
+        kind: 'task-profile',
+        profileKind: AI_ORGANIZATION_TASK_PROFILE_KIND,
+        schemaVersion: 1,
+        facts: Object.freeze({
+            target,
+            snapshotReceipt,
+            assignmentReceipt: null,
+            memberRuntimeRef: null,
+            settlementReceipt: null,
+            snapshotAdoptions: Object.freeze(adoptionInputs.map(normalizeHolonTaskSnapshotAdoptionReceipt)),
+        }),
+    });
+}
+export function normalizeHolonTaskSnapshotAdoptionReceipt(value) {
+    const root = record(canonicalOwnDataClone(value), '$snapshotAdoptionReceipt');
+    exactKeys(root, [
+        'kind', 'schemaVersion', 'taskSpaceId', 'previousTaskId', 'successorTaskId',
+        'previousIssuerReceiptId', 'successorIssuerReceiptId', 'executionBindingDigest', 'adoptedAt',
+    ], '$snapshotAdoptionReceipt');
+    exactLiteral(root.kind, 'holon-task-snapshot-adoption-receipt', '$snapshotAdoptionReceipt.kind');
+    exactLiteral(root.schemaVersion, 'ai-workflow.holon-task-snapshot-adoption-receipt/v1', '$snapshotAdoptionReceipt.schemaVersion');
+    return Object.freeze({
+        kind: 'holon-task-snapshot-adoption-receipt',
+        schemaVersion: 'ai-workflow.holon-task-snapshot-adoption-receipt/v1',
+        taskSpaceId: exactString(root.taskSpaceId, '$snapshotAdoptionReceipt.taskSpaceId'),
+        previousTaskId: exactString(root.previousTaskId, '$snapshotAdoptionReceipt.previousTaskId'),
+        successorTaskId: exactString(root.successorTaskId, '$snapshotAdoptionReceipt.successorTaskId'),
+        previousIssuerReceiptId: digest(root.previousIssuerReceiptId, '$snapshotAdoptionReceipt.previousIssuerReceiptId'),
+        successorIssuerReceiptId: digest(root.successorIssuerReceiptId, '$snapshotAdoptionReceipt.successorIssuerReceiptId'),
+        executionBindingDigest: digest(root.executionBindingDigest, '$snapshotAdoptionReceipt.executionBindingDigest'),
+        adoptedAt: utcInstant(root.adoptedAt, '$snapshotAdoptionReceipt.adoptedAt'),
+    });
+}
+function record(value, path) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        invalid(path, 'Expected an object');
+    return value;
+}
+function exactKeys(value, expected, path) {
+    const actual = Object.keys(value);
+    const expectedSet = new Set(expected);
+    const extra = actual.find((key) => !expectedSet.has(key));
+    if (extra !== undefined)
+        invalid(`${path}.${extra}`, 'Unsupported field');
+    const missing = expected.find((key) => !Object.prototype.hasOwnProperty.call(value, key));
+    if (missing !== undefined)
+        invalid(`${path}.${missing}`, 'Required field is missing');
+}
+function exactString(value, path) {
+    if (typeof value !== 'string' || value.length === 0 || value !== value.trim())
+        invalid(path, 'Expected an exact non-empty string');
+    return value;
+}
+function exactLiteral(value, expected, path) {
+    if (value !== expected)
+        invalid(path, `Expected '${expected}'`);
+    return expected;
+}
+function oneOf(value, expected, path) {
+    if (typeof value !== 'string' || !expected.includes(value))
+        invalid(path, `Expected one of ${expected.join('|')}`);
+    return value;
+}
+function resourceRef(value, path) {
+    const ref = exactString(value, path);
+    if (!/^resource:\/\/[^/\s][^\s]*$/.test(ref))
+        invalid(path, 'Expected a canonical resource:// reference');
+    return ref;
+}
+function digest(value, path) {
+    if (typeof value !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(value))
+        invalid(path, 'Expected a canonical SHA-256 digest');
+    return value;
+}
+function utcInstant(value, path) {
+    const instant = exactString(value, path);
+    const parsed = Date.parse(instant);
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(instant)
+        || Number.isNaN(parsed) || new Date(parsed).toISOString() !== instant)
+        invalid(path, 'Expected a canonical UTC instant');
+    return instant;
+}
+function stringArray(value, path) {
+    if (!Array.isArray(value))
+        invalid(path, 'Expected an array');
+    const result = Object.freeze(value.map((item, index) => exactString(item, `${path}[${index}]`)));
+    if (new Set(result).size !== result.length)
+        invalid(path, 'Duplicate values are not allowed');
+    return result;
+}
+function resourceRefArray(value, path) {
+    if (!Array.isArray(value))
+        invalid(path, 'Expected an array');
+    const result = Object.freeze(value.map((item, index) => resourceRef(item, `${path}[${index}]`)));
+    if (new Set(result).size !== result.length)
+        invalid(path, 'Duplicate values are not allowed');
+    return result;
+}
+function invalid(path, message) {
+    throw new HolonTaskContractError(path, message);
+}

package/dist/canonicalBase64.d.ts

@@ -0,0 +1,2 @@
+/** 纯平台标准转换；公开适配包不依赖主机Buffer或Node类型。 */
+export declare function decodeCanonicalBase64(value: string): Uint8Array;

package/dist/canonicalBase64.js

@@ -0,0 +1,7 @@
+/** 纯平台标准转换；公开适配包不依赖主机Buffer或Node类型。 */
+export function decodeCanonicalBase64(value) {
+    const binary = atob(value);
+    if (!binary.length || btoa(binary) !== value)
+        throw new TypeError('Expected canonical non-empty base64');
+    return Uint8Array.from(binary, character => character.charCodeAt(0));
+}

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export * from "./HolonExecutionBinding.js";
 export * from "./HolonExecutionBindingProjection.js";
 export { parseOrganizationWorkbenchRequest, parseOrganizationWorkbenchReply } from './WorkbenchProtocol.js';
 export type { OrganizationWorkbenchRequest, OrganizationWorkbenchReply } from './WorkbenchProtocol.js';
+export * from "./WorkflowHolonTaskContract.js";

package/dist/index.js

@@ -4,3 +4,4 @@ export * from "./HolonDeploymentRuntime.js";
 export * from "./HolonExecutionBinding.js";
 export * from "./HolonExecutionBindingProjection.js";
 export { parseOrganizationWorkbenchRequest, parseOrganizationWorkbenchReply } from './WorkbenchProtocol.js';
+export * from "./WorkflowHolonTaskContract.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holarchy-eidolon-adapter",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "private": false,
   "description": "Eidolon ResourcePackage adapter for frozen Holarchy organization snapshots and execution bindings.",
   "type": "module",
@@ -35,23 +35,16 @@
     "dist",
     "README.md"
   ],
-  "scripts": {
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "bun test",
-    "build": "tsc -p tsconfig.build.json"
-  },
   "dependencies": {
-    "ai-workflow-contract": "0.2.1",
+    "ai-workflow-contract": "0.2.3",
     "depa-actor": "0.2.2",
     "halfcode-compiler.xnl": "0.3.2",
-    "holarchy-core-contract": "0.3.0"
-  },
-  "devDependencies": {
-    "typescript": "^5.4.0",
-    "@types/node": "^22.0.0"
+    "holarchy-core-contract": "0.3.1",
+    "task-manager-contract": "0.1.4"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.com/"
   },
   "types": "./dist/index.d.ts"
 }