@tomflow/proflow-task-orchestration 0.1.11 → 0.1.13

package/dist/src/product-document-path.d.ts

@@ -0,0 +1,2 @@
+/** Only owner-generated, flat Markdown files under the workspace are accepted. */
+export declare function productDocumentAbsolute(workspaceRoot: string, filePath: string): string;

package/dist/src/product-document-path.js

@@ -0,0 +1,24 @@
+import { lstatSync, realpathSync } from "node:fs";
+import { resolve, sep } from "node:path";
+/** Only owner-generated, flat Markdown files under the workspace are accepted. */
+export function productDocumentAbsolute(workspaceRoot, filePath) {
+    if (!/^product-requirements\/[a-f0-9]{24}\.md$/.test(filePath))
+        throw new Error("PRODUCT_DOCUMENT_PATH_INVALID");
+    const workspace = realpathSync(workspaceRoot);
+    const directory = resolve(workspace, "product-requirements");
+    const absolute = resolve(workspace, filePath);
+    for (const path of [directory, absolute]) {
+        try {
+            const stat = lstatSync(path);
+            if (stat.isSymbolicLink() || (path === directory ? !stat.isDirectory() : !stat.isFile()))
+                throw new Error("PRODUCT_DOCUMENT_PATH_INVALID");
+            if (!realpathSync(path).startsWith(`${workspace}${sep}`))
+                throw new Error("PRODUCT_DOCUMENT_PATH_INVALID");
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                throw error;
+        }
+    }
+    return absolute;
+}

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 {
@@ -1016,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,

package/package.json

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