@taskforcehq/taskforce 0.3.330 → 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';
@@ -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;

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;