@taskforcehq/taskforce 0.3.330 → 0.3.333

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;

package/dist/sync/v3/localTaskStatusOutboxService.js

@@ -347,7 +347,11 @@ export function applyAuthoritativeTaskStatusAndAck(input) {
     if (!validLifecycle || authoritative.metadataOwned !== expectsMetadataOwnership) {
         throw new LocalAuthoritativeTaskStatusError('Authoritative task status state does not match the persisted request.');
     }
-    const localCanonical = input.core.getTask(task.id, input.identity.workspaceId);
+    const activeSuccessors = input.store.listActiveOutboxSuccessors(input.identity);
+    const localCanonical = input.core.getTask(task.id, input.identity.workspaceId)
+        || (activeSuccessors.some((successor) => successor.mutationKind === 'delete')
+            ? input.core.getDeletedTask(task.id, input.identity.workspaceId)?.taskSnapshot
+            : null);
     if (!localCanonical)
         throw new LocalAuthoritativeTaskStatusError('Local task status projection is missing.');
     let canonicalMetadataIntent = null;
@@ -581,14 +585,20 @@ export function applyAuthoritativeTaskStatusAndAck(input) {
                     expectedTaskId: task.id,
                 });
             }
-            const successors = input.store.listActiveOutboxSuccessors(input.identity);
+            const successors = activeSuccessors;
             const hasSuccessor = successors.length > 0;
-            let updated = hasSuccessor
+            const activeTask = hasSuccessor
                 ? input.core.getTask(task.id, input.identity.workspaceId)
+                : null;
+            const deletedSnapshot = !activeTask && successors.some((successor) => successor.mutationKind === 'delete')
+                ? input.core.getDeletedTask(task.id, input.identity.workspaceId)?.taskSnapshot
+                : null;
+            let updated = hasSuccessor
+                ? activeTask || deletedSnapshot
                 : input.core.installDurableTaskStatusAuthoritativeForSync(task, payload, installAssignee, input.identity.workspaceId);
             if (!updated)
                 throw new LocalAuthoritativeTaskStatusError('Local task status projection is missing.');
-            if (reviewHandoff && reviewCommentsPayload && reviewCommentActivity) {
+            if (reviewHandoff && reviewCommentsPayload && reviewCommentActivity && !deletedSnapshot) {
                 const localComments = serializeWorkspaceSyncV3TaskCommentsPayload({
                     taskId: updated.id,
                     comments: updated.comments || [],
@@ -612,7 +622,12 @@ export function applyAuthoritativeTaskStatusAndAck(input) {
                 input.core.upsertEntityEventForSync(reviewCommentActivity, { allowAuthoritativeReplacement: true });
                 activityReconciled = true;
             }
-            if (hasSuccessor
+            else if (reviewHandoff && reviewCommentActivity && deletedSnapshot) {
+                input.core.upsertEntityEventForSync(reviewCommentActivity, { allowAuthoritativeReplacement: true });
+                activityReconciled = true;
+            }
+            if (!deletedSnapshot
+                && hasSuccessor
                 && installAssignee
                 && !successors.some((successor) => successor.ownsTaskAssignee)
                 && normalizeAssignee(updated.assignee) !== normalizeAssignee(task.assignee)) {

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

@@ -90,6 +90,7 @@ export type WorkspaceSyncOutboxRecord = WorkspaceSyncOperationIdentity & {
     initiativeMetadataRevisionRebaseCount?: number;
     leaseOwner: string | null;
     leaseExpiresAt: string | null;
+    lastErrorCode: string | null;
 };
 export type WorkspaceSyncOutboxOperationLookup = WorkspaceSyncOperationIdentity & {
     status: string;
@@ -397,7 +398,7 @@ export declare class WorkspaceSyncDurabilityStore {
         identity: WorkspaceSyncOperationIdentity;
         recoveryBatchId: string;
         now: string;
-        replayPolicy?: 'task-root';
+        replayPolicy?: 'task-root' | 'authoritative-workflow-runtime';
         appendToExistingRecovery?: boolean;
     }): WorkspaceSyncOutboxSupersession;
     recordOutboxRecoveryBaseline(input: {

package/dist/sync/v3/syncDurabilityStore.js

@@ -27,6 +27,7 @@ const TASK_AGGREGATE_SUCCESSOR_MUTATIONS = new Map([
 const TASK_ROOT_SUCCESSOR_MUTATIONS = new Set([
     'metadata-update', 'set-status', 'archive', 'unarchive', 'complete', 'reopen',
 ]);
+const TASK_TERMINAL_SUCCESSOR_MUTATIONS = new Set(['delete']);
 const TASK_CREATE_RECOVERY_ERROR_CODES = new Set([
     'TASK_CREATE_ID_CONFLICT',
     'WORKSPACE_SYNC_REVISION_CONFLICT',
@@ -795,7 +796,8 @@ export class WorkspaceSyncDurabilityStore {
                    payload_json, payload_fingerprint, canonical_intent_json, status, attempt_count,
                    initial_not_found_attempt_count,
                    CAST(enqueue_sequence AS TEXT) AS enqueue_sequence,
-                   rebase_before_first_attempt, lease_owner, lease_expires_at
+                   rebase_before_first_attempt, lease_owner, lease_expires_at,
+                   last_error_code
             FROM workspace_sync_outbox
             WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
         `).get(...operationParams(identity));
@@ -1343,6 +1345,17 @@ export class WorkspaceSyncDurabilityStore {
                     }
                 }
             }
+            else if (input.replayPolicy === 'authoritative-workflow-runtime') {
+                if (selected.length !== 1) {
+                    throw new Error('Workflow runtime recovery has intersecting intent that requires semantic history reconciliation.');
+                }
+                const candidate = selected[0];
+                if (candidate.domain !== 'workflow-execution'
+                    || candidate.mutation_kind !== 'complete-step'
+                    || candidate.last_error_code !== 'WORKFLOW_RUNTIME_SEMANTIC_REPLAY_REQUIRED') {
+                    throw new Error('Workflow runtime recovery requires an exact authoritative semantic replay conflict.');
+                }
+            }
             this.db.prepare(`
                 INSERT INTO workspace_sync_outbox_recoveries (
                     tenant_id, workspace_id, recovery_batch_id,
@@ -1611,6 +1624,11 @@ export class WorkspaceSyncDurabilityStore {
                 }
             }
             const sources = recoverySources.filter((source) => {
+                if (source.domain === 'workflow-execution'
+                    && source.mutation_kind === 'complete-step'
+                    && source.last_error_code === 'WORKFLOW_RUNTIME_SEMANTIC_REPLAY_REQUIRED') {
+                    return false;
+                }
                 if (source.domain === 'task-comments' && source.mutation_kind === 'append') {
                     return !this.isTaskCommentAppendRecoveryIntentSatisfied(tenantId, workspaceId, source);
                 }
@@ -2591,6 +2609,12 @@ export class WorkspaceSyncDurabilityStore {
         const queueableTaskRoot = domain === 'task'
             && TASK_ROOT_SUCCESSOR_MUTATIONS.has(mutationKind)
             && (additionalTargets.length === 0 || queueableTaskReviewHandoff);
+        const queueableTaskDelete = domain === 'task'
+            && TASK_TERMINAL_SUCCESSOR_MUTATIONS.has(mutationKind)
+            && additionalTargets.length === 0
+            && ownsTaskMetadata
+            && ownsTaskLifecycle
+            && !ownsTaskAssignee;
         const queueableTaskAggregate = Boolean(TASK_AGGREGATE_SUCCESSOR_MUTATIONS.get(domain)?.has(mutationKind))
             && ((domain === 'task-comments' && mutationKind === 'reconcile' && additionalTargets.length === 0)
                 || (additionalTargets.length === 1
@@ -2601,7 +2625,8 @@ export class WorkspaceSyncDurabilityStore {
                     && !taskAggregateRootTarget.ownsTaskLifecycle
                     && !taskAggregateRootTarget.ownsTaskAssignee))
             && !ownsTaskMetadata && !ownsTaskLifecycle && !ownsTaskAssignee;
-        if (queuedTaskSuccessor && (input.revisionSource !== 'current' || (!queueableTaskRoot && !queueableTaskAggregate))) {
+        if (queuedTaskSuccessor && (input.revisionSource !== 'current'
+            || (!queueableTaskRoot && !queueableTaskDelete && !queueableTaskAggregate))) {
             throw new Error('Queued task successors require a recognized task root or aggregate operation.');
         }
         const additionalTargetKeys = new Set();
@@ -2813,11 +2838,13 @@ export class WorkspaceSyncDurabilityStore {
                                 const isTaskRoot = activeDomain === 'task'
                                     && row.entity_id === entityId
                                     && (TASK_ROOT_SUCCESSOR_MUTATIONS.has(activeMutationKind)
-                                        || (queueableTaskAggregate && activeMutationKind === 'create'))
+                                        || (activeMutationKind === 'create'
+                                            && Number(row.owns_task_metadata) === 0
+                                            && Number(row.owns_task_lifecycle) === 0
+                                            && Number(row.owns_task_assignee) === 0))
                                     && Number(row.target_count) === 1;
-                                return isTaskRoot
-                                    || isCompatibleTaskAggregate(row)
-                                    || isCompatibleWorkflowRuntimeAggregate(row);
+                                return isTaskRoot || (!queueableTaskDelete && (isCompatibleTaskAggregate(row)
+                                    || isCompatibleWorkflowRuntimeAggregate(row)));
                             });
                         const compatibleWorkflowRuntimeSuccessor = queuedWorkflowRuntimeSuccessor
                             && active.every((row) => (row.domain === 'workflow-execution'
@@ -4914,6 +4941,7 @@ export class WorkspaceSyncDurabilityStore {
             initiativeMetadataRevisionRebaseCount: Number(row.initiative_metadata_revision_rebase_count || 0),
             leaseOwner: row.lease_owner == null ? null : String(row.lease_owner),
             leaseExpiresAt: row.lease_expires_at == null ? null : String(row.lease_expires_at),
+            lastErrorCode: row.last_error_code == null ? null : String(row.last_error_code),
         };
     }
 }

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

@@ -53,6 +53,11 @@ export type PreparedWorkflowRuntimeMutation = {
     terminalEventId: string;
     taskActivityId: string;
 };
+export declare class WorkflowRuntimeSemanticReplayError extends Error {
+    readonly code = "WORKFLOW_RUNTIME_SEMANTIC_REPLAY_REQUIRED";
+    readonly statusCode = 409;
+    constructor();
+}
 export declare function prepareWorkflowRuntimeMutation(input: {
     workflowStore: WorkflowStore;
     workspaceId: string;

package/dist/sync/v3/workflowRuntimeMutationService.js

@@ -6,11 +6,42 @@ import { buildTaskActivityJournalEntry, serializeTaskActivityForSync, } from './
 import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
 import { buildWorkflowRuntimeEventId, buildWorkflowRuntimeTaskActivityId, } from './workflowRuntimeOperationIdentity.js';
 import { fingerprintWorkflowRuntimePayload, serializeWorkflowExecutionEventSyncPayload, serializeWorkflowExecutionRootSyncPayload, validateWorkflowRuntimeAuthoritativeResult, validateWorkflowRuntimeMutationCommand, } from './workflowRuntimeSync.js';
+export class WorkflowRuntimeSemanticReplayError extends Error {
+    code = 'WORKFLOW_RUNTIME_SEMANTIC_REPLAY_REQUIRED';
+    statusCode = 409;
+    constructor() {
+        super('This workflow command was already completed by another synchronized runtime.');
+        this.name = 'WorkflowRuntimeSemanticReplayError';
+    }
+}
+function hasEquivalentCompletedStep(input) {
+    if (input.command.kind !== 'complete-step')
+        return false;
+    const events = input.workflowStore.listExecutionEvents(input.workspaceId, input.command.executionId);
+    const completed = events.find((event) => (event.idempotencyKey === `${input.command.idempotencyKey}:step-completed`));
+    const terminal = events.find((event) => (event.idempotencyKey === `${input.command.idempotencyKey}:step-started`
+        || event.idempotencyKey === `${input.command.idempotencyKey}:execution-completed`));
+    if (!completed || !terminal)
+        return false;
+    const evidence = completed.details.evidence;
+    const evidenceCommentId = evidence
+        && typeof evidence === 'object'
+        && !Array.isArray(evidence)
+        && evidence.type === 'comment'
+        ? String(evidence.commentId || '')
+        : '';
+    return completed.actorId === input.command.actorId
+        && terminal.actorId === input.command.actorId
+        && completed.stepId === input.command.expectedStepId
+        && evidenceCommentId === (input.command.evidenceCommentId || '');
+}
 export function prepareWorkflowRuntimeMutation(input) {
     const before = input.workflowStore.getExecutionStateSnapshot(input.workspaceId, input.command.executionId);
     if (!before)
         throw new Error('Workflow execution not found.');
     if (before.execution.status !== input.command.expectedStatus) {
+        if (hasEquivalentCompletedStep(input))
+            throw new WorkflowRuntimeSemanticReplayError();
         throw new Error('Workflow execution has advanced beyond the expected status.');
     }
     if (input.command.kind === 'complete-step' && input.command.taskTarget.taskId !== before.execution.taskId) {
@@ -191,13 +222,25 @@ export function runDurableWorkflowRuntimeMutation(input) {
             response: JSON.parse(reservation.responseJson),
         };
     }
-    const prepared = prepareWorkflowRuntimeMutation({
-        workflowStore,
-        workspaceId: input.workspaceId,
-        clientId: input.clientId,
-        operationId: input.operationId,
-        command,
-    });
+    let prepared;
+    try {
+        prepared = prepareWorkflowRuntimeMutation({
+            workflowStore,
+            workspaceId: input.workspaceId,
+            clientId: input.clientId,
+            operationId: input.operationId,
+            command,
+        });
+    }
+    catch (error) {
+        input.store.releaseFailedOperationReservation({
+            identity,
+            requestFingerprint,
+            leaseOwner: reservation.leaseOwner,
+            now: input.now,
+        });
+        throw error;
+    }
     const { before, willReassignTask, taskActivityId, eventIds } = prepared;
     const readTaskActivity = (result) => {
         const activity = result.taskActivity || input.core.getTaskEventForSync({
@@ -262,73 +305,83 @@ export function runDurableWorkflowRuntimeMutation(input) {
             },
         })),
     ];
-    const accepted = input.store.acceptReservedOperationBatch({
-        identity,
-        requestFingerprint,
-        leaseOwner: reservation.leaseOwner,
-        now: input.now,
-        entries,
-        applyMutation: () => applyPreparedWorkflowRuntimeMutation({
-            core: input.core,
-            workflowStore,
-            workspaceId: input.workspaceId,
-            command,
-            prepared,
-            now: input.now,
-        }),
-        buildResponse: (result, revisions) => {
-            const executionPayload = serializeWorkflowExecutionRootSyncPayload(result.executionResult.execution);
-            const eventPayloads = result.executionResult.events.map(serializeWorkflowExecutionEventSyncPayload);
-            const projectionRevisions = [
-                {
-                    projection: 'workflow-execution/root-v1',
-                    ...revisionFor(revisions, 'workflow-execution', command.executionId),
-                    canonicalFingerprint: fingerprintWorkflowRuntimePayload(executionPayload),
-                },
-                ...result.newEvents.map((event) => {
-                    const payload = serializeWorkflowExecutionEventSyncPayload(event);
+    const accepted = (() => {
+        try {
+            return input.store.acceptReservedOperationBatch({
+                identity,
+                requestFingerprint,
+                leaseOwner: reservation.leaseOwner,
+                now: input.now,
+                entries,
+                applyMutation: () => applyPreparedWorkflowRuntimeMutation({
+                    core: input.core,
+                    workflowStore,
+                    workspaceId: input.workspaceId,
+                    command,
+                    prepared,
+                    now: input.now,
+                }),
+                buildResponse: (result, revisions) => {
+                    const executionPayload = serializeWorkflowExecutionRootSyncPayload(result.executionResult.execution);
+                    const eventPayloads = result.executionResult.events.map(serializeWorkflowExecutionEventSyncPayload);
+                    const projectionRevisions = [
+                        {
+                            projection: 'workflow-execution/root-v1',
+                            ...revisionFor(revisions, 'workflow-execution', command.executionId),
+                            canonicalFingerprint: fingerprintWorkflowRuntimePayload(executionPayload),
+                        },
+                        ...result.newEvents.map((event) => {
+                            const payload = serializeWorkflowExecutionEventSyncPayload(event);
+                            return {
+                                projection: 'workflow-execution-event/full-v1',
+                                ...revisionFor(revisions, 'workflow-execution-event', event.id),
+                                canonicalFingerprint: fingerprintWorkflowRuntimePayload(payload),
+                            };
+                        }),
+                        ...(result.task ? [{
+                                projection: 'task/root-v1',
+                                ...revisionFor(revisions, 'task', result.task.id),
+                                canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskForSync(result.task)),
+                            }, {
+                                projection: 'entity-event/full-v1',
+                                ...revisionFor(revisions, 'entity-event', readTaskActivity(result).id),
+                                canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskActivityForSync(readTaskActivity(result))),
+                            }] : []),
+                    ].sort((left, right) => BigInt(left.sequence) < BigInt(right.sequence) ? -1 : 1);
+                    const authoritative = validateWorkflowRuntimeAuthoritativeResult({
+                        execution: executionPayload,
+                        events: eventPayloads,
+                        acceptedEventIds: result.newEvents.map((event) => event.id),
+                        ...(result.task ? {
+                            task: {
+                                payload: serializeTaskForSync(result.task),
+                                activity: serializeTaskActivityForSync(readTaskActivity(result)),
+                            },
+                        } : {}),
+                        revisions: projectionRevisions,
+                        replayed: result.executionResult.replayed,
+                    });
+                    const executionRevision = revisionFor(revisions, 'workflow-execution', command.executionId);
                     return {
-                        projection: 'workflow-execution-event/full-v1',
-                        ...revisionFor(revisions, 'workflow-execution-event', event.id),
-                        canonicalFingerprint: fingerprintWorkflowRuntimePayload(payload),
+                        success: true,
+                        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+                        workspaceId: input.workspaceId,
+                        clientId: input.clientId,
+                        operationId: input.operationId,
+                        acceptedSequence: executionRevision.sequence,
+                        operationHighWatermark: revisions.at(-1)?.sequence || executionRevision.sequence,
+                        authoritative,
                     };
-                }),
-                ...(result.task ? [{
-                        projection: 'task/root-v1',
-                        ...revisionFor(revisions, 'task', result.task.id),
-                        canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskForSync(result.task)),
-                    }, {
-                        projection: 'entity-event/full-v1',
-                        ...revisionFor(revisions, 'entity-event', readTaskActivity(result).id),
-                        canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskActivityForSync(readTaskActivity(result))),
-                    }] : []),
-            ].sort((left, right) => BigInt(left.sequence) < BigInt(right.sequence) ? -1 : 1);
-            const authoritative = validateWorkflowRuntimeAuthoritativeResult({
-                execution: executionPayload,
-                events: eventPayloads,
-                acceptedEventIds: result.newEvents.map((event) => event.id),
-                ...(result.task ? {
-                    task: {
-                        payload: serializeTaskForSync(result.task),
-                        activity: serializeTaskActivityForSync(readTaskActivity(result)),
-                    },
-                } : {}),
-                revisions: projectionRevisions,
-                replayed: result.executionResult.replayed,
+                },
             });
-            const executionRevision = revisionFor(revisions, 'workflow-execution', command.executionId);
-            return {
-                success: true,
-                contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
-                workspaceId: input.workspaceId,
-                clientId: input.clientId,
-                operationId: input.operationId,
-                acceptedSequence: executionRevision.sequence,
-                operationHighWatermark: revisions.at(-1)?.sequence || executionRevision.sequence,
-                authoritative,
-            };
-        },
-    });
+        }
+        catch (error) {
+            if (hasEquivalentCompletedStep({ workflowStore, workspaceId: input.workspaceId, command })) {
+                throw new WorkflowRuntimeSemanticReplayError();
+            }
+            throw error;
+        }
+    })();
     const notify = (callback) => {
         if (!callback)
             return;

package/dist/sync/v3/workspaceSyncV3CombinedLocalApply.js

@@ -13,7 +13,7 @@ import { enqueueLocalTaskCommentReconciliation } from './localTaskCommentOutboxS
 import { buildWorkspaceSyncV3TaskCommentReconcileProvenance, indexWorkspaceSyncV3TaskCommentProvenanceEvidence, } from './taskCommentReconcileProvenance.js';
 import { serializeTaskRootForSync, } from './workspaceSyncV3TaskRootProjection.js';
 import { prepareWorkspaceSyncV3WorkflowRuntimeApply } from './workspaceSyncV3WorkflowRuntimeApply.js';
-import { serializeWorkflowExecutionEventSyncPayload, serializeWorkflowExecutionRootSyncPayload, serializeWorkflowPublishedDefinitionSyncPayload, } from './workflowRuntimeSync.js';
+import { serializeWorkflowExecutionEventSyncPayload, serializeWorkflowExecutionRootSyncPayload, serializeWorkflowPublishedDefinitionSyncPayload, validateWorkflowExecutionEventSyncPayload, } from './workflowRuntimeSync.js';
 import { serializeWorkstreamTaskOrderForSync } from './workstreamTaskOrderSync.js';
 import { validateWorkspaceSyncV3WorkstreamTaskOrderFeedEntry } from './workspaceSyncV3WorkstreamTaskOrderProjection.js';
 function combinedRepairBaselineMarker(page) {
@@ -198,6 +198,9 @@ function applyEntries(input) {
         store: new WorkflowStore(input.core.getDatabaseAdapter(), input.tenantId),
         workspaceId: input.workspaceId,
         entries: input.entries,
+        replaceAuthoritativeHistoryExecutionIds: input.allowAuthoritativeRevisionReset
+            ? input.authoritativeWorkflowRecoveryExecutionIds
+            : undefined,
     });
     return store.runWorkspaceDomainCoexistenceTransaction({
         tenantId: input.tenantId,
@@ -1011,7 +1014,7 @@ export function applyWorkspaceSyncV3CombinedRepairPage(input) {
         : [];
     const selectRecoveryEntries = (entries) => {
         const byTarget = new Map(entries.map((entry) => [`${entry.domain}\0${entry.entityId}`, entry]));
-        return recoveryTargets.map((target) => {
+        const selected = recoveryTargets.map((target) => {
             const entry = byTarget.get(`${target.domain}\0${target.entityId}`);
             if (!entry) {
                 if (!target.required)
@@ -1023,12 +1026,28 @@ export function applyWorkspaceSyncV3CombinedRepairPage(input) {
                 || (target.domain === 'task-attachment-links'
                     && (entry.projection === 'task-attachment-links/full-v1'
                         || entry.projection === 'task-attachment-links/full-v2'))
-                || (target.domain === 'entity-event' && entry.projection === 'entity-event/full-v1'));
+                || (target.domain === 'entity-event' && entry.projection === 'entity-event/full-v1')
+                || (target.domain === 'workflow-execution'
+                    && entry.projection === 'workflow-execution/root-v1'));
             if (!supportedTarget) {
                 throw new Error('Targeted workspace sync recovery does not support this projection.');
             }
             return entry;
         }).filter((entry) => entry !== null);
+        const workflowExecutionIds = new Set(selected
+            .filter((entry) => entry.projection === 'workflow-execution/root-v1')
+            .map((entry) => entry.entityId));
+        if (workflowExecutionIds.size > 0) {
+            for (const entry of entries) {
+                if (entry.projection !== 'workflow-execution-event/full-v1')
+                    continue;
+                const payload = validateWorkflowExecutionEventSyncPayload(entry.payload);
+                if (!workflowExecutionIds.has(payload.event.workflowExecutionId))
+                    continue;
+                selected.push(entry);
+            }
+        }
+        return selected;
     };
     const projections = coveredProjections(input.page);
     let notices = notifications();
@@ -1056,6 +1075,9 @@ export function applyWorkspaceSyncV3CombinedRepairPage(input) {
                     authoritativeEntityEventRecoveryIds: new Set(recoveryTargets
                         .filter((target) => target.domain === 'entity-event')
                         .map((target) => target.entityId)),
+                    authoritativeWorkflowRecoveryExecutionIds: new Set(recoveryTargets
+                        .filter((target) => target.domain === 'workflow-execution')
+                        .map((target) => target.entityId)),
                 } : {}),
             });
         },

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

@@ -34,6 +34,7 @@ export interface WorkspaceSyncV3FeedProjectionInput {
     rows: readonly WorkspaceSyncJournalRow[];
     cycleHighWatermark: string;
     followingRow?: WorkspaceSyncJournalRow | null;
+    workspaceId: string;
 }
 export type WorkspaceSyncV3FeedOperationProjector = (input: WorkspaceSyncV3FeedProjectionInput) => WorkspaceSyncV3FeedEntry[];
 export interface WorkspaceSyncV3FeedCoveragePolicy {

package/dist/sync/v3/workspaceSyncV3Feed.js

@@ -207,7 +207,12 @@ export function buildWorkspaceSyncV3Feed(input) {
             throw new WorkspaceSyncV3FeedOperationTooLargeError(`Workspace sync operation ${clientId}/${operationId} exceeds ${MAX_OPERATION_ROWS} journal rows.`);
         }
         const groupRows = rows.slice(offset, end);
-        const groupEntries = projectOperation({ rows: groupRows, cycleHighWatermark: String(high), followingRow: rows[end] || null });
+        const groupEntries = projectOperation({
+            rows: groupRows,
+            cycleHighWatermark: String(high),
+            followingRow: rows[end] || null,
+            workspaceId: input.workspaceId,
+        });
         if (entries.length + groupEntries.length > pageSize) {
             if (!entries.length)
                 throw new WorkspaceSyncV3FeedOperationTooLargeError(`Covered operation ${clientId}/${operationId} exceeds the feed entry limit.`);

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

@@ -49,9 +49,11 @@ export declare function projectWorkspaceSyncV3NestedTaskOperation(input: {
     rows: readonly WorkspaceSyncJournalRow[];
     cycleHighWatermark: string;
     followingRow?: WorkspaceSyncJournalRow | null;
+    workspaceId: string;
 }): WorkspaceSyncV3FeedEntry[] | null;
 export declare function projectWorkspaceSyncV3NestedTaskV2Operation(input: {
     rows: readonly WorkspaceSyncJournalRow[];
     cycleHighWatermark: string;
     followingRow?: WorkspaceSyncJournalRow | null;
+    workspaceId: string;
 }): WorkspaceSyncV3FeedEntry[] | null;