@tomflow/proflow-task-orchestration 0.1.10 → 0.1.12

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @tomflow/proflow-task-orchestration
 
+## 0.1.12
+
+### Patch Changes
+
+- Prune empty Task-level document recovery directories after recovery journals converge so durable recovery leaves no orphan filesystem residue.
+
+- Harden Task-scoped Worker identity and generation semantics so reopened or invalidated executions cannot reuse stale Worker/conversation ownership or a previously consumed run generation.
+
+## 0.1.11
+
+### Patch Changes
+
+- Release the verified Real-3 B1 task recovery, exact execution identity, durable observer resume, bounded gateway error, and matching Agent Action contract fixes.
+
 ## 0.1.10
 
 ### 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.10";
+        readonly moduleVersion: "0.1.12";
     };
     observedEffects: string[];
 };
@@ -17,7 +17,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "task-orchestration";
-            moduleVersion: "0.1.10";
+            moduleVersion: "0.1.12";
             data: {
                 setupStatus: "READY";
                 runtimeStatus: "NOT_APPLICABLE";
@@ -32,7 +32,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "task-orchestration";
-            moduleVersion: "0.1.10";
+            moduleVersion: "0.1.12";
             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.10";
+    readonly moduleVersion: "0.1.12";
     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.10",
+    moduleVersion: "0.1.12",
     kind: "library",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",

package/dist/src/contracts.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { requiredTaskAgentPackageRefs } from "./model.js";
+import { requiredTaskAgentPackageRefs, taskWaitTypes } from "./model.js";
 export const publicOperationNames = [
     "createTaskGroup",
     "getTaskGroup",
@@ -98,6 +98,14 @@ const schemas = {
                 path: ["sequenceNo"],
             });
         }
+        input.roleBindings.forEach((binding, index) => {
+            if (binding.workerRef !== null || binding.conversationLocator !== null)
+                context.addIssue({
+                    code: "custom",
+                    message: "createTask roleBindings must start with workerRef and conversationLocator unset",
+                    path: ["roleBindings", index],
+                });
+        });
         const declaredAgentPackageRefs = new Set(input.roleBindings.map((binding) => binding.agentPackageRef));
         if (declaredAgentPackageRefs.size !== requiredTaskAgentPackageRefs.length ||
             requiredTaskAgentPackageRefs.some((agentPackageRef) => !declaredAgentPackageRefs.has(agentPackageRef))) {
@@ -136,7 +144,7 @@ const schemas = {
     waitNode: z
         .object({
         ...nodeVersion,
-        waitType: id,
+        waitType: z.enum(taskWaitTypes),
         reasonCode: id,
         message: id,
         relatedRef: id.optional(),

package/dist/src/model.d.ts

@@ -1,4 +1,6 @@
 export declare const requiredTaskAgentPackageRefs: readonly ["@tomflow/proflow-agent-product", "@tomflow/proflow-agent-controller-dev", "@tomflow/proflow-agent-test-ops"];
+export declare const taskWaitTypes: readonly ["BUSINESS_CONFIRMATION", "REQUIREMENT_BLOCKED", "EXTERNAL_BUSINESS_DEPENDENCY"];
+export type TaskWaitType = (typeof taskWaitTypes)[number];
 export type TaskGroupStatus = "READY" | "ACTIVE" | "SUCCEEDED";
 export type TaskStatus = "PENDING" | "READY" | "ACTIVE" | "WAITING" | "FAILED" | "PAUSED" | "SUCCEEDED" | "TERMINATED";
 export type NodeStatus = "PENDING" | "READY" | "IN_PROGRESS" | "WAITING" | "FAILED" | "SUCCEEDED" | "TERMINATED";

package/dist/src/model.js

@@ -3,3 +3,8 @@ export const requiredTaskAgentPackageRefs = [
     "@tomflow/proflow-agent-controller-dev",
     "@tomflow/proflow-agent-test-ops",
 ];
+export const taskWaitTypes = [
+    "BUSINESS_CONFIRMATION",
+    "REQUIREMENT_BLOCKED",
+    "EXTERNAL_BUSINESS_DEPENDENCY",
+];

package/dist/src/services.d.ts

@@ -144,6 +144,7 @@ export declare function createTaskServices(options: {
             } | null;
             canDrive: boolean;
             blockedReason: string | null;
+            resumeSignalRef: string | null;
         }>;
         getNodeContext: (raw: unknown) => TaskResult<{
             task: Pick<Task, "taskId" | "title" | "objective" | "status" | "version">;

package/dist/src/services.js

@@ -180,6 +180,17 @@ function recomputeReadiness(tx, task, timestamp, workspaceRoot) {
 function matchesWorker(actorRef, workerRef) {
     return workerRef !== null && actorRef === `worker:${workerRef}`;
 }
+function workerIdentityBoundToAnotherTask(tx, input) {
+    for (const task of tx.tasks.list()) {
+        if (task.taskId === input.taskId)
+            continue;
+        for (const binding of tx.roleBindings.listByTask(task.taskId))
+            if (binding.workerRef === input.workerRef ||
+                binding.conversationLocator === input.conversationLocator)
+                return true;
+    }
+    return false;
+}
 export function createTaskServices(options) {
     const { store, workspaceRoot } = options;
     const now = options.now ?? (() => new Date().toISOString());
@@ -321,13 +332,22 @@ export function createTaskServices(options) {
         ? taskId
         : `id-${createHash("sha256").update(taskId).digest("hex")}`;
     const stageDocumentPath = (taskId, type) => `.proflow/recovery/task-create/${safeTaskId(taskId)}/${type.toLowerCase().replaceAll("_", "-")}.md`;
-    const documentUpdateRecoveryRoot = (taskId, type) => `.proflow/recovery/task-document/${safeTaskId(taskId)}/${type.toLowerCase().replaceAll("_", "-")}`;
+    const documentUpdateRecoveryTaskRoot = (taskId) => `.proflow/recovery/task-document/${safeTaskId(taskId)}`;
+    const documentUpdateRecoveryRoot = (taskId, type) => `${documentUpdateRecoveryTaskRoot(taskId)}/${type.toLowerCase().replaceAll("_", "-")}`;
     const documentUpdateRecoveryPath = (taskId, type, idempotencyKey) => `${documentUpdateRecoveryRoot(taskId, type)}/${createHash("sha256").update(idempotencyKey).digest("hex")}`;
+    const cleanupDocumentRecoveryTaskRoot = (taskId) => {
+        const taskRootAbsolute = join(workspaceRoot, documentUpdateRecoveryTaskRoot(taskId));
+        if (existsSync(taskRootAbsolute) &&
+            readdirSync(taskRootAbsolute).length === 0)
+            rmSync(taskRootAbsolute, { recursive: true, force: true });
+    };
     const recoverPendingDocumentUpdates = (taskId, type) => {
         const recoveryRoot = documentUpdateRecoveryRoot(taskId, type);
         const recoveryRootAbsolute = join(workspaceRoot, recoveryRoot);
-        if (!existsSync(recoveryRootAbsolute))
+        if (!existsSync(recoveryRootAbsolute)) {
+            cleanupDocumentRecoveryTaskRoot(taskId);
             return;
+        }
         const canonicalPath = relativeDocumentPath(taskId, type);
         const canonicalAbsolute = join(workspaceRoot, canonicalPath);
         const currentMetadata = store.read((tx) => tx.documents.get(taskId, type));
@@ -375,6 +395,7 @@ export function createTaskServices(options) {
         }
         if (readdirSync(recoveryRootAbsolute).length === 0)
             rmSync(recoveryRootAbsolute, { recursive: true, force: true });
+        cleanupDocumentRecoveryTaskRoot(taskId);
     };
     const cleanupCreateStage = (taskId) => {
         rmSync(join(workspaceRoot, `.proflow/recovery/task-create/${safeTaskId(taskId)}`), { recursive: true, force: true });
@@ -630,6 +651,8 @@ export function createTaskServices(options) {
                 throw new DomainError("AGENT_PACKAGE_NOT_ELIGIBLE", "Agent package is not declared by the Task.");
             if (old.roleRef !== input.roleRef)
                 throw new DomainError("ROLE_BINDING_MISMATCH", "RoleRef does not match the declared binding.");
+            if (workerIdentityBoundToAnotherTask(tx, input))
+                throw new DomainError("TASK_ROLE_BINDING_CONFLICT", "Worker or Conversation identity is already bound to another Task.");
             if (old.workerRef === input.workerRef &&
                 old.conversationLocator === input.conversationLocator)
                 return {
@@ -726,15 +749,24 @@ export function createTaskServices(options) {
             const current = task.currentNodeId
                 ? tx.nodes.get(task.currentNodeId)
                 : undefined;
+            if (task.status === "WAITING" && current?.status !== "WAITING")
+                throw new DomainError("TASK_INVALID_STATE", "A WAITING Task must have a current WAITING Node.");
             if (current?.status === "FAILED")
                 throw new DomainError("TASK_INVALID_STATE", "A failed Node must be explicitly reopened before resume.");
-            if (current?.status === "WAITING")
+            if (current?.status === "WAITING") {
+                const unresolved = tx.messages
+                    .listPending()
+                    .some((message) => message.taskId === task.taskId &&
+                    message.nodeId === current.nodeId);
+                if (unresolved)
+                    throw new DomainError("TASK_BLOCKER_UNRESOLVED", "The current Node still has an unresolved business blocker.");
                 tx.nodes.update({
                     ...current,
                     status: "IN_PROGRESS",
                     version: current.version + 1,
                     updatedAt: timestamp,
                 });
+            }
             const updated = {
                 ...task,
                 status: "ACTIVE",
@@ -910,6 +942,8 @@ export function createTaskServices(options) {
             checkVersion(node.version, input.expectedNodeVersion, "NODE_VERSION_CONFLICT");
             if (task.status !== "ACTIVE")
                 throw new DomainError("TASK_INVALID_STATE", "Task must be ACTIVE before a Node can wait.");
+            if (task.currentNodeId !== node.nodeId)
+                throw new DomainError("NODE_NOT_CURRENT", "Only the current Node can enter WAITING.");
             if (node.status !== "IN_PROGRESS" ||
                 !matchesWorker(input.actorRef, node.workerRef))
                 throw new DomainError(!matchesWorker(input.actorRef, node.workerRef)
@@ -950,10 +984,14 @@ export function createTaskServices(options) {
             const node = requireNode(tx, input.taskId, input.nodeId);
             checkVersion(task.version, input.expectedTaskVersion, "TASK_VERSION_CONFLICT");
             checkVersion(node.version, input.expectedNodeVersion, "NODE_VERSION_CONFLICT");
-            if (!["ACTIVE", "WAITING"].includes(task.status))
-                throw new DomainError("TASK_INVALID_STATE", "Task cannot accept a Node failure in its current state.");
-            if (!["IN_PROGRESS", "WAITING"].includes(node.status))
-                throw new DomainError("NODE_INVALID_STATE", "Node cannot fail.");
+            if (task.status !== "ACTIVE")
+                throw new DomainError("TASK_INVALID_STATE", "Task must be ACTIVE before the current run can fail.");
+            if (task.currentNodeId !== node.nodeId)
+                throw new DomainError("NODE_NOT_CURRENT", "Only the current Node can record a run failure.");
+            if (!matchesWorker(input.actorRef, node.workerRef))
+                throw new DomainError("WORKER_MISMATCH", "Only the bound running Worker may fail the current Node.");
+            if (node.status !== "IN_PROGRESS")
+                throw new DomainError("NODE_INVALID_STATE", "Only the current IN_PROGRESS run can fail.");
             const failedNode = {
                 ...node,
                 status: "FAILED",
@@ -1001,11 +1039,13 @@ export function createTaskServices(options) {
             tx.nodes.update(reopened);
             for (const later of tx.nodes.listByTask(task.taskId))
                 if (later.sequenceNo > target.sequenceNo) {
+                    const invalidatedStartedRun = later.startedAt !== null || later.workerRef !== null;
                     preserveRunHistory(tx, later, later.status, timestamp);
                     tx.nodes.update({
                         ...later,
                         status: "PENDING",
                         version: later.version + 1,
+                        runNo: later.runNo + (invalidatedStartedRun ? 1 : 0),
                         workerRef: null,
                         resultSummary: null,
                         errorCode: null,
@@ -1116,6 +1156,13 @@ export function createTaskServices(options) {
             else if (!terminal && !roleBinding?.workerRef)
                 blockedReason = "TASK_ROLE_BINDING_REQUIRED";
             const canDrive = !terminal && blockedReason === null;
+            let durableResumeEventId;
+            if (task.status === "ACTIVE" && currentNode?.status === "IN_PROGRESS")
+                for (const taskEvent of tx.events.listByTask(task.taskId))
+                    if (taskEvent.eventType === "TASK_RESUMED" &&
+                        taskEvent.taskVersion === task.version &&
+                        taskEvent.eventId !== undefined)
+                        durableResumeEventId = taskEvent.eventId;
             return {
                 taskId: task.taskId,
                 taskStatus: task.status,
@@ -1140,6 +1187,9 @@ export function createTaskServices(options) {
                     : null,
                 canDrive,
                 blockedReason,
+                resumeSignalRef: durableResumeEventId === undefined
+                    ? null
+                    : `task-event:${durableResumeEventId}`,
             };
         }),
         getNodeContext: (raw) => queryWithDocumentRecovery("getNodeContext", raw, (tx, input) => {

package/dist/src/transitions.js

@@ -7,7 +7,7 @@ const taskTransitions = {
     READY: ["ACTIVE", "TERMINATED"],
     ACTIVE: ["WAITING", "PAUSED", "FAILED", "SUCCEEDED", "TERMINATED"],
     WAITING: ["ACTIVE", "PAUSED", "TERMINATED"],
-    FAILED: ["PAUSED", "TERMINATED"],
+    FAILED: ["TERMINATED"],
     PAUSED: ["ACTIVE", "TERMINATED"],
     SUCCEEDED: [],
     TERMINATED: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-task-orchestration",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@tomflow/proflow-deployment-conformance": "^0.1.13",
     "@tomflow/proflow-task-migration-runner": "^0.1.11",
-    "@tomflow/proflow-task-store-sqlite": "^0.1.11"
+    "@tomflow/proflow-task-store-sqlite": "^0.1.12"
   },
   "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.10",
+	"moduleVersion": "0.1.12",
 	"kind": "library",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",