@taskforcehq/taskforce 0.3.330 → 0.3.333

package/dist/sync/engine/workspaceSyncEnginePushCompletion.d.ts

@@ -19,10 +19,15 @@ export interface WorkspaceSyncEngineAppliedTaskUpsert {
 }
 export declare function workspaceSyncEngineExpectedTaskEchoIds(changes: readonly WorkspaceSyncChange[]): string[];
 export declare function parseWorkspaceSyncEngineAppliedTaskUpserts(value: unknown, expectedTaskIds: readonly string[]): WorkspaceSyncEngineAppliedTaskUpsert[];
+export declare function parseWorkspaceSyncEnginePushTaskSettlement(value: unknown, expectedTaskIds: readonly string[]): {
+    appliedTaskUpserts: WorkspaceSyncEngineAppliedTaskUpsert[];
+    settledTaskDeleteIds: string[];
+};
 export declare function createWorkspaceSyncEngineV2SettlementIdentityProjection(input: {
     operationIdentity: string;
     changes: readonly WorkspaceSyncChange[];
     appliedTaskUpserts: readonly WorkspaceSyncEngineAppliedTaskUpsert[];
+    settledTaskDeleteIds?: readonly string[];
     excludedProjections?: readonly WorkspaceSyncV2ProjectionExclusion[];
 }): {
     version: 1;
@@ -31,4 +36,5 @@ export declare function createWorkspaceSyncEngineV2SettlementIdentityProjection(
         archived: boolean;
         task: Record<string, unknown>;
     }>;
+    settledTaskDeleteIds?: string[];
 };

package/dist/sync/engine/workspaceSyncEnginePushCompletion.js

@@ -86,6 +86,28 @@ export function parseWorkspaceSyncEngineAppliedTaskUpserts(value, expectedTaskId
     }
     return normalized;
 }
+export function parseWorkspaceSyncEnginePushTaskSettlement(value, expectedTaskIds) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new TypeError('The V2 push authoritative echo response is invalid.');
+    }
+    const source = value;
+    const settledTaskDeleteIds = source.settledTaskDeleteIds === undefined
+        ? []
+        : source.settledTaskDeleteIds;
+    if (!Array.isArray(settledTaskDeleteIds)
+        || settledTaskDeleteIds.some((taskId) => (typeof taskId !== 'string'
+            || taskId.trim().length === 0
+            || taskId !== taskId.trim()))
+        || new Set(settledTaskDeleteIds).size !== settledTaskDeleteIds.length
+        || settledTaskDeleteIds.some((taskId) => !expectedTaskIds.includes(taskId))) {
+        throw new TypeError('The V2 push terminal task settlement identities are invalid.');
+    }
+    const settledIds = new Set(settledTaskDeleteIds);
+    return {
+        appliedTaskUpserts: parseWorkspaceSyncEngineAppliedTaskUpserts(value, expectedTaskIds.filter((taskId) => !settledIds.has(taskId))),
+        settledTaskDeleteIds: [...settledTaskDeleteIds],
+    };
+}
 function taskSettlementProjection(task, preserveReferenceNumber) {
     const { updatedAt: _updatedAt, ...stableTask } = structuredClone(task);
     if (!preserveReferenceNumber)
@@ -136,7 +158,17 @@ export function createWorkspaceSyncEngineV2SettlementIdentityProjection(input) {
     if (!operationIdentity || operationIdentity !== input.operationIdentity) {
         throw new TypeError('The V2 push settlement operation identity is invalid.');
     }
-    const expectedTaskUpserts = input.changes.filter((change) => change.op === 'upsert');
+    const allExpectedTaskUpserts = input.changes.filter((change) => change.op === 'upsert');
+    const expectedTaskIds = allExpectedTaskUpserts.map((change) => String(change.task.id || '').trim());
+    const settledTaskDeleteIds = [...(input.settledTaskDeleteIds || [])];
+    if ((settledTaskDeleteIds.length > 0
+        && !input.excludedProjections?.includes('task/root-v1'))
+        || settledTaskDeleteIds.some((taskId) => !expectedTaskIds.includes(taskId))
+        || new Set(settledTaskDeleteIds).size !== settledTaskDeleteIds.length) {
+        throw new TypeError('The V2 push terminal task settlement identities are invalid.');
+    }
+    const settledIds = new Set(settledTaskDeleteIds);
+    const expectedTaskUpserts = allExpectedTaskUpserts.filter((change) => !settledIds.has(String(change.task.id || '').trim()));
     if (expectedTaskUpserts.length !== input.appliedTaskUpserts.length) {
         throw new TypeError('The V2 push authoritative settlement projection is incomplete.');
     }
@@ -167,5 +199,6 @@ export function createWorkspaceSyncEngineV2SettlementIdentityProjection(input) {
         version: 1,
         operationIdentity,
         taskUpserts: expectedProjection,
+        ...(settledTaskDeleteIds.length > 0 ? { settledTaskDeleteIds } : {}),
     };
 }

package/dist/sync/engine/workspaceSyncEngineServerRemoteServices.js

@@ -2,7 +2,7 @@ import { workspaceSyncGatewayOperationClassFor, workspaceSyncGatewayTimeoutMs, }
 import { canonicalWorkspaceSyncJson } from '../v3/canonicalWorkspaceSyncJson.js';
 import { WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR, resolveWorkspaceSyncV3CombinedCoverageForExclusions, } from '../v3/workspaceSyncV3CombinedWireContract.js';
 import { WORKSPACE_SYNC_ENGINE_TRANSFER_COMPLETION_VERSION, } from './workspaceSyncEngineTransferCompletion.js';
-import { parseWorkspaceSyncEngineAppliedTaskUpserts, parseWorkspaceSyncEngineV2PushBoundary, workspaceSyncEngineExpectedTaskEchoIds, } from './workspaceSyncEnginePushCompletion.js';
+import { parseWorkspaceSyncEnginePushTaskSettlement, parseWorkspaceSyncEngineV2PushBoundary, workspaceSyncEngineExpectedTaskEchoIds, } from './workspaceSyncEnginePushCompletion.js';
 const PERMIT_DEADLINE_SLACK_MS = 5_000;
 function isPlainObject(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
@@ -311,7 +311,7 @@ export function createServerWorkspaceSyncEngineRemoteServices(options) {
                 requireAcceptedJsonObject: true,
                 validateAcceptedData: (value) => {
                     try {
-                        parseWorkspaceSyncEngineAppliedTaskUpserts(value, expectedTaskEchoIds);
+                        parseWorkspaceSyncEnginePushTaskSettlement(value, expectedTaskEchoIds);
                         return true;
                     }
                     catch {

package/dist/sync/engine/workspaceSyncEngineServerRunnerOperations.js

@@ -623,7 +623,7 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                             acknowledgedOperationIdentities.length;
                     }
                 },
-                onAcceptedBatchSettled: async ({ operationIdentity, settlementIdentityFingerprint, appliedTaskUpserts, transferReceipt, pushBoundary, excludedProjections, }) => {
+                onAcceptedBatchSettled: async ({ operationIdentity, settlementIdentityFingerprint, appliedTaskUpserts, settledTaskDeleteIds, transferReceipt, pushBoundary, excludedProjections, }) => {
                     const pendingV2Push = checkpoint.pendingV2Push;
                     if (!pendingV2Push
                         || pendingV2Push.settlementVersion !== 1
@@ -661,6 +661,9 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                                     operationIdentity,
                                     settlementIdentityFingerprint,
                                     appliedTaskUpserts: structuredClone(appliedTaskUpserts),
+                                    ...(settledTaskDeleteIds.length > 0 ? {
+                                        settledTaskDeleteIds: [...settledTaskDeleteIds],
+                                    } : {}),
                                 },
                             ],
                         },

package/dist/sync/engine/workspaceSyncV2ChangeDispatcher.d.ts

@@ -17,6 +17,7 @@ export interface WorkspaceSyncV2DispatchOptions {
     coexistenceDirection?: TaskMetadataCoexistenceDirection;
     assertedActiveV3TaskMetadataIds?: ReadonlySet<string>;
     assertedActiveV3TaskDeleteIds?: ReadonlySet<string>;
+    candidateTerminalV3TaskDeleteIds?: ReadonlySet<string>;
     assertedActiveV3TaskLifecycleIds?: ReadonlySet<string>;
     assertedActiveV3TaskReopenAssigneeIds?: ReadonlySet<string>;
     assertedActiveV3Taxonomy?: boolean;

package/dist/sync/engine/workspaceSyncV2ChangeDispatcher.js

@@ -156,11 +156,40 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
             throw createSyncRouteError('Cloud pull contained content from an excluded v2 projection.', { excludedProjections: Array.from(v2ExcludedProjections) }, { code: 'SYNC_V2_EXCLUDED_PROJECTION_PRESENT', statusCode: 409 });
         }
         const taskMutationsForApply = prepareWorkspaceSyncV2TaskCarriers(applyModel.taskMutations, v2ExcludedProjections, (taskId) => core.getTask(taskId, workspaceId));
-        if (v2ExcludedProjections.has('task/root-v1')) {
+        if (v2ExcludedProjections.has('task/root-v1')
+            && !(options.coexistenceDirection === 'cloud-push'
+                && options.candidateTerminalV3TaskDeleteIds?.size)) {
             assertWorkspaceSyncV2TaskCarrierRootsExist(taskMutationsForApply, (taskId) => Boolean(core.getTask(taskId, workspaceId)));
         }
         return { applyModel, taskMutationsForApply, v2ExcludedProjections };
     };
+    const resolveTaskCarrierSettlement = (workspaceId, taskMutations, ownership, options) => {
+        const candidates = options.coexistenceDirection === 'cloud-push'
+            ? options.candidateTerminalV3TaskDeleteIds
+            : undefined;
+        if (!candidates?.size) {
+            return { taskMutationsForSettlement: taskMutations, settledTaskDeleteIds: [] };
+        }
+        const terminalOwnership = new Set(ownership
+            .filter((entry) => entry.activeDeleteOperation === true || entry.deleteOwned === true)
+            .map((entry) => entry.taskId));
+        const settledTaskDeleteIds = candidates
+            ? taskMutations.upserts
+                .map((mutation) => mutation.task.id)
+                .filter((taskId) => (candidates.has(taskId)
+                && terminalOwnership.has(taskId)
+                && !core.getTask(taskId, workspaceId)))
+            : [];
+        const settledIds = new Set(settledTaskDeleteIds);
+        const taskMutationsForSettlement = settledIds.size > 0
+            ? {
+                ...taskMutations,
+                upserts: taskMutations.upserts.filter((mutation) => !settledIds.has(mutation.task.id)),
+            }
+            : taskMutations;
+        assertWorkspaceSyncV2TaskCarrierRootsExist(taskMutationsForSettlement, (taskId) => Boolean(core.getTask(taskId, workspaceId)));
+        return { taskMutationsForSettlement, settledTaskDeleteIds };
+    };
     const prepareTaskSnapshotForDispatch = (workspaceId, taskMutationsForApply, v2ExcludedProjections, options) => {
         const prepared = prepareTaskSyncSnapshotApply({
             core,
@@ -317,6 +346,7 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                     taskforceAgentPushActorUserId: String(options.actorUserId || '').trim() || null,
                     taskforceAgentPushAccessPreflighted: true,
                 } : {}),
+                coexistenceDirection: options.coexistenceDirection,
                 recordSyncDiagnostic,
                 createSyncRouteError,
             });
@@ -334,14 +364,15 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                             if (options.coexistenceDirection === 'cloud-push'
                                 && taskMutationsForApply.upserts.some((mutation) => mutation.durableRevision))
                                 throw new Error('Task durable revisions are only accepted from the cloud pull feed.');
+                            const { taskMutationsForSettlement, settledTaskDeleteIds, } = resolveTaskCarrierSettlement(workspaceId, taskMutationsForApply, ownership, options);
                             const durablePull = options.coexistenceDirection === 'local-pull'
                                 ? prepareDurableTaskPullMutations({
                                     store: durabilityStore,
                                     tenantId: core.getTenantId(),
                                     workspaceId,
-                                    taskMutations: taskMutationsForApply,
+                                    taskMutations: taskMutationsForSettlement,
                                 })
-                                : { taskMutations: taskMutationsForApply, pendingRevisions: [] };
+                                : { taskMutations: taskMutationsForSettlement, pendingRevisions: [] };
                             const prepared = prepareTaskSyncSnapshotApply({
                                 core,
                                 workspaceId,
@@ -360,7 +391,7 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                                     ownership: durabilityStore.listTaskTaxonomyProjectionOwnership({
                                         tenantId: core.getTenantId(),
                                         workspaceId,
-                                        taskIds: taskMutationsForApply.upserts.map((mutation) => mutation.task.id),
+                                        taskIds: taskMutationsForSettlement.upserts.map((mutation) => mutation.task.id),
                                     }),
                                 }),
                                 v3OwnedTaskDeleteIds: resolveV3OwnedTaskDeleteIds({
@@ -395,7 +426,7 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                                 revisions: durablePull.pendingRevisions,
                                 now: revisionNow,
                             });
-                            return { prepared, result };
+                            return { prepared, result, settledTaskDeleteIds };
                         },
                     });
                 })()
@@ -406,6 +437,7 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                         workspaceId,
                         prepared: preparedTaskSnapshot,
                     }),
+                    settledTaskDeleteIds: [],
                 };
             const result = finalPreparedTaskSnapshot.result;
             const committedTaskIds = finalPreparedTaskSnapshot.result.changedTaskIds || [];
@@ -479,7 +511,14 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                 recordSyncDiagnostic,
                 createSyncRouteError,
             });
-            return { result, deleteCount, emittedEventIds: Array.from(emittedEventIds) };
+            return {
+                result,
+                deleteCount,
+                emittedEventIds: Array.from(emittedEventIds),
+                ...(finalPreparedTaskSnapshot.settledTaskDeleteIds.length > 0 ? {
+                    settledTaskDeleteIds: finalPreparedTaskSnapshot.settledTaskDeleteIds,
+                } : {}),
+            };
         }
         finally {
             unsubscribeRealtime();
@@ -777,6 +816,7 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                         taskforceAgentPushActorUserId: String(options.actorUserId || '').trim() || null,
                         taskforceAgentPushAccessPreflighted: true,
                     } : {}),
+                    coexistenceDirection: options.coexistenceDirection,
                     recordSyncDiagnostic,
                     createSyncRouteError,
                 });
@@ -794,14 +834,15 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                                 if (options.coexistenceDirection === 'cloud-push'
                                     && taskMutationsForApply.upserts.some((mutation) => mutation.durableRevision))
                                     throw new Error('Task durable revisions are only accepted from the cloud pull feed.');
+                                const { taskMutationsForSettlement, settledTaskDeleteIds, } = resolveTaskCarrierSettlement(workspaceId, taskMutationsForApply, ownership, options);
                                 const durablePull = options.coexistenceDirection === 'local-pull'
                                     ? prepareDurableTaskPullMutations({
                                         store: durabilityStore,
                                         tenantId: core.getTenantId(),
                                         workspaceId,
-                                        taskMutations: taskMutationsForApply,
+                                        taskMutations: taskMutationsForSettlement,
                                     })
-                                    : { taskMutations: taskMutationsForApply, pendingRevisions: [] };
+                                    : { taskMutations: taskMutationsForSettlement, pendingRevisions: [] };
                                 const prepared = prepareTaskSyncSnapshotApply({
                                     core,
                                     workspaceId,
@@ -820,7 +861,7 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                                         ownership: durabilityStore.listTaskTaxonomyProjectionOwnership({
                                             tenantId: core.getTenantId(),
                                             workspaceId,
-                                            taskIds: taskMutationsForApply.upserts.map((mutation) => mutation.task.id),
+                                            taskIds: taskMutationsForSettlement.upserts.map((mutation) => mutation.task.id),
                                         }),
                                     }),
                                     v3OwnedTaskDeleteIds: resolveV3OwnedTaskDeleteIds({
@@ -855,7 +896,7 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                                     revisions: durablePull.pendingRevisions,
                                     now: revisionNow,
                                 });
-                                return { prepared, result };
+                                return { prepared, result, settledTaskDeleteIds };
                             },
                         });
                     })()
@@ -867,6 +908,7 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                             prepared: preparedTaskSnapshot,
                             deferSideEffects: true,
                         }),
+                        settledTaskDeleteIds: [],
                     };
                 const protectedTaskCount = finalPreparedTaskSnapshot.prepared.metadataPreservedTaskIds.length;
                 const protectedLifecycleTaskCount = finalPreparedTaskSnapshot.prepared.lifecyclePreservedTaskIds.length;
@@ -932,6 +974,9 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                     result: finalPreparedTaskSnapshot.result,
                     deleteCount,
                     emittedEventIds: [],
+                    ...(finalPreparedTaskSnapshot.settledTaskDeleteIds.length > 0 ? {
+                        settledTaskDeleteIds: finalPreparedTaskSnapshot.settledTaskDeleteIds,
+                    } : {}),
                 };
                 const beforeCommitResult = options.transactionHooks?.beforeCommit?.(result);
                 assertSynchronousTransactionResult(beforeCommitResult);

package/dist/sync/syncApplyHandlers.d.ts

@@ -257,6 +257,7 @@ export declare function applyCollaborationSyncChanges(input: {
     incomingAgentConversations?: Map<string, WorkspaceSyncAgentConversationSnapshot>;
     taskforceAgentPushActorUserId?: string | null;
     taskforceAgentPushAccessPreflighted?: boolean;
+    coexistenceDirection?: 'local-pull' | 'cloud-push';
     recordSyncDiagnostic: RecordSyncDiagnostic;
     createSyncRouteError: CreateSyncRouteError;
 }): void;

package/dist/sync/syncApplyHandlers.js

@@ -1053,7 +1053,7 @@ export async function applyContentSyncChanges(input) {
     }
 }
 export function applyCollaborationSyncChanges(input) {
-    const { core, workspaceId, incomingDocumentReviewSessions, incomingDocumentReviewSessionDeletes, incomingDocumentReviewComments, incomingDocumentReviewCommentDeletes, incomingAnnotatedAttachmentSessions, incomingAnnotatedAttachmentSessionDeletes, incomingTaskforceAgents = new Map(), incomingAgentRoles = new Map(), incomingTaskforceAgentSkills = new Map(), incomingAgentConversations = new Map(), taskforceAgentPushActorUserId, taskforceAgentPushAccessPreflighted = false, recordSyncDiagnostic, createSyncRouteError, } = input;
+    const { core, workspaceId, incomingDocumentReviewSessions, incomingDocumentReviewSessionDeletes, incomingDocumentReviewComments, incomingDocumentReviewCommentDeletes, incomingAnnotatedAttachmentSessions, incomingAnnotatedAttachmentSessionDeletes, incomingTaskforceAgents = new Map(), incomingAgentRoles = new Map(), incomingTaskforceAgentSkills = new Map(), incomingAgentConversations = new Map(), taskforceAgentPushActorUserId, taskforceAgentPushAccessPreflighted = false, coexistenceDirection, recordSyncDiagnostic, createSyncRouteError, } = input;
     if (taskforceAgentPushActorUserId !== undefined && !taskforceAgentPushAccessPreflighted) {
         assertTaskforceAgentSyncPushAccess({
             agents: incomingTaskforceAgents.values(),
@@ -1141,6 +1141,48 @@ export function applyCollaborationSyncChanges(input) {
                         .digest('hex')
                     : '';
                 const metadataCompare = resolveSyncConflictOrdering(comment.updatedAt, String(existing?.updatedAt || '').trim(), incomingTieBreak, existingTieBreak);
+                const parentCommentConflict = Boolean(existing
+                    && comment.parentCommentId !== undefined
+                    && comment.parentCommentId !== existing.parentCommentId);
+                const nonThreadFieldsMatch = Boolean(existing
+                    && comment.sessionId === existing.sessionId
+                    && comment.body === existing.body
+                    && JSON.stringify(comment.anchor ?? null) === JSON.stringify(existing.anchor ?? null)
+                    && comment.order === existing.order
+                    && (comment.authorActorId ?? null) === (existing.authorActorId ?? null)
+                    && (comment.updatedByActorId ?? null) === (existing.updatedByActorId ?? null)
+                    && (comment.deletedByActorId ?? null) === (existing.deletedByActorId ?? null)
+                    && comment.createdAt === existing.createdAt
+                    && comment.updatedAt === existing.updatedAt
+                    && (comment.deletedAt ?? null) === (existing.deletedAt ?? null));
+                const incomingIsLegacyProjectedRoot = Boolean(nonThreadFieldsMatch
+                    && comment.parentCommentId === null
+                    && comment.threadStatus === 'open'
+                    && comment.threadStatusUpdatedAt === comment.createdAt
+                    && !comment.resolvedAt
+                    && !comment.resolvedByActorId);
+                const existingIsLegacyProjectedRoot = Boolean(nonThreadFieldsMatch
+                    && existing
+                    && existing.parentCommentId === null
+                    && existing.threadStatus === 'open'
+                    && existing.threadStatusUpdatedAt === existing.createdAt
+                    && !existing.resolvedAt
+                    && !existing.resolvedByActorId);
+                const preserveLocalReplyParent = parentCommentConflict
+                    && coexistenceDirection === 'local-pull'
+                    && Boolean(existing?.parentCommentId)
+                    && incomingIsLegacyProjectedRoot;
+                const reconcileAuthoritativeParent = parentCommentConflict
+                    && coexistenceDirection === 'local-pull'
+                    && !preserveLocalReplyParent;
+                const reconcileLegacyCloudRoot = parentCommentConflict
+                    && coexistenceDirection === 'cloud-push'
+                    && existingIsLegacyProjectedRoot
+                    && Boolean(comment.parentCommentId);
+                const applyIncomingMetadata = metadataCompare >= 0
+                    && !(parentCommentConflict
+                        && coexistenceDirection === 'cloud-push'
+                        && !reconcileLegacyCloudRoot);
                 const incomingLifecycleTieBreak = createHash('sha256')
                     .update(JSON.stringify({
                     threadStatus: comment.threadStatus,
@@ -1160,28 +1202,43 @@ export function applyCollaborationSyncChanges(input) {
                 const lifecycleCompare = comment.threadStatusUpdatedAt === undefined
                     ? -1
                     : resolveSyncConflictOrdering(String(comment.threadStatusUpdatedAt || '').trim(), String(existing?.threadStatusUpdatedAt || '').trim(), incomingLifecycleTieBreak, existingLifecycleTieBreak);
-                if (metadataCompare < 0 && lifecycleCompare < 0)
+                if (metadataCompare < 0
+                    && lifecycleCompare < 0
+                    && !reconcileAuthoritativeParent
+                    && !reconcileLegacyCloudRoot)
                     continue;
-                core.upsertDocumentReviewCommentForSync({
+                const commentForSync = {
                     id: comment.id,
                     tenantId: core.getTenantId(),
                     workspaceId,
-                    sessionId: metadataCompare >= 0 ? comment.sessionId : existing.sessionId,
-                    body: metadataCompare >= 0 ? comment.body : existing.body,
-                    anchor: (metadataCompare >= 0 ? comment.anchor : existing.anchor),
-                    order: metadataCompare >= 0 ? comment.order : existing.order,
-                    authorActorId: metadataCompare >= 0 ? comment.authorActorId : existing.authorActorId,
-                    updatedByActorId: metadataCompare >= 0 ? comment.updatedByActorId : existing.updatedByActorId,
-                    deletedByActorId: metadataCompare >= 0 ? comment.deletedByActorId : existing.deletedByActorId,
-                    parentCommentId: metadataCompare >= 0 ? comment.parentCommentId : existing.parentCommentId,
+                    sessionId: applyIncomingMetadata ? comment.sessionId : existing.sessionId,
+                    body: applyIncomingMetadata ? comment.body : existing.body,
+                    anchor: (applyIncomingMetadata ? comment.anchor : existing.anchor),
+                    order: applyIncomingMetadata ? comment.order : existing.order,
+                    authorActorId: applyIncomingMetadata ? comment.authorActorId : existing.authorActorId,
+                    updatedByActorId: applyIncomingMetadata ? comment.updatedByActorId : existing.updatedByActorId,
+                    deletedByActorId: applyIncomingMetadata ? comment.deletedByActorId : existing.deletedByActorId,
+                    parentCommentId: preserveLocalReplyParent
+                        ? existing.parentCommentId
+                        : reconcileAuthoritativeParent || reconcileLegacyCloudRoot || applyIncomingMetadata
+                            ? comment.parentCommentId
+                            : existing.parentCommentId,
                     threadStatus: lifecycleCompare >= 0 ? comment.threadStatus : undefined,
                     threadStatusUpdatedAt: lifecycleCompare >= 0 ? comment.threadStatusUpdatedAt : undefined,
                     resolvedAt: lifecycleCompare >= 0 ? comment.resolvedAt : undefined,
                     resolvedByActorId: lifecycleCompare >= 0 ? comment.resolvedByActorId : undefined,
-                    createdAt: metadataCompare >= 0 ? comment.createdAt : existing.createdAt,
-                    updatedAt: metadataCompare >= 0 ? comment.updatedAt : existing.updatedAt,
-                    deletedAt: metadataCompare >= 0 ? comment.deletedAt : existing.deletedAt,
-                });
+                    createdAt: applyIncomingMetadata ? comment.createdAt : existing.createdAt,
+                    updatedAt: applyIncomingMetadata ? comment.updatedAt : existing.updatedAt,
+                    deletedAt: applyIncomingMetadata ? comment.deletedAt : existing.deletedAt,
+                };
+                if (reconcileAuthoritativeParent || reconcileLegacyCloudRoot) {
+                    core.upsertDocumentReviewCommentForSync(commentForSync, {
+                        allowAuthoritativeThreadReconciliation: true,
+                    });
+                }
+                else {
+                    core.upsertDocumentReviewCommentForSync(commentForSync);
+                }
                 if (comment.parentCommentId) {
                     const rootExists = core.listDocumentReviewCommentsForSync({
                         workspaceId,

package/dist/sync/syncService.d.ts

@@ -72,6 +72,7 @@ export interface WorkspacePushSyncInput {
         operationIdentity: string;
         settlementIdentityFingerprint: string;
         appliedTaskUpserts: WorkspacePushSyncResult['appliedTaskUpserts'];
+        settledTaskDeleteIds: string[];
         transferReceipt: WorkspaceSyncEngineRemoteTransferReceipt;
         pushBoundary: WorkspaceSyncEngineV2PushBoundary;
         excludedProjections?: readonly WorkspaceSyncV2ProjectionExclusion[];

package/dist/sync/syncService.js

@@ -1,7 +1,7 @@
 import { applyLocalWorkspaceChanges, getLocalWorkspaceContentPullObligations, recordLocalWorkspaceContentPullObligationFailures, getLocalWorkspaceContentManifest, pullUserSettings, pushUserSettings, prepareWorkspacePushChanges, } from './cloudSyncApi.js';
 import { workspaceSyncContentPullObligationId, } from './engine/workspaceSyncContentPullObligationStore.js';
 import { createBrowserWorkspaceSyncEngineRemoteServices, } from './engine/workspaceSyncEngineRemoteServices.js';
-import { createWorkspaceSyncEngineV2SettlementIdentityProjection, createWorkspaceSyncEngineV2PushBoundary, parseWorkspaceSyncEngineAppliedTaskUpserts, workspaceSyncEngineExpectedTaskEchoIds, } from './engine/workspaceSyncEnginePushCompletion.js';
+import { createWorkspaceSyncEngineV2SettlementIdentityProjection, createWorkspaceSyncEngineV2PushBoundary, parseWorkspaceSyncEnginePushTaskSettlement, workspaceSyncEngineExpectedTaskEchoIds, } from './engine/workspaceSyncEnginePushCompletion.js';
 import { encryptDocument } from './encryptionService.js';
 import { decryptWorkspaceSyncContentChangeInPlace } from './workspaceSyncContentDecryption.js';
 import { decideWorkspaceContentFetch, fingerprintWorkspaceContentBody, } from './workspaceContentManifest.js';
@@ -835,7 +835,8 @@ export async function runWorkspacePushSyncService(input) {
                     emittedEventIds.add(eventId);
                 }
             }
-            const normalizedTaskUpserts = parseWorkspaceSyncEngineAppliedTaskUpserts(pushData, expectedTaskEchoIds);
+            const taskSettlement = parseWorkspaceSyncEnginePushTaskSettlement(pushData, expectedTaskEchoIds);
+            const normalizedTaskUpserts = taskSettlement.appliedTaskUpserts;
             appliedTaskUpserts.push(...normalizedTaskUpserts);
             if (input.onAcceptedBatchSettled) {
                 if (!pushResult.transferReceipt) {
@@ -847,9 +848,11 @@ export async function runWorkspacePushSyncService(input) {
                         operationIdentity: idempotencyKey,
                         changes: plainBatchChanges,
                         appliedTaskUpserts: normalizedTaskUpserts,
+                        settledTaskDeleteIds: taskSettlement.settledTaskDeleteIds,
                         excludedProjections: effectiveV2ExcludedProjections,
                     })),
                     appliedTaskUpserts: normalizedTaskUpserts,
+                    settledTaskDeleteIds: taskSettlement.settledTaskDeleteIds,
                     transferReceipt: pushResult.transferReceipt,
                     pushBoundary,
                     excludedProjections: effectiveV2ExcludedProjections,

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';
@@ -53,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;
@@ -72,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';
@@ -110,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);
@@ -120,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);
@@ -338,18 +364,15 @@ export function createDurableWorkflowRuntimeMutationRouter(input) {
             if (!snapshot)
                 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({
@@ -363,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/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;