@taskforcehq/taskforce 0.3.329 → 0.3.330

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,27 +181,33 @@ 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,
@@ -180,7 +217,13 @@ export function createDurableTaskChecklistMutationRouter(input) {
             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/durableTaskHttpRootMutationRouter.d.ts

@@ -38,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' | 'getTaskDetailRevision' | 'assertTaskDetailRevisionForUpdate' | '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';
@@ -59,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([
@@ -237,6 +245,8 @@ 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,

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,

package/dist/sync/v3/durableWorkstreamTaskOrderMutationRouter.js

@@ -5,6 +5,7 @@ import { enqueueLocalWorkstreamTaskOrderReplacement } from './localWorkstreamTas
 import { DurableWorkstreamTaskOrderError, runDurableWorkstreamTaskOrderReplace, } from './workstreamTaskOrderMutationService.js';
 import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
 import { serializeWorkstreamTaskOrderForSync } from './workstreamTaskOrderSync.js';
+import { readDurableOperationReplay } from './durableOperationReplay.js';
 const OPERATION_LEASE_MS = 30_000;
 function enabled(value) {
     return /^(1|true|on|yes)$/i.test(String(value || '').trim());
@@ -68,6 +69,9 @@ export function createDurableWorkstreamTaskOrderMutationRouter(input) {
                         || canonicalWorkspaceSyncJson(prior.taskIds || []) !== canonicalWorkspaceSyncJson(payload.taskIds)) {
                         throw new DurableWorkstreamTaskOrderError('Operation identity is assigned to a different workstream task order.', 'WORKSTREAM_TASK_ORDER_IDENTITY_CONFLICT', 409);
                     }
+                    store.assertOutboxOperationIdentity(existing, {
+                        domain: 'workstream-task-order', entityId: payload.workstreamId, mutationKind: 'replace',
+                    });
                     return { state: 'pending', route: 'local-outbox', operationId,
                         taskIds: input.core.getWorkstreamTaskOrderForSync(payload.workstreamId, input.workspaceId) };
                 }
@@ -85,14 +89,21 @@ export function createDurableWorkstreamTaskOrderMutationRouter(input) {
             }
             const committed = store.readCommittedOperationResponse(identity);
             if (committed) {
-                const response = JSON.parse(committed);
-                if (response.authoritative?.entityId !== payload.workstreamId
-                    || canonicalWorkspaceSyncJson(response.authoritative.payload.taskIds)
-                        !== canonicalWorkspaceSyncJson(payload.taskIds)) {
+                const replay = readDurableOperationReplay({
+                    responseJson: committed,
+                    operationId,
+                    domain: 'workstream-task-order',
+                    entityId: payload.workstreamId,
+                    mutationKind: 'replace',
+                    revisionMode: 'metadata',
+                    requirePayload: true,
+                });
+                if (canonicalWorkspaceSyncJson(replay.authoritative.payload?.taskIds)
+                    !== canonicalWorkspaceSyncJson(payload.taskIds)) {
                     throw new DurableWorkstreamTaskOrderError('Operation identity is assigned to a different workstream task order.', 'WORKSTREAM_TASK_ORDER_IDENTITY_CONFLICT', 409);
                 }
                 return { state: 'committed', route: 'cloud-acceptance', operationId,
-                    taskIds: response.authoritative.payload.taskIds };
+                    taskIds: replay.authoritative.payload.taskIds };
             }
             const coordinates = store.readEntityRevisionCoordinates({
                 tenantId: input.tenantId,

package/dist/sync/v3/localOutboxDispatchRuntime.js

@@ -20,7 +20,7 @@ import { serializeTaskRootForSync } from './workspaceSyncV3TaskRootProjection.js
 import { createLocalWorkflowRuntimeOutboxHandler } from './localWorkflowRuntimeOutboxHandler.js';
 import { createLocalWorkstreamOutboxHandler } from './localWorkstreamOutboxHandler.js';
 import { createLocalWorkstreamTaskOrderOutboxHandler } from './localWorkstreamTaskOrderOutboxHandler.js';
-import { resolveWorkflowRuntimeMutationCapability } from './durableWorkflowRuntimeMutationRouter.js';
+import { resolveWorkflowRuntimeDurableTransportCapability } from './durableWorkflowRuntimeMutationRouter.js';
 import { createLocalEntityEventLegacyAdoptionHandler, enqueueNextLegacyEntityEventAdoption, } from './localEntityEventLegacyAdoption.js';
 export function createLocalOutboxDispatchHandlers(input) {
     return [
@@ -40,7 +40,7 @@ export function createLocalOutboxDispatchHandlers(input) {
         createLocalInitiativeOutboxHandler(input),
         createLocalWorkstreamOutboxHandler(input),
         createLocalWorkstreamTaskOrderOutboxHandler(input),
-        ...(resolveWorkflowRuntimeMutationCapability({
+        ...(resolveWorkflowRuntimeDurableTransportCapability({
             runtimeMode: 'local',
             surface: 'http',
             env: input.env || process.env,

package/dist/sync/v3/localTaskChecklistOutboxHandler.js

@@ -2,6 +2,7 @@ import { EntityEventIdentityCollisionError } from '../../core/TaskActivityServic
 import { applyAuthoritativeTaskChecklistAndAck, LocalAuthoritativeTaskChecklistError, } from './localTaskChecklistOutboxService.js';
 import { fingerprintWorkspaceSyncPayload, WorkspaceSyncIdempotencyConflictError, WorkspaceSyncRevisionConflictError, } from './syncDurabilityStore.js';
 import { validateWorkspaceSyncV3TaskChecklistPayload } from './workspaceSyncV3NestedTaskCodecs.js';
+import { validateTaskChecklistItemUpdateIntent } from './taskChecklistMutationService.js';
 import { parseWorkspaceSyncV3OriginActor } from './workspaceSyncV3OriginActor.js';
 export function buildTaskChecklistEnvelope(record) {
     let payload;
@@ -17,9 +18,20 @@ export function buildTaskChecklistEnvelope(record) {
     }
     const source = payload;
     if (!Object.prototype.hasOwnProperty.call(source, 'items')
-        || Object.keys(source).some((key) => key !== 'items' && key !== 'originActor')) {
-        throw new Error('Local task checklist outbox payload must contain items and optional originActor.');
+        || Object.keys(source).some((key) => ![
+            'items', 'expectedDetailRevision', 'itemUpdateIntent', 'originActor',
+        ].includes(key))) {
+        throw new Error('Local task checklist outbox payload must contain items and optional expectedDetailRevision/originActor.');
     }
+    const expectedDetailRevision = source.expectedDetailRevision === undefined
+        ? undefined
+        : String(source.expectedDetailRevision).trim();
+    if (source.expectedDetailRevision !== undefined && !expectedDetailRevision) {
+        throw new Error('Local task checklist expectedDetailRevision is invalid.');
+    }
+    const itemUpdateIntent = source.itemUpdateIntent === undefined
+        ? undefined
+        : validateTaskChecklistItemUpdateIntent(source.itemUpdateIntent);
     const checklist = validateWorkspaceSyncV3TaskChecklistPayload({ taskId: record.entityId, items: source.items });
     return {
         contractVersion: 3,
@@ -31,6 +43,8 @@ export function buildTaskChecklistEnvelope(record) {
             baseEntityRevision: record.baseEntityRevision, baseLifecycleRevision: '0',
             payload: {
                 items: checklist.items,
+                ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
+                ...(itemUpdateIntent ? { itemUpdateIntent } : {}),
                 ...(source.originActor !== undefined
                     ? { originActor: parseWorkspaceSyncV3OriginActor(source.originActor) }
                     : {}),

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

@@ -1,4 +1,5 @@
 import type { ChecklistItem, TaskEvent, TaskItem } from '../../core/Taskforce.js';
+import { type TaskChecklistItemUpdateIntent } from './taskChecklistMutationService.js';
 import { WorkspaceSyncDurabilityStore, type WorkspaceSyncOperationIdentity } from './syncDurabilityStore.js';
 export interface LocalTaskChecklistOutboxCore {
     getTask(id: string, workspaceId?: string): TaskItem | null;
@@ -17,6 +18,7 @@ export interface LocalTaskChecklistOutboxCore {
         allowAuthoritativeReplacement?: boolean;
     }): unknown;
     notifyDurableTaskMetadataCommitted(workspaceId: string, taskId: string): void;
+    assertTaskDetailRevisionForUpdate?(id: string, expectedDetailRevision: string, workspaceId?: string): void;
 }
 export declare class LocalAuthoritativeTaskChecklistError extends Error {
     readonly code = "WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID";
@@ -30,6 +32,8 @@ export declare function enqueueLocalTaskChecklistMutation(input: {
     items: readonly Partial<ChecklistItem>[];
     now: string;
     actorRef: string;
+    expectedDetailRevision?: string;
+    itemUpdateIntent?: TaskChecklistItemUpdateIntent;
     requireV3CombinedOwnership?: boolean;
     onPostCommitError?: (error: unknown) => void;
 }): {

package/dist/sync/v3/localTaskChecklistOutboxService.js

@@ -1,5 +1,6 @@
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 import { buildTaskChecklistActivityEventId } from './taskChecklistActivityIdentity.js';
+import { DurableTaskChecklistMutationError, } from './taskChecklistMutationService.js';
 import { selectDurableTaskMetadataPatch } from '../../core/TaskDurableSyncMutationService.js';
 import { serializeTaskRootForSync } from './workspaceSyncV3TaskRootProjection.js';
 import { serializeTaskActivityForSync } from './taskActivityJournal.js';
@@ -48,7 +49,13 @@ export function enqueueLocalTaskChecklistMutation(input) {
     const result = input.store.enqueueLocalOperation({
         identity: input.identity,
         domain: 'task-checklist', entityId: input.taskId, mutationKind: 'replace',
-        revisionSource: 'current', payload: withOriginActorPayload({ items }, input.actorRef),
+        revisionSource: 'current', payload: withOriginActorPayload({
+            items,
+            ...(input.expectedDetailRevision
+                ? { expectedDetailRevision: input.expectedDetailRevision }
+                : {}),
+            ...(input.itemUpdateIntent ? { itemUpdateIntent: input.itemUpdateIntent } : {}),
+        }, input.actorRef),
         additionalTargets: [{
                 domain: 'task', entityId: input.taskId, mutationKind: 'metadata-update',
                 baseEntityRevision: rootRevision.entityRevision, baseLifecycleRevision: rootRevision.lifecycleRevision,
@@ -58,6 +65,12 @@ export function enqueueLocalTaskChecklistMutation(input) {
         ...(input.requireV3CombinedOwnership ? { requireV3PlanningOwnership: 'combined' } : {}),
         now: input.now,
         applyLocalMutation: () => {
+            if (input.expectedDetailRevision) {
+                if (!input.core.assertTaskDetailRevisionForUpdate) {
+                    throw new DurableTaskChecklistMutationError('Task detail revision checks are unavailable.', 'TASK_CHECKLIST_INVALID', 500);
+                }
+                input.core.assertTaskDetailRevisionForUpdate(input.taskId, input.expectedDetailRevision, input.identity.workspaceId);
+            }
             const existing = input.core.getTask(input.taskId, input.identity.workspaceId);
             if (!existing)
                 throw new LocalAuthoritativeTaskChecklistError('Task not found.');

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

@@ -23,6 +23,14 @@ export interface LocalTaskStatusOutboxCore extends DurableTaskStatusMutationCore
         activity: TaskEvent | null;
     }): boolean;
     notifyDurableTaskLifecycleCommitted(workspaceId: string, taskId: string): void;
+    addTaskCommentEventForDurableSync(event: {
+        taskId: string;
+        workspaceId: string;
+        actor: string;
+        eventId: string;
+        createdAt: string;
+        comment: NonNullable<TaskItem['comments']>[number];
+    }): void;
 }
 export declare class LocalAuthoritativeTaskStatusError extends Error {
     readonly code = "WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID";