@tomflow/proflow-task-orchestration 0.1.13 → 0.1.15

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @tomflow/proflow-task-orchestration
 
+## 0.1.15
+
+### Patch Changes
+
+- fix(product): bind phase1 materialization to current authorization
+
+## 0.1.14
+
+### Patch Changes
+
+- fix(task): bind terminal evidence to current document revision
+
 ## 0.1.13
 
 ### Patch Changes

package/dist/deployment/adapter.d.ts

@@ -4,7 +4,7 @@ declare const success: () => {
         readonly ok: true;
         readonly status: "SUCCEEDED";
         readonly moduleRef: "task-orchestration";
-        readonly moduleVersion: "0.1.13";
+        readonly moduleVersion: "0.1.15";
     };
     observedEffects: string[];
 };
@@ -17,7 +17,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "task-orchestration";
-            moduleVersion: "0.1.13";
+            moduleVersion: "0.1.15";
             data: {
                 setupStatus: "READY";
                 runtimeStatus: "NOT_APPLICABLE";
@@ -32,7 +32,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "task-orchestration";
-            moduleVersion: "0.1.13";
+            moduleVersion: "0.1.15";
             data: {
                 docs: string;
             };

package/dist/deployment/descriptor.d.ts

@@ -3,7 +3,7 @@ export declare const descriptor: {
     readonly contractVersion: "1.0.0";
     readonly moduleRef: "task-orchestration";
     readonly packageName: "@tomflow/proflow-task-orchestration";
-    readonly moduleVersion: "0.1.13";
+    readonly moduleVersion: "0.1.15";
     readonly kind: "library";
     readonly templateVersion: "1.0.0";
     readonly platformCompatibility: ">=1.0.0 <2.0.0";

package/dist/deployment/descriptor.js

@@ -3,7 +3,7 @@ export const descriptor = {
     contractVersion: "1.0.0",
     moduleRef: "task-orchestration",
     packageName: "@tomflow/proflow-task-orchestration",
-    moduleVersion: "0.1.13",
+    moduleVersion: "0.1.15",
     kind: "library",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",

package/dist/src/model.d.ts

@@ -78,10 +78,16 @@ export interface NodeExecutionHistory {
     startedAt: string | null;
     endedAt: string;
 }
+export declare const taskDocumentRef: (taskId: string, documentType: string) => string;
 export interface TaskDocument {
+    documentRef: string;
     taskId: string;
     documentType: string;
     sourceNodeId: string | null;
+    sourceNodeRunNo: number | null;
+    revision: number;
+    sourceDocumentRef: string | null;
+    sourceDocumentRevision: number | null;
     filePath: string;
     contentHash: string;
     updatedByRef: string;

package/dist/src/model.js

@@ -8,3 +8,4 @@ export const taskWaitTypes = [
     "REQUIREMENT_BLOCKED",
     "EXTERNAL_BUSINESS_DEPENDENCY",
 ];
+export const taskDocumentRef = (taskId, documentType) => "taskdoc:" + encodeURIComponent(taskId) + ":" + encodeURIComponent(documentType);

package/dist/src/phase4-continuation-services.d.ts

@@ -106,10 +106,18 @@ export declare function createTaskServices(options: ServiceOptions): {
             task: Pick<Task, "taskId" | "title" | "objective" | "status" | "version">;
             node: Pick<import("./model.ts").TaskNode, "nodeId" | "title" | "objective" | "status" | "version" | "runNo" | "requiredAgentPackageRef" | "workerRef" | "inputDocuments" | "outputDocuments">;
             documents: Array<{
+                documentRef: string;
                 documentType: string;
                 path: string;
                 contentHash: string;
                 sizeBytes: number;
+                revision: number;
+                sourceNodeId: string | null;
+                sourceNodeRunNo: number | null;
+                sourceDocumentRef: string | null;
+                sourceDocumentRevision: number | null;
+                updatedByRef: string;
+                updatedAt: string;
             }>;
         }>;
         listPendingMessages: (raw: unknown) => TaskResult<{

package/dist/src/phase4-continuation-services.js

@@ -126,8 +126,23 @@ export function createTaskServices(options) {
                     throw new ProjectionError("PRODUCT_CAMPAIGN_NOT_FOUND");
                 if (campaign.status !== "OPEN")
                     throw new ProjectionError("PRODUCT_CAMPAIGN_CLOSED");
+                if (campaign.version !== input.expectedCampaignVersion)
+                    throw new ProjectionError("PRODUCT_CAMPAIGN_VERSION_CONFLICT", true);
                 if (campaign.discussionRef !== input.discussionRef)
                     throw new ProjectionError("PRODUCT_DISCUSSION_MISMATCH");
+                const authorization = tx.campaignAuthorizations.get(input.authorizationRef);
+                if (!authorization)
+                    throw new ProjectionError("CAMPAIGN_AUTHORIZATION_NOT_FOUND");
+                if (authorization.version !== input.expectedAuthorizationVersion)
+                    throw new ProjectionError("CAMPAIGN_AUTHORIZATION_VERSION_CONFLICT", true);
+                if (authorization.revokedAt !== null)
+                    throw new ProjectionError("CAMPAIGN_AUTHORIZATION_REVOKED");
+                if (authorization.campaignRef !== campaign.campaignRef)
+                    throw new ProjectionError("CAMPAIGN_AUTHORIZATION_CAMPAIGN_MISMATCH");
+                if (authorization.discussionRef !== input.discussionRef)
+                    throw new ProjectionError("PRODUCT_DISCUSSION_MISMATCH");
+                if (authorization.goalRevision !== campaign.goalRevision)
+                    throw new ProjectionError("CAMPAIGN_GOAL_REVISION_MISMATCH");
                 const current = tx.productDocuments.get(input.documentRef);
                 if (input.expectedRevision === 0) {
                     if (current)

package/dist/src/phase4-contracts.js

@@ -58,6 +58,8 @@ const submitProductTaskIntentSchema = z
     .object({
     intentRef: id,
     campaignRef: id.optional(),
+    authorizationRef: id.optional(),
+    expectedAuthorizationVersion: version.optional(),
     discussionRef: id,
     goalRevision: version,
     intentRevision: version,
@@ -74,11 +76,17 @@ const submitProductTaskIntentSchema = z
 })
     .strict()
     .superRefine((input, context) => {
-    if ((input.campaignRef === undefined) !== (input.expectedCampaignVersion === undefined))
+    const campaignFields = [
+        input.campaignRef,
+        input.authorizationRef,
+        input.expectedAuthorizationVersion,
+        input.expectedCampaignVersion,
+    ];
+    if (campaignFields.some((value) => value !== undefined) && campaignFields.some((value) => value === undefined))
         context.addIssue({
             code: "custom",
-            message: "campaignRef and expectedCampaignVersion must be supplied together",
-            path: ["expectedCampaignVersion"],
+            message: "campaignRef, authorizationRef, expectedAuthorizationVersion, and expectedCampaignVersion must be supplied together",
+            path: ["authorizationRef"],
         });
     const packages = new Set(input.roleBindings.map((binding) => binding.agentPackageRef));
     if (packages.size !== requiredTaskAgentPackageRefs.length ||
@@ -128,6 +136,9 @@ const phase4Schemas = {
         documentRef: id,
         campaignRef: id,
         discussionRef: id,
+        authorizationRef: id,
+        expectedAuthorizationVersion: version,
+        expectedCampaignVersion: version,
         documentType: id,
         content: z.string().min(1),
         expectedRevision: revision,

package/dist/src/phase4-services.d.ts

@@ -80,10 +80,18 @@ export declare function createTaskServices(options: ServiceOptions): {
             task: Pick<Task, "taskId" | "title" | "objective" | "status" | "version">;
             node: Pick<import("./model.ts").TaskNode, "nodeId" | "title" | "objective" | "status" | "version" | "runNo" | "requiredAgentPackageRef" | "workerRef" | "inputDocuments" | "outputDocuments">;
             documents: Array<{
+                documentRef: string;
                 documentType: string;
                 path: string;
                 contentHash: string;
                 sizeBytes: number;
+                revision: number;
+                sourceNodeId: string | null;
+                sourceNodeRunNo: number | null;
+                sourceDocumentRef: string | null;
+                sourceDocumentRevision: number | null;
+                updatedByRef: string;
+                updatedAt: string;
             }>;
         }>;
         listPendingMessages: (raw: unknown) => TaskResult<{

package/dist/src/phase4-services.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { productDocumentAbsolute } from "./product-document-path.js";
 import { ZodError } from "zod";
 import { validatePublicInput } from "./phase4-contracts.js";
-import { requiredTaskAgentPackageRefs } from "./model.js";
+import { requiredTaskAgentPackageRefs, taskDocumentRef } from "./model.js";
 import { createTaskServices as createLegacyTaskServices, } from "./services.js";
 class Phase4DomainError extends Error {
     code;
@@ -144,6 +144,16 @@ function readinessBlockedReason(tx, task, workspaceRoot) {
         return "TASK_REQUIREMENT_REQUIRED";
     if (contentHash(readFileSync(absolute, "utf8")) !== requirement.contentHash)
         return "TASK_DOCUMENT_INDEX_MISMATCH";
+    if (requirement.sourceDocumentRef !== null) {
+        const source = tx.productDocuments.get(requirement.sourceDocumentRef);
+        if (!source ||
+            requirement.sourceDocumentRevision === null ||
+            source.revision !== requirement.sourceDocumentRevision ||
+            source.contentHash !== requirement.contentHash ||
+            source.filePath !== requirement.filePath ||
+            source.updatedByRef !== requirement.updatedByRef)
+            return "TASK_DOCUMENT_INDEX_MISMATCH";
+    }
     const bindings = tx.roleBindings.listByTask(task.taskId);
     if (bindings.length !== requiredTaskAgentPackageRefs.length)
         return "TASK_ROLE_BINDING_REQUIRED";
@@ -325,12 +335,21 @@ export function createTaskServices(options) {
             if (campaign.status !== "OPEN")
                 throw new Phase4DomainError("PRODUCT_CAMPAIGN_CLOSED");
             checkVersion(campaign.version, input.expectedCampaignVersion, "PRODUCT_CAMPAIGN_VERSION_CONFLICT");
-            if (campaign.discussionRef !== input.discussionRef ||
-                campaign.goalRevision !== input.goalRevision)
+            if (campaign.discussionRef !== input.discussionRef || campaign.goalRevision !== input.goalRevision)
                 throw new Phase4DomainError("CAMPAIGN_GOAL_REVISION_MISMATCH");
-            if (!subsetOf(input.scope, campaign.scope))
+            const authorization = requireAuthorization(tx, input.authorizationRef);
+            checkVersion(authorization.version, input.expectedAuthorizationVersion, "CAMPAIGN_AUTHORIZATION_VERSION_CONFLICT");
+            if (authorization.revokedAt !== null)
+                throw new Phase4DomainError("CAMPAIGN_AUTHORIZATION_REVOKED");
+            if (authorization.campaignRef !== campaign.campaignRef)
+                throw new Phase4DomainError("CAMPAIGN_AUTHORIZATION_CAMPAIGN_MISMATCH");
+            if (authorization.discussionRef !== input.discussionRef)
+                throw new Phase4DomainError("PRODUCT_DISCUSSION_MISMATCH");
+            if (authorization.goalRevision !== campaign.goalRevision)
+                throw new Phase4DomainError("CAMPAIGN_GOAL_REVISION_MISMATCH");
+            if (!subsetOf(input.scope, campaign.scope) || !subsetOf(input.scope, authorization.scope))
                 throw new Phase4DomainError("PRODUCT_INTENT_SCOPE_VIOLATION");
-            if (!same(input.constraints, campaign.constraints))
+            if (!same(input.constraints, campaign.constraints) || !same(input.constraints, authorization.constraints))
                 throw new Phase4DomainError("CAMPAIGN_CONSTRAINT_VIOLATION");
         }
         if (input.productDocuments.length > 0 && input.campaignRef === undefined)
@@ -537,13 +556,21 @@ export function createTaskServices(options) {
         if (!existsSync(absolute) ||
             contentHash(readFileSync(absolute, "utf8")) !== requirement.contentHash)
             throw new Phase4DomainError("PRODUCT_DOCUMENT_INDEX_MISMATCH");
+        const currentRequirement = tx.documents.get(current.taskId, "REQUIREMENT");
+        const taskDocumentRevision = (currentRequirement?.revision ?? 0) + 1;
+        const transferredDocumentRef = taskDocumentRef(current.taskId, "REQUIREMENT");
         tx.documents.upsert({
+            documentRef: transferredDocumentRef,
             taskId: current.taskId,
             documentType: "REQUIREMENT",
             sourceNodeId: null,
+            sourceNodeRunNo: null,
+            revision: taskDocumentRevision,
+            sourceDocumentRef: requirement.documentRef,
+            sourceDocumentRevision: requirement.revision,
             filePath: requirement.filePath,
             contentHash: requirement.contentHash,
-            updatedByRef: input.actorRef,
+            updatedByRef: requirement.updatedByRef,
             updatedAt: timestamp,
         });
         const advancedIntent = {
@@ -571,6 +598,9 @@ export function createTaskServices(options) {
             payload: {
                 intentRef: intent.intentRef,
                 productDocumentRef: requirement.documentRef,
+                productDocumentRevision: requirement.revision,
+                taskDocumentRef: transferredDocumentRef,
+                taskDocumentRevision,
             },
             createdAt: timestamp,
         });

package/dist/src/services.d.ts

@@ -77,6 +77,7 @@ export interface CompleteNodeResult {
     nextNodeId: string | null;
 }
 export interface DocumentResult {
+    documentRef: string;
     taskId: string;
     nodeId: string | null;
     documentType: string;
@@ -84,6 +85,11 @@ export interface DocumentResult {
     contentHash: string;
     sizeBytes: number;
     taskVersion: number;
+    revision: number;
+    sourceNodeRunNo: number | null;
+    sourceDocumentRef: string | null;
+    sourceDocumentRevision: number | null;
+    updatedByRef: string;
     updatedAt: string;
     content?: string;
 }
@@ -150,10 +156,18 @@ export declare function createTaskServices(options: {
             task: Pick<Task, "taskId" | "title" | "objective" | "status" | "version">;
             node: Pick<TaskNode, "nodeId" | "title" | "objective" | "status" | "version" | "runNo" | "requiredAgentPackageRef" | "workerRef" | "inputDocuments" | "outputDocuments">;
             documents: Array<{
+                documentRef: string;
                 documentType: string;
                 path: string;
                 contentHash: string;
                 sizeBytes: number;
+                revision: number;
+                sourceNodeId: string | null;
+                sourceNodeRunNo: number | null;
+                sourceDocumentRef: string | null;
+                sourceDocumentRevision: number | null;
+                updatedByRef: string;
+                updatedAt: string;
             }>;
         }>;
         listPendingMessages: (raw: unknown) => TaskResult<{

package/dist/src/services.js

@@ -3,7 +3,7 @@ import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, rea
 import { dirname, join } from "node:path";
 import { ZodError } from "zod";
 import { validatePublicInput } from "./contracts.js";
-import { requiredTaskAgentPackageRefs } from "./model.js";
+import { requiredTaskAgentPackageRefs, taskDocumentRef } from "./model.js";
 const allowedDocumentTypes = [
     "REQUIREMENT",
     "PRD",
@@ -590,9 +590,14 @@ export function createTaskServices(options) {
                 for (const item of validated.initialDocuments) {
                     const path = relativeDocumentPath(taskId, item.documentType);
                     tx.documents.upsert({
+                        documentRef: taskDocumentRef(taskId, item.documentType),
                         taskId,
                         documentType: item.documentType,
                         sourceNodeId: null,
+                        sourceNodeRunNo: null,
+                        revision: 1,
+                        sourceDocumentRef: null,
+                        sourceDocumentRevision: null,
                         filePath: path,
                         contentHash: contentHash(item.content),
                         updatedByRef: validated.actorRef,
@@ -848,6 +853,12 @@ export function createTaskServices(options) {
                 const doc = tx.documents.get(task.taskId, type);
                 if (!doc || !existsSync(join(workspaceRoot, doc.filePath)))
                     throw new DomainError("NODE_OUTPUT_MISSING", "A required output document is missing.");
+                if (doc.documentRef !== taskDocumentRef(task.taskId, type) ||
+                    doc.sourceNodeId !== node.nodeId ||
+                    doc.sourceNodeRunNo !== node.runNo ||
+                    doc.updatedByRef !== input.actorRef ||
+                    doc.revision < 1)
+                    throw new DomainError("NODE_OUTPUT_EVIDENCE_INVALID", "A required output document is not evidence from the current Node run.");
                 if (contentHash(readFileSync(join(workspaceRoot, doc.filePath), "utf8")) !== doc.contentHash)
                     throw new DomainError("DOCUMENT_INDEX_MISMATCH", "A required output document does not match its index.");
             }
@@ -1199,10 +1210,18 @@ export function createTaskServices(options) {
                 .map((type) => tx.documents.get(task.taskId, type))
                 .filter((item) => item !== undefined)
                 .map((document) => ({
+                documentRef: document.documentRef,
                 documentType: document.documentType,
                 path: document.filePath,
                 contentHash: document.contentHash,
                 sizeBytes: statSync(join(workspaceRoot, document.filePath)).size,
+                revision: document.revision,
+                sourceNodeId: document.sourceNodeId,
+                sourceNodeRunNo: document.sourceNodeRunNo,
+                sourceDocumentRef: document.sourceDocumentRef,
+                sourceDocumentRevision: document.sourceDocumentRevision,
+                updatedByRef: document.updatedByRef,
+                updatedAt: document.updatedAt,
             }));
             return {
                 task: {
@@ -1247,6 +1266,7 @@ export function createTaskServices(options) {
             const content = readFileSync(join(workspaceRoot, document.filePath), "utf8");
             const task = requireTask(tx, input.taskId);
             return {
+                documentRef: document.documentRef,
                 taskId: input.taskId,
                 nodeId: document.sourceNodeId,
                 documentType: type,
@@ -1254,6 +1274,11 @@ export function createTaskServices(options) {
                 contentHash: document.contentHash,
                 sizeBytes: statSync(join(workspaceRoot, document.filePath)).size,
                 taskVersion: task.version,
+                revision: document.revision,
+                sourceNodeRunNo: document.sourceNodeRunNo,
+                sourceDocumentRef: document.sourceDocumentRef,
+                sourceDocumentRevision: document.sourceDocumentRevision,
+                updatedByRef: document.updatedByRef,
                 updatedAt: document.updatedAt,
                 content,
             };
@@ -1301,9 +1326,23 @@ export function createTaskServices(options) {
             const result = command("putTaskDocument", raw, (tx, validated, timestamp) => {
                 const task = requireTask(tx, validated.taskId);
                 checkVersion(task.version, validated.expectedTaskVersion, "TASK_VERSION_CONFLICT");
-                if (validated.nodeId !== null)
-                    requireNode(tx, task.taskId, validated.nodeId);
                 const validatedType = ensureType(validated.documentType);
+                let sourceNodeRunNo = null;
+                if (validated.nodeId !== null) {
+                    const producer = requireNode(tx, task.taskId, validated.nodeId);
+                    if (task.status !== "ACTIVE" ||
+                        task.currentNodeId !== producer.nodeId ||
+                        producer.status !== "IN_PROGRESS")
+                        throw new DomainError("NODE_NOT_CURRENT", "Only the current IN_PROGRESS Node may produce Task evidence.");
+                    if (!matchesWorker(validated.actorRef, producer.workerRef))
+                        throw new DomainError("WORKER_MISMATCH", "Only the bound current Worker may produce Task evidence.");
+                    if (!producer.outputDocuments.includes(validatedType))
+                        throw new DomainError("NODE_OUTPUT_DOCUMENT_NOT_DECLARED", "Document type is not declared as an output of the current Node.");
+                    sourceNodeRunNo = producer.runNo;
+                }
+                else if (task.status !== "PENDING") {
+                    throw new DomainError("TASK_INVALID_STATE", "Node-less Task documents can only be written while the Task is PENDING.");
+                }
                 const path = relativeDocumentPath(task.taskId, validatedType);
                 const staged = `${documentUpdateRecoveryPath(task.taskId, validatedType, validated.idempotencyKey)}/next.md`;
                 // BEGIN IMMEDIATE + optimistic version validation happens before the
@@ -1317,10 +1356,18 @@ export function createTaskServices(options) {
                     updatedAt: timestamp,
                 };
                 tx.tasks.update(updated);
+                const currentDocument = tx.documents.get(task.taskId, validatedType);
+                const documentRevision = (currentDocument?.revision ?? 0) + 1;
+                const documentRef = taskDocumentRef(task.taskId, validatedType);
                 tx.documents.upsert({
+                    documentRef,
                     taskId: task.taskId,
                     documentType: validatedType,
                     sourceNodeId: validated.nodeId,
+                    sourceNodeRunNo,
+                    revision: documentRevision,
+                    sourceDocumentRef: null,
+                    sourceDocumentRevision: null,
                     filePath: path,
                     contentHash: contentHash(validated.content),
                     updatedByRef: validated.actorRef,
@@ -1336,9 +1383,15 @@ export function createTaskServices(options) {
                     actorRef: validated.actorRef,
                     taskVersion: readied.version,
                     nodeVersion: null,
-                    payload: { documentType: validatedType },
+                    payload: {
+                        documentType: validatedType,
+                        documentRef,
+                        revision: documentRevision,
+                        sourceNodeRunNo,
+                    },
                 }, timestamp);
                 return {
+                    documentRef,
                     taskId: task.taskId,
                     nodeId: validated.nodeId,
                     documentType: validatedType,
@@ -1346,6 +1399,11 @@ export function createTaskServices(options) {
                     contentHash: contentHash(validated.content),
                     sizeBytes: Buffer.byteLength(validated.content),
                     taskVersion: readied.version,
+                    revision: documentRevision,
+                    sourceNodeRunNo,
+                    sourceDocumentRef: null,
+                    sourceDocumentRevision: null,
+                    updatedByRef: validated.actorRef,
                     updatedAt: timestamp,
                 };
             });
@@ -1373,31 +1431,16 @@ export function createTaskServices(options) {
                         promoteDocument(staged, relativeDocumentPath(input.taskId, type));
                 }
                 cleanupCreateStage(input.taskId);
-                const result = store.transaction((tx) => {
+                const result = store.read((tx) => {
                     requireTask(tx, input.taskId);
-                    let reconciled = 0;
-                    for (const type of allowedDocumentTypes) {
-                        const path = relativeDocumentPath(input.taskId, type);
-                        const absolute = join(workspaceRoot, path);
+                    for (const document of tx.documents.listByTask(input.taskId)) {
+                        const absolute = join(workspaceRoot, document.filePath);
                         if (!existsSync(absolute))
-                            continue;
-                        const content = readFileSync(absolute, "utf8");
-                        const current = tx.documents.get(input.taskId, type);
-                        const digest = contentHash(content);
-                        if (!current || current.contentHash !== digest) {
-                            tx.documents.upsert({
-                                taskId: input.taskId,
-                                documentType: type,
-                                sourceNodeId: current?.sourceNodeId ?? null,
-                                filePath: path,
-                                contentHash: digest,
-                                updatedByRef: input.actorRef,
-                                updatedAt: now(),
-                            });
-                            reconciled++;
-                        }
+                            throw new DomainError("DOCUMENT_INDEX_MISMATCH", "Canonical Task document is missing.");
+                        if (contentHash(readFileSync(absolute, "utf8")) !== document.contentHash)
+                            throw new DomainError("DOCUMENT_INDEX_MISMATCH", "Canonical Task document does not match durable evidence metadata.");
                     }
-                    return { reconciled };
+                    return { reconciled: 0 };
                 });
                 return success(result);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-task-orchestration",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -24,8 +24,8 @@
   },
   "devDependencies": {
     "@tomflow/proflow-deployment-conformance": "^0.1.13",
-    "@tomflow/proflow-task-store-sqlite": "^0.1.12",
-    "@tomflow/proflow-task-migration-runner": "^0.1.11"
+    "@tomflow/proflow-task-migration-runner": "^0.1.12",
+    "@tomflow/proflow-task-store-sqlite": "^0.1.14"
   },
   "description": "Owns the Task & Orchestration public contract, domain rules and application services.",
   "keywords": [

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "task-orchestration",
 	"packageName": "@tomflow/proflow-task-orchestration",
-	"moduleVersion": "0.1.13",
+	"moduleVersion": "0.1.15",
 	"kind": "library",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",