@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/sync/v3/durableTaskAttachmentLinksMutationRouter.js

@@ -140,10 +140,19 @@ export function createDurableTaskAttachmentLinksMutationRouter(input) {
                     catch {
                         throw new DurableTaskAttachmentLinksMutationError('Captured task attachment-link payload is invalid.', 'TASK_ATTACHMENT_LINKS_IDENTITY_CONFLICT', 409);
                     }
-                    if (canonicalWorkspaceSyncJson(frozen) !== canonicalWorkspaceSyncJson(links)
+                    const relationshipIntent = (entries) => entries.map((link) => ({
+                        assetId: link.assetId,
+                        role: link.role,
+                        order: link.order,
+                    }));
+                    if (canonicalWorkspaceSyncJson(relationshipIntent(frozen))
+                        !== canonicalWorkspaceSyncJson(relationshipIntent(links))
                         || String(payload.cardCoverAssetId || '') !== String(cardCoverAssetId || '')) {
                         throw new DurableTaskAttachmentLinksMutationError('Operation identity is assigned to different task attachment links.', 'TASK_ATTACHMENT_LINKS_IDENTITY_CONFLICT', 409);
                     }
+                    store.assertOutboxOperationIdentity(existing, {
+                        domain: 'task-attachment-links', entityId: taskId, mutationKind: 'replace',
+                    });
                     const task = input.core.getTask(taskId, workspaceId);
                     if (!task)
                         throw new DurableTaskAttachmentLinksMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
@@ -204,6 +213,10 @@ export function createDurableTaskAttachmentLinksMutationRouter(input) {
                 baseEntityRevision: coordinates.entityRevision, baseLifecycleRevision: coordinates.lifecycleRevision,
                 now: acceptedAtIso, leaseExpiresAt: new Date(acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
                 actorRef, onPostCommitError: input.onPostCommitError,
+                expectedDetailRevision: args.expectedDetailRevision,
+                assertPrecondition: args.expectedDetailRevision
+                    ? () => input.core.assertTaskDetailRevisionForUpdate(taskId, args.expectedDetailRevision, workspaceId)
+                    : undefined,
             });
             if (result.state === 'in_progress')
                 throw new DurableTaskAttachmentLinksRouterInProgressError(result.retryAt);

package/dist/sync/v3/durableTaskChecklistMutationRouter.d.ts

@@ -1,7 +1,7 @@
 import type { ChecklistItem, TaskItem } from '../../core/Taskforce.js';
 import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
 import { type LocalTaskChecklistOutboxCore } from './localTaskChecklistOutboxService.js';
-import { type DurableTaskChecklistServiceCore } from './taskChecklistMutationService.js';
+import { type DurableTaskChecklistServiceCore, type TaskChecklistItemUpdateIntent } from './taskChecklistMutationService.js';
 export declare function resolveTaskChecklistMutationCapability(input: {
     runtimeMode: 'local' | 'cloud';
     surface: 'http' | 'mcp';
@@ -11,6 +11,7 @@ export declare function resolveTaskChecklistMutationCapability(input: {
 export type DurableTaskChecklistMutationRouterCore = DurableTaskChecklistServiceCore & LocalTaskChecklistOutboxCore & {
     getDatabaseAdapter(): DatabaseAdapter;
     getTask(id: string, workspaceId?: string): TaskItem | null;
+    assertTaskDetailRevisionForUpdate(id: string, expected: string, workspaceId?: string): void;
 };
 export declare class DurableTaskChecklistRouterDisabledError extends Error {
     readonly code = "WORKSPACE_SYNC_V3_TASK_CHECKLIST_ROUTER_DISABLED";
@@ -38,6 +39,8 @@ export declare function createDurableTaskChecklistMutationRouter(input: {
     replace(args: {
         taskId: string;
         items: readonly Partial<ChecklistItem>[];
+        expectedDetailRevision?: string;
+        itemUpdateIntent?: TaskChecklistItemUpdateIntent;
     }): {
         state: "pending" | "committed";
         route: "local-outbox" | "cloud-acceptance";

package/dist/sync/v3/durableTaskChecklistMutationRouter.js

@@ -1,7 +1,7 @@
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 import { LocalSyncIdentityStore } from './localSyncIdentityStore.js';
 import { enqueueLocalTaskChecklistMutation, } from './localTaskChecklistOutboxService.js';
-import { DurableTaskChecklistMutationError, runDurableTaskChecklistReplace, } from './taskChecklistMutationService.js';
+import { DurableTaskChecklistMutationError, runDurableTaskChecklistReplace, validateTaskChecklistItemUpdateIntent, } from './taskChecklistMutationService.js';
 import { WorkspaceSyncDurabilityStore, WorkspaceSyncEntityBusyError } from './syncDurabilityStore.js';
 import { serializeWorkspaceSyncV3TaskChecklistPayload } from './workspaceSyncV3NestedTaskCodecs.js';
 const OPERATION_LEASE_MS = 30_000;
@@ -82,6 +82,18 @@ export function createDurableTaskChecklistMutationRouter(input) {
             catch (error) {
                 throw new DurableTaskChecklistMutationError(error instanceof Error ? error.message : 'Task checklist is invalid.', 'TASK_CHECKLIST_INVALID', 400);
             }
+            const itemUpdateIntent = args.itemUpdateIntent
+                ? validateTaskChecklistItemUpdateIntent(args.itemUpdateIntent)
+                : undefined;
+            if (itemUpdateIntent) {
+                const target = items.find((item) => item.id === itemUpdateIntent.itemId);
+                if (!target
+                    || (itemUpdateIntent.patch.text !== undefined && target.title !== itemUpdateIntent.patch.text)
+                    || (itemUpdateIntent.patch.done !== undefined && target.isCompleted !== itemUpdateIntent.patch.done)
+                    || (itemUpdateIntent.patch.order !== undefined && target.order !== itemUpdateIntent.patch.order)) {
+                    throw new DurableTaskChecklistMutationError('Task checklist item update intent does not match the replacement aggregate.', 'TASK_CHECKLIST_INVALID', 400);
+                }
+            }
             const acceptedAt = now();
             const acceptedAtIso = acceptedAt.toISOString();
             const operationId = operationIdRequired(input.operationId);
@@ -109,25 +121,43 @@ export function createDurableTaskChecklistMutationRouter(input) {
                     catch {
                         throw new DurableTaskChecklistMutationError('Captured task checklist payload is invalid.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                     }
-                    if (canonicalWorkspaceSyncJson(frozen) !== canonicalWorkspaceSyncJson(items)) {
+                    const capturedIntent = payload.itemUpdateIntent
+                        ? validateTaskChecklistItemUpdateIntent(payload.itemUpdateIntent)
+                        : undefined;
+                    const requestedIntent = itemUpdateIntent;
+                    if (capturedIntent || requestedIntent
+                        ? canonicalWorkspaceSyncJson(capturedIntent) !== canonicalWorkspaceSyncJson(requestedIntent)
+                        : canonicalWorkspaceSyncJson(frozen) !== canonicalWorkspaceSyncJson(items)) {
                         throw new DurableTaskChecklistMutationError('Operation identity is assigned to a different task checklist.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                     }
+                    if ((payload.expectedDetailRevision || undefined) !== (args.expectedDetailRevision || undefined)) {
+                        throw new DurableTaskChecklistMutationError('Operation identity is assigned to a different task checklist precondition.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
+                    }
+                    store.assertOutboxOperationIdentity(existing, {
+                        domain: 'task-checklist', entityId: taskId, mutationKind: 'replace',
+                    });
                     const task = input.core.getTask(taskId, workspaceId);
                     if (!task)
                         throw new DurableTaskChecklistMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
                     const installed = serializeWorkspaceSyncV3TaskChecklistPayload({
                         taskId, items: task.checklistItems || [],
                     }).items;
-                    if (canonicalWorkspaceSyncJson(installed) !== canonicalWorkspaceSyncJson(frozen)) {
+                    if (!capturedIntent
+                        && canonicalWorkspaceSyncJson(installed) !== canonicalWorkspaceSyncJson(frozen)) {
                         throw new DurableTaskChecklistMutationError('Captured task checklist does not match local state.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                     }
-                    return { state: 'pending', route: 'local-outbox', operationId, task };
+                    return {
+                        state: 'pending', route: 'local-outbox', operationId,
+                        task: capturedIntent ? { ...task, checklistItems: frozen } : task,
+                    };
                 }
                 let result;
                 try {
                     result = enqueueLocalTaskChecklistMutation({
                         store, core: input.core, identity, taskId, items, now: acceptedAtIso,
                         actorRef, onPostCommitError: input.onPostCommitError,
+                        expectedDetailRevision: args.expectedDetailRevision,
+                        itemUpdateIntent,
                         requireV3CombinedOwnership: persistedOwnershipChecked,
                     });
                 }
@@ -142,6 +172,7 @@ export function createDurableTaskChecklistMutationRouter(input) {
                 return { state: 'pending', route: 'local-outbox', operationId, task };
             }
             const committed = store.readCommittedOperationResponse(identity);
+            let coordinates;
             if (committed) {
                 let response;
                 try {
@@ -150,33 +181,49 @@ export function createDurableTaskChecklistMutationRouter(input) {
                 catch {
                     throw new DurableTaskChecklistMutationError('Committed task checklist response is invalid.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                 }
+                const projection = response.authoritative?.checklist;
+                const acceptedRevision = String(projection?.entityRevision || '');
+                const lifecycleRevision = String(projection?.lifecycleRevision || '');
                 if (response.workspaceId !== workspaceId || response.clientId !== clientId
                     || response.operationId !== operationId || response.authoritative?.root?.entityId !== taskId
-                    || response.authoritative?.checklist?.entityId !== taskId
-                    || canonicalWorkspaceSyncJson(response.authoritative.checklist.payload?.items || [])
-                        !== canonicalWorkspaceSyncJson(items)) {
+                    || projection?.entityId !== taskId
+                    || !/^[1-9]\d*$/.test(acceptedRevision)
+                    || !/^(0|[1-9]\d*)$/.test(lifecycleRevision)) {
                     throw new DurableTaskChecklistMutationError('Operation identity is assigned to a different task checklist.', 'TASK_CHECKLIST_IDENTITY_CONFLICT', 409);
                 }
-                const task = input.core.getTask(taskId, workspaceId);
-                if (!task)
-                    throw new DurableTaskChecklistMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
-                return { state: 'committed', route: 'cloud-acceptance', operationId, task };
+                coordinates = {
+                    entityRevision: String(BigInt(acceptedRevision) - 1n),
+                    lifecycleRevision,
+                };
+            }
+            else {
+                coordinates = store.readEntityRevisionCoordinates({
+                    tenantId, workspaceId, domain: 'task-checklist', entityId: taskId,
+                });
             }
-            const coordinates = store.readEntityRevisionCoordinates({
-                tenantId, workspaceId, domain: 'task-checklist', entityId: taskId,
-            });
             const result = runDurableTaskChecklistReplace({
                 store, core: input.core, tenantId, workspaceId, clientId, operationId, taskId, items,
                 baseEntityRevision: coordinates.entityRevision, baseLifecycleRevision: coordinates.lifecycleRevision,
                 now: acceptedAtIso, leaseExpiresAt: new Date(acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
                 actorRef, onPostCommitError: input.onPostCommitError,
+                expectedDetailRevision: args.expectedDetailRevision,
+                itemUpdateIntent,
+                assertPrecondition: args.expectedDetailRevision
+                    ? () => input.core.assertTaskDetailRevisionForUpdate(taskId, args.expectedDetailRevision, workspaceId)
+                    : undefined,
             });
             if (result.state === 'in_progress')
                 throw new DurableTaskChecklistRouterInProgressError(result.retryAt);
             const task = input.core.getTask(taskId, workspaceId);
             if (!task)
                 throw new DurableTaskChecklistMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
-            return { state: 'committed', route: 'cloud-acceptance', operationId, task };
+            return {
+                state: 'committed', route: 'cloud-acceptance', operationId,
+                task: {
+                    ...task,
+                    checklistItems: result.response.authoritative.checklist.payload.items,
+                },
+            };
         },
     };
 }

package/dist/sync/v3/durableTaskCommentMutationRouter.js

@@ -113,6 +113,9 @@ export function createDurableTaskCommentMutationRouter(input) {
                     if (!sameCommentRetryIntent(existingPayload.comment, canonical)) {
                         throw new DurableTaskCommentMutationError('Operation identity is assigned to a different task comment.', 'TASK_COMMENT_IDENTITY_CONFLICT', 409);
                     }
+                    store.assertOutboxOperationIdentity(existing, {
+                        domain: 'task-comments', entityId: taskId, mutationKind: 'append',
+                    });
                     const frozenComment = serializeWorkspaceSyncV3TaskCommentsPayload({
                         taskId, comments: [existingPayload.comment],
                     }).comments[0];

package/dist/sync/v3/durableTaskHttpBulkMutationRouter.d.ts

@@ -51,6 +51,7 @@ export declare function createDurableTaskHttpBulkMutationRouter(input: {
     }>, options?: {
         saveSource?: "manual" | "autosave";
         atomicItemFailures?: boolean;
+        expectedDetailRevision?: string;
     }): {
         preview: import("../../core/Taskforce.js").BulkUpdateFieldsPreview;
         results: TaskItem[];

package/dist/sync/v3/durableTaskHttpBulkMutationRouter.js

@@ -222,7 +222,12 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
             }, { atomicRecovery: true });
         },
         updateFields(updates, options = {}) {
-            return input.rootRouter.runBatch('bulk-update-fields', { updates }, (batch) => {
+            return input.rootRouter.runBatch('bulk-update-fields', {
+                updates,
+                ...(options.expectedDetailRevision
+                    ? { expectedDetailRevision: options.expectedDetailRevision }
+                    : {}),
+            }, (batch) => {
                 const preview = input.core.bulkUpdateFieldsPreview(updates, input.workspaceId);
                 const results = [];
                 const errors = preview.skipped
@@ -273,14 +278,21 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
                                 && !(durableAttachmentLinks && key === 'cardCoverAssetId'))))
                             : item.fields;
                         let updated = input.core.getTask(item.id, input.workspaceId);
+                        let expectedDetailRevision = options.expectedDetailRevision;
                         if (Object.keys(rootFields).length > 0) {
                             const child = input.createChildRouter(input.deriveChildOperationId('bulk-update-fields-root', item.index, item.id), () => { });
                             updated = child.enabled
-                                ? batch.runChild(() => child.update(item.id, rootFields, options.saveSource || 'manual'))
-                                : input.core.updateTask(item.id, rootFields, input.workspaceId, {
-                                    actorRef: 'user',
-                                    saveSource: options.saveSource || 'manual',
-                                });
+                                ? batch.runChild(() => child.update(item.id, rootFields, options.saveSource || 'manual', undefined, expectedDetailRevision))
+                                : (() => {
+                                    if (expectedDetailRevision) {
+                                        input.core.assertTaskDetailRevisionForUpdate(item.id, expectedDetailRevision, input.workspaceId);
+                                    }
+                                    return input.core.updateTask(item.id, rootFields, input.workspaceId, {
+                                        actorRef: 'user',
+                                        saveSource: options.saveSource || 'manual',
+                                    });
+                                })();
+                            expectedDetailRevision = undefined;
                         }
                         if (durableChecklist && checklist) {
                             const currentTask = input.core.getTask(item.id, input.workspaceId) || updated;
@@ -301,7 +313,12 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
                                     updatedAt: String(unchanged ? existing.updatedAt : existing ? now : source.updatedAt || createdAt),
                                 };
                             });
-                            updated = batch.runChild(() => checklist.replace({ taskId: item.id, items: normalizedChecklist }).task);
+                            updated = batch.runChild(() => checklist.replace({
+                                taskId: item.id,
+                                items: normalizedChecklist,
+                                expectedDetailRevision,
+                            }).task);
+                            expectedDetailRevision = undefined;
                         }
                         if (durableAttachmentLinks && attachmentLinks) {
                             updated = batch.runChild(() => attachmentLinks.replace({
@@ -312,7 +329,9 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
                                         ? null
                                         : String(item.fields.cardCoverAssetId).trim(),
                                 } : {}),
+                                expectedDetailRevision,
                             }).task);
+                            expectedDetailRevision = undefined;
                         }
                         if (updated)
                             results.push(updated);
@@ -327,7 +346,10 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
                 }
                 batch.deferPostCommitNotification(() => input.core.notifyDurableTaskBatchCommitted(input.workspaceId, results.map((task) => task.id)));
                 return { preview, results, errors };
-            }, { atomicRecovery: true, allowIndependentNestedOwnership: true });
+            }, {
+                atomicRecovery: true,
+                allowIndependentNestedOwnership: true,
+            });
         },
     };
 }

package/dist/sync/v3/durableTaskHttpRootMutationRouter.d.ts

@@ -3,7 +3,8 @@ import type { TaskRestoreDestination } from '../../shared/taskRestoreDestination
 export declare class DurableTaskHttpRootMutationError extends Error {
     readonly code: string;
     readonly statusCode: number;
-    constructor(message: string, code: string, statusCode: number);
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, statusCode: number, details?: Record<string, unknown> | undefined);
 }
 export declare function resolveTaskHttpRootMutationCapability(input: {
     runtimeMode: 'local' | 'cloud';
@@ -22,8 +23,9 @@ export declare function createDurableTaskHttpRootMutationRouter(input: {
     deferPostCommitNotification?: (notify: () => void) => void;
 }): {
     enabled: boolean;
+    hasCommittedOperation(): boolean;
     create(candidate: unknown): TaskItem;
-    update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed"): TaskItem;
+    update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed", expectedDetailRevision?: string): TaskItem;
     runBatch<T>(routeInput: string, request: unknown, apply: (context: {
         runChild<R>(mutation: () => R): R;
         deferPostCommitNotification(notify: () => void): void;
@@ -36,5 +38,5 @@ export declare function createDurableTaskHttpRootMutationRouter(input: {
     restore(deletedRecordIdInput: string, restoreDestination?: TaskRestoreDestination): TaskItem;
     delete(taskIdInput: string): DeletedTaskRecord;
 };
-type TaskforceCoreForHttpRootMutation = Pick<import('../../core/Taskforce.js').TaskforceCore, 'getDatabaseAdapter' | 'getTask' | 'listAssignableActors' | 'getDeletedTask' | 'updateTask' | 'hasTaskDeletionMarkerForSync' | 'createTask' | 'listTaskAttachmentLinksForDurableSync' | 'resolveTaskAttachmentLinksForDurableSync' | 'normalizeTaskAttachmentDescriptorsForDurableSync' | 'notifyDurableTaskCreateCommitted' | 'notifyDurableTaskBatchCommitted' | 'notifyDurableTaskMetadataCommitted' | 'notifyDurableTaskLifecycleCommitted' | 'notifyDurableTaskDeleteCommitted' | 'getTaskEventForSync' | 'getEntityEventForSync' | 'lockTaskLifecycleMutationDomain' | 'archiveTask' | 'unarchiveTask' | 'restoreDeletedTask' | 'addTaskStatusEventsForDurableSync' | 'lockTaskRelationshipMutationDomain' | 'listTaskRelationships' | 'getTaskRelationshipForSync' | 'deleteTaskForSync'>;
+type TaskforceCoreForHttpRootMutation = Pick<import('../../core/Taskforce.js').TaskforceCore, 'getDatabaseAdapter' | 'getTask' | 'getTaskDetailRevision' | 'assertTaskDetailRevisionForUpdate' | 'listAssignableActors' | 'getDeletedTask' | 'updateTask' | 'hasTaskDeletionMarkerForSync' | 'createTask' | 'listTaskAttachmentLinksForDurableSync' | 'resolveTaskAttachmentLinksForDurableSync' | 'normalizeTaskAttachmentDescriptorsForDurableSync' | 'notifyDurableTaskCreateCommitted' | 'notifyDurableTaskBatchCommitted' | 'notifyDurableTaskMetadataCommitted' | 'notifyDurableTaskLifecycleCommitted' | 'notifyDurableTaskDeleteCommitted' | 'getTaskEventForSync' | 'getEntityEventForSync' | 'lockTaskLifecycleMutationDomain' | 'archiveTask' | 'unarchiveTask' | 'restoreDeletedTask' | 'addTaskStatusEventsForDurableSync' | 'addTaskCommentEventForDurableSync' | 'lockTaskRelationshipMutationDomain' | 'listTaskRelationships' | 'getTaskRelationshipForSync' | 'deleteTaskForSync'>;
 export {};

package/dist/sync/v3/durableTaskHttpRootMutationRouter.js

@@ -2,6 +2,7 @@ import { selectDurableTaskMetadataPatch } from '../../core/TaskDurableSyncMutati
 import { prepareTaskDeleteForDurableSync } from '../../core/TaskDurableDeleteMutationService.js';
 import { selectTaskCreateActivationInput } from './taskCreateActivation.js';
 import { resolveTaskAttachmentLinksMutationCapability } from './durableTaskAttachmentLinksMutationRouter.js';
+import { areWorkflowRuntimeMutationsFenced, resolveWorkflowRuntimeDurableTransportCapability, } from './durableWorkflowRuntimeMutationRouter.js';
 import { runDurableTaskCreate } from './taskCreateMutationService.js';
 import { runDurableTaskDelete } from './taskDeleteMutationService.js';
 import { runDurableTaskLifecycleMutation } from './taskLifecycleMutationService.js';
@@ -28,10 +29,12 @@ function requiredText(value, label) {
 export class DurableTaskHttpRootMutationError extends Error {
     code;
     statusCode;
-    constructor(message, code, statusCode) {
+    details;
+    constructor(message, code, statusCode, details) {
         super(message);
         this.code = code;
         this.statusCode = statusCode;
+        this.details = details;
         this.name = 'DurableTaskHttpRootMutationError';
     }
 }
@@ -57,6 +60,13 @@ export function createDurableTaskHttpRootMutationRouter(input) {
         surface: 'http',
         env: input.env,
     });
+    const workflowRuntimeJournalEnabled = resolveWorkflowRuntimeDurableTransportCapability({
+        runtimeMode: input.runtimeMode,
+        surface: 'http',
+        env: input.env,
+    });
+    const rejectWorkflowRuntimeActivation = workflowRuntimeJournalEnabled
+        && areWorkflowRuntimeMutationsFenced(input.env);
     const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
     const now = input.now || (() => new Date());
     const notificationMethods = new Set([
@@ -120,6 +130,11 @@ export function createDurableTaskHttpRootMutationRouter(input) {
             rethrowDurableReplayError(error, 'Committed durable task HTTP response is invalid.');
         }
     };
+    const detailRevisionPrecondition = (taskId, expectedDetailRevision) => {
+        if (!expectedDetailRevision)
+            return undefined;
+        return () => input.core.assertTaskDetailRevisionForUpdate(taskId, expectedDetailRevision, input.workspaceId);
+    };
     const lifecycle = (taskIdInput, mutationKind, payload) => {
         const taskId = requiredText(taskIdInput, 'Task id');
         const operation = context();
@@ -144,6 +159,12 @@ export function createDurableTaskHttpRootMutationRouter(input) {
     };
     return {
         enabled,
+        hasCommittedOperation() {
+            const operationId = String(input.operationId || '').trim();
+            if (!operationId)
+                return false;
+            return Boolean(store.readCommittedOperationResponse(operationIdentity(operationId)));
+        },
         create(candidate) {
             const source = candidate && typeof candidate === 'object' && !Array.isArray(candidate)
                 ? candidate
@@ -183,7 +204,7 @@ export function createDurableTaskHttpRootMutationRouter(input) {
                 throw new DurableTaskHttpRootMutationError('The durable task mutation is already in progress.', 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS', 409);
             return result.response.authoritative.payload;
         },
-        update(taskIdInput, candidate, saveSource, activityAction) {
+        update(taskIdInput, candidate, saveSource, activityAction, expectedDetailRevision) {
             const taskId = requiredText(taskIdInput, 'Task id');
             if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
                 throw new DurableTaskHttpRootMutationError('Task patch must be an object.', 'DURABLE_TASK_PATCH_INVALID', 400);
@@ -224,6 +245,10 @@ export function createDurableTaskHttpRootMutationRouter(input) {
                     now: operation.acceptedAtIso,
                     leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
                     actorRef: input.actorRef,
+                    includeWorkflowRuntimeJournal: workflowRuntimeJournalEnabled,
+                    rejectWorkflowRuntimeActivation,
+                    expectedDetailRevision,
+                    assertPrecondition: detailRevisionPrecondition(taskId, expectedDetailRevision),
                     onPostCommitError: input.onPostCommitError,
                 });
                 if (result.state === 'in_progress')
@@ -283,6 +308,8 @@ export function createDurableTaskHttpRootMutationRouter(input) {
                     actorRef: input.actorRef,
                     saveSource,
                     activityAction,
+                    expectedDetailRevision,
+                    assertPrecondition: detailRevisionPrecondition(taskId, expectedDetailRevision),
                     onPostCommitError: input.onPostCommitError,
                 });
                 if (result.state === 'in_progress')
@@ -341,6 +368,14 @@ export function createDurableTaskHttpRootMutationRouter(input) {
             if (options?.atomicRecovery) {
                 const notifications = [];
                 const result = input.core.getDatabaseAdapter().transaction(() => {
+                    // Child durable mutations lock the workspace sequence before
+                    // touching task rows. Take the same lock first when a batch
+                    // may combine a legacy root write with durable child owners.
+                    store.lockWorkspaceSequenceForMutation({
+                        tenantId: input.tenantId,
+                        workspaceId: input.workspaceId,
+                        now: operation.acceptedAtIso,
+                    });
                     const value = apply({
                         runChild: (mutation) => input.core.getDatabaseAdapter().transaction(mutation)(),
                         deferPostCommitNotification: (notify) => notifications.push(notify),

package/dist/sync/v3/durableTaxonomyMutationRouter.js

@@ -185,6 +185,11 @@ export function createDurableTaxonomyMutationRouter(input) {
             if (!sameTaxonomyState(storedPayload.state, canonicalState) || !Array.isArray(storedPayload.taskPatches)) {
                 throw new WorkspaceSyncIdempotencyConflictError();
             }
+            store.assertOutboxOperationIdentity(existingOutbox, {
+                domain: WORKSPACE_SYNC_TAXONOMY_DOMAIN,
+                entityId: WORKSPACE_SYNC_TAXONOMY_ENTITY_ID,
+                mutationKind: WORKSPACE_SYNC_TAXONOMY_REPLACE_WITH_REMAPS,
+            });
             enqueueLocalTaxonomyCompositeReplacement({
                 store,
                 core: input.core,

package/dist/sync/v3/durableWorkflowRuntimeMutationRouter.d.ts

@@ -15,11 +15,22 @@ export declare class DurableWorkflowRuntimeRouterInProgressError extends Error {
     readonly statusCode = 409;
     constructor(retryAt: string);
 }
+export declare class DurableWorkflowRuntimeExecutionNotFoundError extends Error {
+    readonly code = "execution_not_found";
+    readonly statusCode = 404;
+    constructor();
+}
+export declare function areWorkflowRuntimeMutationsFenced(env?: NodeJS.ProcessEnv): boolean;
 export declare function resolveWorkflowRuntimeMutationCapability(input: {
     runtimeMode: 'local' | 'cloud';
     surface: DurableWorkflowRuntimeSurface;
     env?: NodeJS.ProcessEnv;
 }): boolean;
+export declare function resolveWorkflowRuntimeDurableTransportCapability(input: {
+    runtimeMode: 'local' | 'cloud';
+    surface: DurableWorkflowRuntimeSurface;
+    env?: NodeJS.ProcessEnv;
+}): boolean;
 export declare function createDurableWorkflowRuntimeMutationRouter(input: {
     core: DurableWorkflowRuntimeMutationRouterCore;
     runtimeMode: 'local' | 'cloud';

package/dist/sync/v3/durableWorkflowRuntimeMutationRouter.js

@@ -7,6 +7,7 @@ import { WorkspaceSyncDurabilityStore, } from './syncDurabilityStore.js';
 import { runDurableWorkflowRuntimeMutation, } from './workflowRuntimeMutationService.js';
 import { validateWorkflowRuntimeAuthoritativeResult, validateWorkflowRuntimeMutationCommand, } from './workflowRuntimeSync.js';
 import { WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR } from './workspaceSyncV3WorkflowWireContract.js';
+import { WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR, } from './workspaceSyncV3WorkflowTaskCoverWireContract.js';
 const OPERATION_LEASE_MS = 30_000;
 export class DurableWorkflowRuntimeRouterDisabledError extends Error {
     code = 'WORKSPACE_SYNC_V3_WORKFLOW_RUNTIME_ROUTER_DISABLED';
@@ -26,31 +27,55 @@ export class DurableWorkflowRuntimeRouterInProgressError extends Error {
         this.name = 'DurableWorkflowRuntimeRouterInProgressError';
     }
 }
+export class DurableWorkflowRuntimeExecutionNotFoundError extends Error {
+    code = 'execution_not_found';
+    statusCode = 404;
+    constructor() {
+        super('Workflow execution not found.');
+        this.name = 'DurableWorkflowRuntimeExecutionNotFoundError';
+    }
+}
+export function areWorkflowRuntimeMutationsFenced(env = process.env) {
+    return String(env.TASKFORCE_SYNC_V3_WORKFLOW_RUNTIME_MUTATIONS_FENCED || '')
+        .trim()
+        .toLowerCase() === 'true';
+}
 function required(value, label) {
     const normalized = String(value || '').trim();
     if (!normalized)
         throw new Error(`${label} is required.`);
     return normalized;
 }
-function isWorkflowCoverageSelected(env) {
+const WORKFLOW_RUNTIME_COVERAGE_SELECTORS = [
+    WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR,
+    WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR,
+];
+function resolveSelectedWorkflowCoverage(env) {
     try {
         const coverage = resolveRequestedCombinedFeedCoverage(env);
-        return coverage.coverageProfileId === WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR.coverageProfileId
-            && coverage.coverageVersion === WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR.coverageVersion
-            && coverage.coverageDigest === WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR.coverageDigest;
+        return WORKFLOW_RUNTIME_COVERAGE_SELECTORS.find((candidate) => (coverage.coverageProfileId === candidate.coverageProfileId
+            && coverage.coverageVersion === candidate.coverageVersion
+            && coverage.coverageDigest === candidate.coverageDigest)) || null;
     }
     catch {
-        return false;
+        return null;
     }
 }
 export function resolveWorkflowRuntimeMutationCapability(input) {
     const env = input.env || process.env;
-    if (!isWorkflowCoverageSelected(env))
+    if (areWorkflowRuntimeMutationsFenced(env))
+        return false;
+    return resolveWorkflowRuntimeDurableTransportCapability(input);
+}
+export function resolveWorkflowRuntimeDurableTransportCapability(input) {
+    const env = input.env || process.env;
+    const coverage = resolveSelectedWorkflowCoverage(env);
+    if (!coverage)
         return false;
     const capability = resolveCombinedFeedCapability({
         runtimeMode: input.runtimeMode,
         env,
-        coverage: WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR,
+        coverage,
     }).combinedFeed;
     return capability.activationReady;
 }
@@ -62,7 +87,11 @@ function parseExistingLocalCommand(store, identity) {
         throw new Error('Operation identity is assigned to another local mutation.');
     }
     try {
-        return validateWorkflowRuntimeMutationCommand(JSON.parse(existing.payloadJson));
+        const command = validateWorkflowRuntimeMutationCommand(JSON.parse(existing.payloadJson));
+        store.assertOutboxOperationIdentity(existing, {
+            domain: 'workflow-execution', entityId: command.executionId, mutationKind: command.kind,
+        });
+        return command;
     }
     catch {
         throw new Error('Captured workflow runtime command is invalid.');
@@ -254,7 +283,7 @@ export function createDurableWorkflowRuntimeMutationRouter(input) {
             const workflowStore = new WorkflowStore(input.core.getDatabaseAdapter(), tenantId);
             const snapshot = workflowStore.getExecutionStateSnapshot(workspaceId, args.executionId);
             if (!snapshot)
-                throw new Error('Workflow execution not found.');
+                throw new DurableWorkflowRuntimeExecutionNotFoundError();
             const committed = readCommittedCloudResponse();
             if (committed) {
                 const event = snapshot.events.find((candidate) => candidate.idempotencyKey === operationId);
@@ -307,7 +336,7 @@ export function createDurableWorkflowRuntimeMutationRouter(input) {
             const workflowStore = new WorkflowStore(input.core.getDatabaseAdapter(), tenantId);
             const snapshot = workflowStore.getExecutionStateSnapshot(workspaceId, args.executionId);
             if (!snapshot)
-                throw new Error('Workflow execution not found.');
+                throw new DurableWorkflowRuntimeExecutionNotFoundError();
             const committed = readCommittedCloudResponse();
             if (committed) {
                 const completedEvent = snapshot.events.find((event) => event.idempotencyKey === `${operationId}:step-completed`);

package/dist/sync/v3/durableWorkstreamMutationRouter.js

@@ -7,6 +7,7 @@ import { enqueueLocalWorkstreamMutation, } from './localWorkstreamOutboxService.
 import { isWorkspaceSyncV3PlanningActivationEnabled } from './planningActivation.js';
 import { serializeEntityActivityForSync } from './taskActivityJournal.js';
 import { WorkspaceSyncDurabilityStore, WorkspaceSyncIdempotencyConflictError } from './syncDurabilityStore.js';
+import { readDurableOperationReplay } from './durableOperationReplay.js';
 import { buildWorkstreamActivityEventId } from './workstreamActivityIdentity.js';
 const OPERATION_LEASE_MS = 30_000;
 export class DurableWorkstreamMutationRouterDisabledError extends Error {
@@ -85,6 +86,9 @@ export function createDurableWorkstreamMutationRouter(input) {
                 if (persistedOutbox.domain !== 'workstream' || persistedOutbox.entityId !== workstreamId) {
                     throw new WorkspaceSyncIdempotencyConflictError();
                 }
+                store.assertOutboxOperationIdentity(persistedOutbox, {
+                    domain: 'workstream', entityId: workstreamId, mutationKind: persistedOutbox.mutationKind,
+                });
                 return {
                     revisions: {
                         entityRevision: persistedOutbox.baseEntityRevision,
@@ -99,18 +103,22 @@ export function createDurableWorkstreamMutationRouter(input) {
             if (operationState?.status === 'committed') {
                 if (!operationState.responseJson)
                     throw new Error('Committed operation is missing its response.');
-                const response = JSON.parse(operationState.responseJson);
-                if (response.authoritative.entityId !== workstreamId) {
-                    throw new WorkspaceSyncIdempotencyConflictError();
-                }
-                const lifecycleMutation = response.authoritative.mutationKind === 'archive'
-                    || response.authoritative.mutationKind === 'unarchive';
+                const parsed = JSON.parse(operationState.responseJson);
+                const lifecycleMutation = parsed.authoritative.mutationKind === 'archive'
+                    || parsed.authoritative.mutationKind === 'unarchive';
+                const replay = readDurableOperationReplay({
+                    responseJson: operationState.responseJson,
+                    operationId,
+                    domain: 'workstream',
+                    entityId: workstreamId,
+                    mutationKind: parsed.authoritative.mutationKind,
+                    revisionMode: lifecycleMutation ? 'both' : 'metadata',
+                });
+                const response = replay.response;
                 return {
                     revisions: {
-                        entityRevision: String(BigInt(response.authoritative.entityRevision) - 1n),
-                        lifecycleRevision: lifecycleMutation
-                            ? String(BigInt(response.authoritative.lifecycleRevision) - 1n)
-                            : response.authoritative.lifecycleRevision,
+                        entityRevision: replay.baseEntityRevision,
+                        lifecycleRevision: replay.baseLifecycleRevision,
                     },
                     persistedOutbox: null,
                     committedResponse: response,