@taskforcehq/taskforce 0.3.329 → 0.3.332

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

@@ -1,5 +1,5 @@
 import type { WorkflowExecutionAction, WorkflowStepCompletionActorType } from '../../core/WorkflowExecutionService.js';
-import { type WorkflowExecutionStatus } from '../../storage/workflowStore.js';
+import { type WorkflowExecutionEventRecord, type WorkflowExecutionStatus } from '../../storage/workflowStore.js';
 import { type LocalWorkflowRuntimeOutboxCore } from './localWorkflowRuntimeOutboxService.js';
 import { type DurableWorkflowRuntimeServiceCore } from './workflowRuntimeMutationService.js';
 export type DurableWorkflowRuntimeSurface = 'http' | 'mcp';
@@ -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';
@@ -42,11 +53,11 @@ export declare function createDurableWorkflowRuntimeMutationRouter(input: {
         details?: Record<string, unknown>;
     }): {
         state: "pending" | "committed";
-        route: "local-outbox" | "cloud-acceptance";
+        route: "local-outbox" | "cloud-acceptance" | "local-projection-replay";
         operationId: string;
         execution: import("../../storage/workflowStore.js").WorkflowExecutionRecord;
-        events: import("../../storage/workflowStore.js").WorkflowExecutionEventRecord[];
-        event: import("../../storage/workflowStore.js").WorkflowExecutionEventRecord | null;
+        events: WorkflowExecutionEventRecord[];
+        event: WorkflowExecutionEventRecord | null;
         completedStep: import("../../storage/workflowStore.js").WorkflowStepRecord | null;
         nextStep: import("../../storage/workflowStore.js").WorkflowStepRecord | null;
         taskAssignee: string | null;
@@ -61,11 +72,11 @@ export declare function createDurableWorkflowRuntimeMutationRouter(input: {
         evidenceCommentId?: string;
     }): {
         state: "pending" | "committed";
-        route: "local-outbox" | "cloud-acceptance";
+        route: "local-outbox" | "cloud-acceptance" | "local-projection-replay";
         operationId: string;
         execution: import("../../storage/workflowStore.js").WorkflowExecutionRecord;
-        events: import("../../storage/workflowStore.js").WorkflowExecutionEventRecord[];
-        event: import("../../storage/workflowStore.js").WorkflowExecutionEventRecord | null;
+        events: WorkflowExecutionEventRecord[];
+        event: WorkflowExecutionEventRecord | null;
         completedStep: import("../../storage/workflowStore.js").WorkflowStepRecord | null;
         nextStep: import("../../storage/workflowStore.js").WorkflowStepRecord | null;
         taskAssignee: string | null;

package/dist/sync/v3/durableWorkflowRuntimeMutationRouter.js

@@ -1,4 +1,4 @@
-import { WorkflowStore } from '../../storage/workflowStore.js';
+import { WorkflowStore, } from '../../storage/workflowStore.js';
 import { LocalSyncIdentityStore } from './localSyncIdentityStore.js';
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 import { enqueueLocalWorkflowRuntimeMutation, } from './localWorkflowRuntimeOutboxService.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.');
@@ -81,6 +110,31 @@ function taskTarget(input) {
         baseLifecycleRevision: coordinates.lifecycleRevision,
     };
 }
+function matchCompletedStepReplay(input) {
+    const completedEvent = input.events.find((event) => event.idempotencyKey === `${input.operationId}:step-completed`);
+    const terminalEvent = input.events.find((event) => (event.idempotencyKey === `${input.operationId}:step-started`
+        || event.idempotencyKey === `${input.operationId}:execution-completed`));
+    if (!completedEvent && !terminalEvent)
+        return 'absent';
+    if (!completedEvent
+        || !terminalEvent
+        || completedEvent.eventType !== 'step-completed'
+        || (terminalEvent.eventType !== 'step-started'
+            && terminalEvent.eventType !== 'execution-completed')
+        || completedEvent.actorId !== input.actorId
+        || terminalEvent.actorId !== input.actorId
+        || (input.expectedStepId !== undefined && completedEvent.stepId !== input.expectedStepId)) {
+        return 'conflict';
+    }
+    const evidence = completedEvent.details.evidence;
+    const replayCommentId = evidence
+        && typeof evidence === 'object'
+        && !Array.isArray(evidence)
+        && evidence.type === 'comment'
+        ? String(evidence.commentId || '')
+        : '';
+    return (input.evidenceCommentId || '') === replayCommentId ? 'exact' : 'conflict';
+}
 function buildResult(input) {
     const workflowStore = new WorkflowStore(input.core.getDatabaseAdapter(), input.core.getTenantId());
     const assignmentSnapshot = workflowStore.getAssignmentForExecutionSync(input.workspaceId, input.executionId);
@@ -91,7 +145,8 @@ function buildResult(input) {
     const completedStep = completedEvent?.stepId
         ? assignmentSnapshot.steps.find((step) => step.id === completedEvent.stepId) || null
         : null;
-    const nextStep = assignmentSnapshot.execution.currentStepId
+    const nextStep = assignmentSnapshot.execution.status === 'running'
+        && assignmentSnapshot.execution.currentStepId
         ? assignmentSnapshot.steps.find((step) => step.id === assignmentSnapshot.execution.currentStepId) || null
         : null;
     const taskSnapshot = input.core.getTask(assignmentSnapshot.execution.taskId, input.workspaceId);
@@ -254,7 +309,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,20 +362,17 @@ 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();
+            const replayMatch = matchCompletedStepReplay({
+                events: snapshot.events,
+                operationId,
+                actorId,
+                expectedStepId: args.expectedStepId,
+                evidenceCommentId: args.evidenceCommentId,
+            });
             if (committed) {
-                const completedEvent = snapshot.events.find((event) => event.idempotencyKey === `${operationId}:step-completed`);
-                const terminalEvent = snapshot.events.find((event) => (event.idempotencyKey === `${operationId}:step-started`
-                    || event.idempotencyKey === `${operationId}:execution-completed`));
-                if (!completedEvent
-                    || !terminalEvent
-                    || completedEvent.actorId !== actorId
-                    || terminalEvent.actorId !== actorId
-                    || (args.expectedStepId !== undefined && completedEvent.stepId !== args.expectedStepId)
-                    || (args.evidenceCommentId !== undefined
-                        && completedEvent.details.evidence?.commentId
-                            !== args.evidenceCommentId)) {
+                if (replayMatch !== 'exact') {
                     throw new Error('Operation identity is assigned to a different workflow step command.');
                 }
                 return buildResult({
@@ -334,6 +386,20 @@ export function createDurableWorkflowRuntimeMutationRouter(input) {
                     replayed: true,
                 });
             }
+            if (!existing && replayMatch !== 'absent') {
+                if (replayMatch === 'conflict') {
+                    throw new Error('Operation identity is assigned to a different workflow step command.');
+                }
+                return buildResult({
+                    core: input.core,
+                    workspaceId,
+                    executionId: args.executionId,
+                    operationId,
+                    state: 'committed',
+                    route: 'local-projection-replay',
+                    replayed: true,
+                });
+            }
             const expectedStepId = args.expectedStepId || snapshot.execution.currentStepId;
             if (!expectedStepId)
                 throw new Error('Workflow execution current step is unavailable.');

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/localOutboxRecoveryPreparationService.js

@@ -43,11 +43,14 @@ function appendEligibleBlockedChains(input) {
         workspaceId: input.workspaceId,
     })) {
         try {
+            const blocked = input.store.readOutboxOperation(identity);
             input.store.supersedeBlockedOutboxChain({
                 identity,
                 recoveryBatchId: input.recovery.recoveryBatchId,
                 now: input.now,
-                replayPolicy: 'task-root',
+                replayPolicy: blocked?.lastErrorCode === 'WORKFLOW_RUNTIME_SEMANTIC_REPLAY_REQUIRED'
+                    ? 'authoritative-workflow-runtime'
+                    : 'task-root',
                 appendToExistingRecovery: true,
             });
         }
@@ -104,11 +107,14 @@ export function prepareLocalOutboxRecovery(input) {
     for (const root of blockedRoots) {
         const candidateBatchId = input.createRecoveryBatchId();
         try {
+            const blocked = input.store.readOutboxOperation(root);
             input.store.supersedeBlockedOutboxChain({
                 identity: root,
                 recoveryBatchId: candidateBatchId,
                 now: input.now,
-                replayPolicy: 'task-root',
+                replayPolicy: blocked?.lastErrorCode === 'WORKFLOW_RUNTIME_SEMANTIC_REPLAY_REQUIRED'
+                    ? 'authoritative-workflow-runtime'
+                    : 'task-root',
             });
             recoveryBatchId = candidateBatchId;
             break;

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/localTaskCreateOutboxService.d.ts

@@ -16,7 +16,9 @@ export interface LocalTaskCreateOutboxCore {
         allowV3OwnedCreate?: boolean;
         preferExplicitAttachmentAssetId?: boolean;
     }): TaskItem;
-    installDurableTaskCreateAuthoritativeForSync(task: TaskItem, workspaceId: string): TaskItem;
+    installDurableTaskCreateAuthoritativeForSync(task: TaskItem, workspaceId: string, options?: {
+        preserveDeletedSuccessor?: boolean;
+    }): TaskItem;
     upsertEntityEventForSync(event: EntityEvent, options?: {
         allowAuthoritativeReplacement?: boolean;
     }): unknown;

package/dist/sync/v3/localTaskCreateOutboxService.js

@@ -356,10 +356,15 @@ export function applyAuthoritativeTaskCreateAndAck(input) {
                 canonicalFingerprint: fingerprintWorkspaceSyncPayload(canonicalDependentActivities[index]),
             }))],
         applyAuthoritative: () => {
+            const hasDeletedSuccessor = input.store.listActiveOutboxSuccessors(input.identity).some((successor) => (successor.domain === 'task'
+                && successor.entityId === task.id
+                && successor.mutationKind === 'delete'));
             const updated = input.core.installDurableTaskCreateAuthoritativeForSync({
                 ...task,
                 localReferenceNumber: null,
-            }, input.identity.workspaceId);
+            }, input.identity.workspaceId, {
+                preserveDeletedSuccessor: hasDeletedSuccessor,
+            });
             const installedWithAttachments = canonicalAttachmentProjection
                 ? input.core.updateTask(task.id, {
                     attachments: input.core.resolveTaskAttachmentLinksForDurableSync(canonicalAttachmentProjection.links, input.identity.workspaceId, { adoptAuthoritativeReferenceNumber: true }),

package/dist/sync/v3/localTaskDeleteOutboxService.js

@@ -99,6 +99,7 @@ export function enqueueLocalTaskDeleteMutation(input) {
                 entityId: taskId,
                 mutationKind: 'delete',
                 revisionSource: 'current',
+                queuedTaskSuccessor: true,
                 ownership: { taskMetadata: true, taskLifecycle: true },
                 payload: { relationships },
                 now: input.now,

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

@@ -1,4 +1,4 @@
-import type { TaskEvent, TaskItem } from '../../core/Taskforce.js';
+import type { DeletedTaskRecord, TaskEvent, TaskItem } from '../../core/Taskforce.js';
 import { type DurableTaskLifecycleMutationCore, type DurableTaskLifecycleMutationKind } from '../../core/TaskDurableLifecycleMutationService.js';
 import { type DurableTaskWorkflowMutationCore, type DurableTaskWorkflowMutationKind } from '../../core/TaskDurableWorkflowMutationService.js';
 import { WorkspaceSyncDurabilityStore, type WorkspaceSyncOperationIdentity, type WorkspaceSyncOutboxRecord } from './syncDurabilityStore.js';
@@ -16,6 +16,7 @@ export declare function normalizeLocalTaskLifecyclePayload(mutationKind: LocalTa
     };
 };
 export interface LocalTaskLifecycleOutboxCore extends DurableTaskLifecycleMutationCore, DurableTaskWorkflowMutationCore {
+    getDeletedTask(id: string, workspaceId?: string): DeletedTaskRecord | null;
     installDurableTaskLifecycleAuthoritativeForSync(task: TaskItem, mutationKind: LocalTaskLifecycleMutationKind, workspaceId: string): TaskItem;
     upsertEntityEventForSync(event: TaskEvent, options?: {
         allowAuthoritativeReplacement?: boolean;

package/dist/sync/v3/localTaskLifecycleOutboxService.js

@@ -276,9 +276,13 @@ export function applyAuthoritativeTaskLifecycleAndAck(input) {
                     canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskActivityForSync(activity)),
                 }] : [])],
         applyAuthoritative: () => {
-            const hasSuccessor = input.store.hasActiveOutboxSuccessor(input.identity);
+            const successors = input.store.listActiveOutboxSuccessors(input.identity);
+            const hasSuccessor = successors.length > 0;
             const updated = hasSuccessor
                 ? input.core.getTask(task.id, input.identity.workspaceId)
+                    || (successors.some((successor) => successor.mutationKind === 'delete')
+                        ? input.core.getDeletedTask(task.id, input.identity.workspaceId)?.taskSnapshot
+                        : null)
                 : input.core.installDurableTaskLifecycleAuthoritativeForSync(task, input.mutationKind, input.identity.workspaceId);
             if (!updated)
                 throw new LocalAuthoritativeTaskLifecycleError('Local task lifecycle projection is missing.');

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

@@ -1,7 +1,8 @@
-import type { EntityEvent, TaskItem } from '../../core/Taskforce.js';
+import type { DeletedTaskRecord, EntityEvent, TaskItem } from '../../core/Taskforce.js';
 import { WorkspaceSyncDurabilityStore, type WorkspaceSyncOperationIdentity } from './syncDurabilityStore.js';
 export interface LocalTaskMetadataOutboxCore {
     getTask(id: string, workspaceId?: string): TaskItem | null | undefined;
+    getDeletedTask(id: string, workspaceId?: string): DeletedTaskRecord | null;
     updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
         persistBackup?: boolean;
         emitRealtime?: boolean;

package/dist/sync/v3/localTaskMetadataOutboxService.js

@@ -196,8 +196,12 @@ export function applyAuthoritativeTaskMetadataAndAck(input) {
             for (const dependentActivity of canonicalDependentActivities) {
                 input.core.upsertEntityEventForSync(dependentActivity, { allowAuthoritativeReplacement: true });
             }
-            if (input.store.hasActiveOutboxSuccessor(input.identity)) {
-                const provisional = input.core.getTask(taskId, input.identity.workspaceId);
+            const successors = input.store.listActiveOutboxSuccessors(input.identity);
+            if (successors.length > 0) {
+                const provisional = input.core.getTask(taskId, input.identity.workspaceId)
+                    || (successors.some((successor) => successor.mutationKind === 'delete')
+                        ? input.core.getDeletedTask(taskId, input.identity.workspaceId)?.taskSnapshot
+                        : null);
                 if (!provisional)
                     throw new DurableTaskMetadataMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
                 return provisional;

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

@@ -1,8 +1,9 @@
-import type { EntityEvent, TaskEvent, TaskItem } from '../../core/Taskforce.js';
+import type { DeletedTaskRecord, EntityEvent, TaskEvent, TaskItem } from '../../core/Taskforce.js';
 import { type DurableTaskStatusMutationCore, type DurableTaskStatusMutationPayload } from '../../core/TaskDurableStatusMutationService.js';
 import { WorkspaceSyncDurabilityStore, type WorkspaceSyncOperationIdentity, type WorkspaceSyncOutboxRecord } from './syncDurabilityStore.js';
 import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
 export interface LocalTaskStatusOutboxCore extends DurableTaskStatusMutationCore {
+    getDeletedTask(id: string, workspaceId?: string): DeletedTaskRecord | null;
     assertTaskDetailRevisionForUpdate?(id: string, expectedDetailRevision: string, workspaceId?: string): void;
     getDatabaseAdapter(): DatabaseAdapter;
     getTenantId(): string;
@@ -23,6 +24,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";