@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/sync/v3/workflowAssignmentSync.js

@@ -203,11 +203,38 @@ export function normalizeTaskStatusOperationWithWorkflowAssignment(raw) {
         }
         originActor = { kind: 'ai-profile', profileId };
     }
+    let reviewHandoff;
+    if (source.reviewHandoff !== undefined) {
+        if (status.status !== 'review') {
+            throw new WorkflowAssignmentSyncError('reviewHandoff is valid only when status is review.');
+        }
+        const handoff = object(source.reviewHandoff, 'reviewHandoff');
+        if (Object.keys(handoff).join(',') !== 'comment') {
+            throw new WorkflowAssignmentSyncError('reviewHandoff must contain exactly comment.');
+        }
+        const comment = object(handoff.comment, 'reviewHandoff.comment');
+        if (Object.keys(comment).sort().join(',') !== 'author,id,submittedAuthor,text') {
+            throw new WorkflowAssignmentSyncError('reviewHandoff.comment must contain exactly id, author, submittedAuthor, and text.');
+        }
+        const author = text(comment.author, 'reviewHandoff.comment.author');
+        const submittedAuthor = text(comment.submittedAuthor, 'reviewHandoff.comment.submittedAuthor');
+        const commentText = text(comment.text, 'reviewHandoff.comment.text');
+        if (author !== submittedAuthor) {
+            throw new WorkflowAssignmentSyncError('reviewHandoff comment authorship is invalid.');
+        }
+        reviewHandoff = { comment: {
+                id: text(comment.id, 'reviewHandoff.comment.id'),
+                author,
+                submittedAuthor,
+                text: commentText,
+            } };
+    }
     return {
         ...status,
         ...(source.workflowAssignment === undefined
             ? {}
             : { workflowAssignment: normalizeWorkflowAssignmentSyncRecord(source.workflowAssignment) }),
+        ...(reviewHandoff ? { reviewHandoff } : {}),
         ...(originActor ? { originActor } : {}),
         ...(typeof source.expectedDetailRevision === 'string' && source.expectedDetailRevision.trim()
             ? { expectedDetailRevision: source.expectedDetailRevision.trim() }

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

@@ -31,7 +31,7 @@ export class WorkspaceSyncJournalReader {
             CAST(lifecycle_revision AS TEXT) AS lifecycle_revision, content_sha256,
             CAST(size_bytes AS TEXT) AS size_bytes, payload_json, occurred_at FROM workspace_sync_journal
             WHERE tenant_id = ? AND workspace_id = ? AND sequence > ? AND sequence <= ?
-            ORDER BY sequence ASC LIMIT ?`).all(input.tenantId, input.workspaceId, sequence(input.afterSequence), sequence(input.throughSequence), Math.max(1, Math.min(10_101, Math.floor(input.limit))));
+            ORDER BY workspace_sync_journal.sequence ASC LIMIT ?`).all(input.tenantId, input.workspaceId, sequence(input.afterSequence), sequence(input.throughSequence), Math.max(1, Math.min(10_101, Math.floor(input.limit))));
         return rows.map((row) => ({
             sequence: sequence(row.sequence), contractVersion: Number(row.contract_version), clientId: String(row.client_id || ''),
             operationId: String(row.operation_id || ''), domain: String(row.domain || ''),

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

@@ -0,0 +1,16 @@
+import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
+export declare const WORKSPACE_SYNC_OPERATION_RETENTION_DAYS = 90;
+export declare const WORKSPACE_SYNC_OPERATION_RETENTION_INTERVAL_MS: number;
+export declare const WORKSPACE_SYNC_OPERATION_RETENTION_BATCH_SIZE = 100;
+export declare const WORKSPACE_SYNC_OPERATION_RETENTION_WORKSPACE_LIMIT = 100;
+export interface WorkspaceSyncOperationRetentionResult {
+    deletedOutbox: number;
+    deletedResults: number;
+    remainingEligible: number;
+    workspacesProcessed: number;
+}
+export declare function pruneRetainedWorkspaceSyncOperations(input: {
+    db: DatabaseAdapter;
+    tenantId: string;
+    now?: Date;
+}): WorkspaceSyncOperationRetentionResult;

package/dist/sync/v3/workspaceSyncOperationRetentionService.js

@@ -0,0 +1,83 @@
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+export const WORKSPACE_SYNC_OPERATION_RETENTION_DAYS = 90;
+export const WORKSPACE_SYNC_OPERATION_RETENTION_INTERVAL_MS = 24 * 60 * 60_000;
+export const WORKSPACE_SYNC_OPERATION_RETENTION_BATCH_SIZE = 100;
+export const WORKSPACE_SYNC_OPERATION_RETENTION_WORKSPACE_LIMIT = 100;
+export function pruneRetainedWorkspaceSyncOperations(input) {
+    const now = input.now || new Date();
+    const cutoff = new Date(now.getTime() - WORKSPACE_SYNC_OPERATION_RETENTION_DAYS * 24 * 60 * 60_000).toISOString();
+    const workspaceRows = input.db.prepare(`
+        SELECT eligible.workspace_id
+        FROM (
+            SELECT candidate.workspace_id, candidate.updated_at AS terminal_at
+            FROM workspace_sync_outbox AS candidate
+            WHERE candidate.tenant_id = ?
+              AND candidate.status IN ('accepted', 'superseded')
+              AND candidate.updated_at < ?
+              AND NOT EXISTS (
+                  SELECT 1
+                  FROM workspace_sync_outbox AS replay
+                  WHERE replay.tenant_id = candidate.tenant_id
+                    AND replay.workspace_id = candidate.workspace_id
+                    AND replay.replay_of_client_id = candidate.client_id
+                    AND replay.replay_of_operation_id = candidate.operation_id
+              )
+            UNION ALL
+            SELECT workspace_id, updated_at AS terminal_at
+            FROM workspace_sync_operation_results
+            WHERE tenant_id = ? AND status = 'committed' AND updated_at < ?
+        ) AS eligible
+        GROUP BY eligible.workspace_id
+        ORDER BY MIN(eligible.terminal_at), eligible.workspace_id
+        LIMIT ?
+    `).all(input.tenantId, cutoff, input.tenantId, cutoff, WORKSPACE_SYNC_OPERATION_RETENTION_WORKSPACE_LIMIT);
+    const store = new WorkspaceSyncDurabilityStore(input.db);
+    let deletedOutbox = 0;
+    let deletedResults = 0;
+    for (const row of workspaceRows) {
+        const workspaceId = String(row.workspace_id || '').trim();
+        if (!workspaceId)
+            continue;
+        const outboxResult = store.pruneTerminalOutboxOperations({
+            tenantId: input.tenantId,
+            workspaceId,
+            terminalBefore: cutoff,
+            limit: WORKSPACE_SYNC_OPERATION_RETENTION_BATCH_SIZE,
+        });
+        deletedOutbox += outboxResult.deleted;
+        const result = store.pruneCommittedOperationResults({
+            tenantId: input.tenantId,
+            workspaceId,
+            terminalBefore: cutoff,
+            limit: WORKSPACE_SYNC_OPERATION_RETENTION_BATCH_SIZE,
+        });
+        deletedResults += result.deleted;
+    }
+    const remaining = input.db.prepare(`
+        SELECT (
+            SELECT COUNT(*)
+            FROM workspace_sync_outbox AS candidate
+            WHERE candidate.tenant_id = ?
+              AND candidate.status IN ('accepted', 'superseded')
+              AND candidate.updated_at < ?
+              AND NOT EXISTS (
+                  SELECT 1
+                  FROM workspace_sync_outbox AS replay
+                  WHERE replay.tenant_id = candidate.tenant_id
+                    AND replay.workspace_id = candidate.workspace_id
+                    AND replay.replay_of_client_id = candidate.client_id
+                    AND replay.replay_of_operation_id = candidate.operation_id
+              )
+        ) + (
+            SELECT COUNT(*)
+            FROM workspace_sync_operation_results
+            WHERE tenant_id = ? AND status = 'committed' AND updated_at < ?
+        ) AS count
+    `).get(input.tenantId, cutoff, input.tenantId, cutoff);
+    return {
+        deletedOutbox,
+        deletedResults,
+        remainingEligible: Number(remaining?.count || 0),
+        workspacesProcessed: workspaceRows.length,
+    };
+}

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

@@ -46,6 +46,7 @@ export type WorkspaceSyncV3CloudOperationContext = {
     /** @deprecated Prefer resolveOriginActorRef; retained for create callers. */
     resolveTaskCreateActorRef?: (originActor: NonNullable<WorkspaceSyncV3TaskCreateEnvelope['operation']['payload']['originActor']>) => string;
     onPostCommitError?: (error: unknown) => void;
+    includeWorkflowRuntimeJournal?: boolean;
 };
 export type WorkspaceSyncV3CloudOperationHandler = {
     key: string;

package/dist/sync/v3/workspaceSyncV3CloudOperationHandler.js

@@ -197,6 +197,7 @@ export function createWorkspaceSyncV3CloudOperationHandlers() {
                     taskId: operation.entityId,
                     payload,
                     expectedDetailRevision,
+                    includeWorkflowRuntimeJournal: context.includeWorkflowRuntimeJournal,
                     assertPrecondition: expectedDetailRevision && context.core.assertTaskDetailRevisionForUpdate
                         ? () => context.core.assertTaskDetailRevisionForUpdate(operation.entityId, expectedDetailRevision, context.workspaceId)
                         : undefined,
@@ -237,10 +238,16 @@ export function createWorkspaceSyncV3CloudOperationHandlers() {
             supports: (envelope) => envelope.operation.domain === 'task-checklist' && envelope.operation.mutationKind === 'replace',
             apply: (envelope, context) => {
                 const operation = envelope.operation;
+                const { originActor, expectedDetailRevision, itemUpdateIntent, items } = operation.payload;
                 return runDurableTaskChecklistReplace({
-                    ...withDeferredOriginActor(context, operation.payload.originActor),
+                    ...withDeferredOriginActor(context, originActor),
                     taskId: operation.entityId,
-                    items: operation.payload.items,
+                    items,
+                    expectedDetailRevision,
+                    itemUpdateIntent,
+                    assertPrecondition: expectedDetailRevision && context.core.assertTaskDetailRevisionForUpdate
+                        ? () => context.core.assertTaskDetailRevisionForUpdate(operation.entityId, expectedDetailRevision, context.workspaceId)
+                        : undefined,
                     baseEntityRevision: operation.baseEntityRevision,
                     baseLifecycleRevision: operation.baseLifecycleRevision,
                 });

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

@@ -6,6 +6,7 @@ export declare function prepareWorkspaceSyncV3CombinedRepairSnapshot(input: {
     now?: string;
     nestedCoverage?: boolean;
     workflowCoverage?: boolean;
+    workflowTaskCoverCoverage?: boolean;
     planningOrderCoverage?: boolean;
     taskCoverCoverage?: boolean;
     coveredLegacyWritesFenced?: boolean;
@@ -42,6 +43,12 @@ export declare function prepareWorkspaceSyncV3TaskCoverRepairSnapshot(input: {
     now?: string;
     coveredLegacyWritesFenced?: boolean;
 }): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
+export declare function prepareWorkspaceSyncV3WorkflowTaskCoverRepairSnapshot(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+    now?: string;
+    coveredLegacyWritesFenced?: boolean;
+}): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
 export declare function ensureWorkspaceSyncV3CombinedRepairBaselines(input: {
     core: TaskforceCore;
     workspaceId: string;

package/dist/sync/v3/workspaceSyncV3CombinedRepairBaseline.js

@@ -3,12 +3,13 @@ import { serializeInitiativeForSync, serializeWorkstreamForSync } from '../plann
 import { serializeTaskForSync } from '../taskSyncPayload.js';
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 import { WORKSPACE_SYNC_COMBINED_PROJECTION, fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, WorkspaceSyncRevisionConflictError, } from './syncDurabilityStore.js';
-import { buildWorkspaceSyncV3CombinedRepairSnapshot, buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates, buildWorkspaceSyncV3NestedRepairSnapshot, buildWorkspaceSyncV3PlanningOrderRepairSnapshot, buildWorkspaceSyncV3TaskCoverRepairSnapshot, buildWorkspaceSyncV3WorkflowRepairSnapshot, listWorkspaceSyncV3CombinedRepairCandidates, listWorkspaceSyncV3NestedRepairCandidates, listWorkspaceSyncV3PlanningOrderRepairCandidates, listWorkspaceSyncV3TaskCoverRepairCandidates, listWorkspaceSyncV3WorkflowRepairCandidates, } from './workspaceSyncV3CombinedRepairSnapshot.js';
+import { buildWorkspaceSyncV3CombinedRepairSnapshot, buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates, buildWorkspaceSyncV3NestedRepairSnapshot, buildWorkspaceSyncV3PlanningOrderRepairSnapshot, buildWorkspaceSyncV3TaskCoverRepairSnapshot, buildWorkspaceSyncV3WorkflowRepairSnapshot, buildWorkspaceSyncV3WorkflowTaskCoverRepairSnapshot, listWorkspaceSyncV3CombinedRepairCandidates, listWorkspaceSyncV3NestedRepairCandidates, listWorkspaceSyncV3PlanningOrderRepairCandidates, listWorkspaceSyncV3TaskCoverRepairCandidates, listWorkspaceSyncV3WorkflowRepairCandidates, listWorkspaceSyncV3WorkflowTaskCoverRepairCandidates, } from './workspaceSyncV3CombinedRepairSnapshot.js';
 import { WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE } from './workspaceSyncV3CombinedCoverage.js';
 import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE } from './workspaceSyncV3NestedCoverage.js';
 import { WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE } from './workspaceSyncV3WorkflowCoverage.js';
 import { WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE } from './workspaceSyncV3PlanningOrderCoverage.js';
 import { WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE } from './workspaceSyncV3TaskCoverCoverage.js';
+import { WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE } from './workspaceSyncV3WorkflowTaskCoverCoverage.js';
 import { serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskCommentsPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
 import { projectWorkspaceSyncV3NestedTaskJournalRow } from './workspaceSyncV3NestedTaskProjection.js';
 import { serializeTaskRelationshipForSync } from './workspaceSyncV3TaskRelationshipProjection.js';
@@ -261,15 +262,17 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
         `).get(tenantId, workspaceId, now);
         sequence(lock?.last_sequence);
         const lockCompletedAt = Date.now();
-        const candidates = input.workflowCoverage
-            ? listWorkspaceSyncV3WorkflowRepairCandidates(input.core, workspaceId)
-            : input.taskCoverCoverage
-                ? listWorkspaceSyncV3TaskCoverRepairCandidates(input.core, workspaceId)
-                : input.planningOrderCoverage
-                    ? listWorkspaceSyncV3PlanningOrderRepairCandidates(input.core, workspaceId)
-                    : input.nestedCoverage
-                        ? listWorkspaceSyncV3NestedRepairCandidates(input.core, workspaceId)
-                        : listWorkspaceSyncV3CombinedRepairCandidates(input.core, workspaceId);
+        const candidates = input.workflowTaskCoverCoverage
+            ? listWorkspaceSyncV3WorkflowTaskCoverRepairCandidates(input.core, workspaceId)
+            : input.workflowCoverage
+                ? listWorkspaceSyncV3WorkflowRepairCandidates(input.core, workspaceId)
+                : input.taskCoverCoverage
+                    ? listWorkspaceSyncV3TaskCoverRepairCandidates(input.core, workspaceId)
+                    : input.planningOrderCoverage
+                        ? listWorkspaceSyncV3PlanningOrderRepairCandidates(input.core, workspaceId)
+                        : input.nestedCoverage
+                            ? listWorkspaceSyncV3NestedRepairCandidates(input.core, workspaceId)
+                            : listWorkspaceSyncV3CombinedRepairCandidates(input.core, workspaceId);
         const inventoryCompletedAt = Date.now();
         const keys = candidates.map((candidate) => `${candidate.domain}\0${candidate.entityId}`);
         if (new Set(keys).size !== keys.length)
@@ -551,15 +554,17 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
                 throw repairConflict('legacy-nested-repair-raced', repair.candidate);
         }
         const baselineWritesCompletedAt = Date.now();
-        const profile = input.workflowCoverage
-            ? WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE
-            : input.taskCoverCoverage
-                ? WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE
-                : input.planningOrderCoverage
-                    ? WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE
-                    : input.nestedCoverage
-                        ? WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE
-                        : WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE;
+        const profile = input.workflowTaskCoverCoverage
+            ? WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE
+            : input.workflowCoverage
+                ? WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE
+                : input.taskCoverCoverage
+                    ? WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE
+                    : input.planningOrderCoverage
+                        ? WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE
+                        : input.nestedCoverage
+                            ? WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE
+                            : WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE;
         const activeOwner = db.prepare(`
             SELECT 1 AS active
             FROM workspace_sync_projection_state
@@ -580,28 +585,32 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
                 inventory: candidates,
                 nestedCoverage: input.nestedCoverage === true,
                 workflowCoverage: input.workflowCoverage === true,
+                workflowTaskCoverCoverage: input.workflowTaskCoverCoverage === true,
                 planningOrderCoverage: input.planningOrderCoverage === true,
                 taskCoverCoverage: input.taskCoverCoverage === true,
             })
-            : input.workflowCoverage
-                ? buildWorkspaceSyncV3WorkflowRepairSnapshot({ core: input.core, workspaceId })
-                : input.taskCoverCoverage
-                    ? buildWorkspaceSyncV3TaskCoverRepairSnapshot({ core: input.core, workspaceId })
-                    : input.planningOrderCoverage
-                        ? buildWorkspaceSyncV3PlanningOrderRepairSnapshot({ core: input.core, workspaceId })
-                        : input.nestedCoverage
-                            ? buildWorkspaceSyncV3NestedRepairSnapshot({ core: input.core, workspaceId })
-                            : buildWorkspaceSyncV3CombinedRepairSnapshot({ core: input.core, workspaceId });
+            : input.workflowTaskCoverCoverage
+                ? buildWorkspaceSyncV3WorkflowTaskCoverRepairSnapshot({ core: input.core, workspaceId })
+                : input.workflowCoverage
+                    ? buildWorkspaceSyncV3WorkflowRepairSnapshot({ core: input.core, workspaceId })
+                    : input.taskCoverCoverage
+                        ? buildWorkspaceSyncV3TaskCoverRepairSnapshot({ core: input.core, workspaceId })
+                        : input.planningOrderCoverage
+                            ? buildWorkspaceSyncV3PlanningOrderRepairSnapshot({ core: input.core, workspaceId })
+                            : input.nestedCoverage
+                                ? buildWorkspaceSyncV3NestedRepairSnapshot({ core: input.core, workspaceId })
+                                : buildWorkspaceSyncV3CombinedRepairSnapshot({ core: input.core, workspaceId });
         const snapshotCompletedAt = Date.now();
         if (snapshot.snapshotSequence !== highWatermark) {
             throw new Error('Combined repair baseline snapshot sequence changed while locked.');
         }
         console.info('[Taskforce Sync Repair Baseline Timing]', JSON.stringify({
             workspaceId,
-            coverage: input.workflowCoverage ? 'workflow'
-                : input.taskCoverCoverage ? 'task-cover'
-                    : input.planningOrderCoverage ? 'planning-order'
-                        : input.nestedCoverage ? 'nested' : 'combined',
+            coverage: input.workflowTaskCoverCoverage ? 'workflow-task-cover'
+                : input.workflowCoverage ? 'workflow'
+                    : input.taskCoverCoverage ? 'task-cover'
+                        : input.planningOrderCoverage ? 'planning-order'
+                            : input.nestedCoverage ? 'nested' : 'combined',
             candidates: candidates.length,
             lock: lockCompletedAt - startedAt,
             inventory: inventoryCompletedAt - lockCompletedAt,
@@ -627,6 +636,9 @@ export function prepareWorkspaceSyncV3PlanningOrderRepairSnapshot(input) {
 export function prepareWorkspaceSyncV3TaskCoverRepairSnapshot(input) {
     return prepareWorkspaceSyncV3CombinedRepairSnapshot({ ...input, taskCoverCoverage: true });
 }
+export function prepareWorkspaceSyncV3WorkflowTaskCoverRepairSnapshot(input) {
+    return prepareWorkspaceSyncV3CombinedRepairSnapshot({ ...input, workflowTaskCoverCoverage: true });
+}
 export function ensureWorkspaceSyncV3CombinedRepairBaselines(input) {
     const { snapshot: _snapshot, ...result } = prepareWorkspaceSyncV3CombinedRepairSnapshot(input);
     return result;