@taskforcehq/taskforce 0.3.327 → 0.3.329

package/dist/sync/v3/workspaceSyncV3AttachmentAssetHydration.js

@@ -3,20 +3,48 @@ import { fingerprintWorkspaceContentBody } from '../workspaceContentManifest.js'
 export async function hydrateWorkspaceSyncV3AttachmentAsset(input) {
     const remoteServices = input.remoteServices;
     const applyV2Batch = input.localServices.applyV2Batch;
+    const completionIdentity = `attachment-asset:${input.assetId}`;
     const response = await remoteServices.pullWorkspaceContent({
         workspaceId: input.workspaceId,
         requests: [{ kind: 'asset', assetId: input.assetId }],
         previousCursor: null,
+        independentCompletionIdentity: completionIdentity,
     });
     const receipt = response.transferReceipt;
     let transferCommitted = false;
+    let localApplyStarted = false;
     try {
         if (!response.ok) {
             return { success: false, error: `Workspace attachment asset hydration failed (${response.status || 0}).` };
         }
         const data = response.data || {};
-        if ((data.missing?.length || 0) > 0 || (data.remaining?.length || 0) > 0) {
-            return { success: false, error: `Workspace attachment asset is unavailable in cloud content: ${input.assetId}` };
+        if ((data.remaining?.length || 0) > 0) {
+            return {
+                success: false,
+                error: `Workspace attachment asset hydration is incomplete: ${input.assetId}`,
+                disposition: 'retryable',
+            };
+        }
+        const exactMissing = Array.isArray(data.missing) && data.missing.find((entry) => (entry?.kind === 'asset'
+            && 'assetId' in entry
+            && String(entry.assetId || '').trim() === input.assetId));
+        if (exactMissing) {
+            return {
+                success: false,
+                error: exactMissing.disposition === 'terminal-unavailable'
+                    ? `Workspace attachment asset is authoritatively unavailable in cloud metadata: ${input.assetId}`
+                    : `Workspace attachment asset body is temporarily unavailable in cloud content: ${input.assetId}`,
+                disposition: exactMissing.disposition === 'terminal-unavailable'
+                    ? 'terminal-unavailable'
+                    : 'retryable',
+            };
+        }
+        if ((data.missing?.length || 0) > 0) {
+            return {
+                success: false,
+                error: `Workspace attachment asset hydration returned an unexpected missing result: ${input.assetId}`,
+                disposition: 'retryable',
+            };
         }
         const rawChanges = Array.isArray(data.changes) ? data.changes : [];
         const changes = rawChanges.filter((change) => ((change.op === 'document-upsert' || change.op === 'asset-upsert')
@@ -50,10 +78,9 @@ export async function hydrateWorkspaceSyncV3AttachmentAsset(input) {
             return { success: false, error: `Workspace attachment asset hydration verification failed: ${input.assetId}` };
         }
         const completionGroup = receipt
-            ? remoteServices.buildV2ApplyCompletionGroup({
+            ? remoteServices.buildIndependentContentApplyCompletionGroup({
                 workspaceId: input.workspaceId,
-                previousCursor: null,
-                nextCursor: null,
+                identity: completionIdentity,
                 receipts: [receipt],
             })
             : undefined;
@@ -63,6 +90,7 @@ export async function hydrateWorkspaceSyncV3AttachmentAsset(input) {
                 error: 'Workspace attachment asset hydration could not bind its transfer to local apply.',
             };
         }
+        localApplyStarted = true;
         const applyResult = completionGroup
             ? await applyV2Batch(input.workspaceId, changes, { completionGroup })
             : await applyV2Batch(input.workspaceId, changes);
@@ -80,11 +108,25 @@ export async function hydrateWorkspaceSyncV3AttachmentAsset(input) {
     }
     finally {
         if (receipt && !transferCommitted) {
-            await remoteServices.abandonTransferReceipts({
-                workspaceId: input.workspaceId,
-                receipts: [receipt],
-                errorCode: 'WORKSPACE_SYNC_V3_ATTACHMENT_HYDRATION_NOT_COMMITTED',
-            });
+            if (!localApplyStarted) {
+                const completionGroup = remoteServices.buildIndependentContentApplyCompletionGroup({
+                    workspaceId: input.workspaceId,
+                    identity: completionIdentity,
+                    receipts: [receipt],
+                });
+                if (completionGroup) {
+                    localApplyStarted = true;
+                    const settlement = await applyV2Batch(input.workspaceId, [], { completionGroup });
+                    transferCommitted = settlement.ok;
+                }
+            }
+            if (!transferCommitted) {
+                await remoteServices.abandonTransferReceipts({
+                    workspaceId: input.workspaceId,
+                    receipts: [receipt],
+                    errorCode: 'WORKSPACE_SYNC_V3_ATTACHMENT_HYDRATION_NOT_COMMITTED',
+                });
+            }
         }
     }
 }

package/dist/sync/v3/workspaceSyncV3CloudOperationHandler.js

@@ -71,6 +71,10 @@ export function createWorkspaceSyncV3CloudOperationHandlers() {
                     ...withDeferredOriginActor(context, operation.payload.originActor),
                     taskId: operation.entityId, patch: operation.payload.patch,
                     saveSource: operation.payload.saveSource,
+                    expectedDetailRevision: operation.payload.expectedDetailRevision,
+                    assertPrecondition: operation.payload.expectedDetailRevision && context.core.assertTaskDetailRevisionForUpdate
+                        ? () => context.core.assertTaskDetailRevisionForUpdate(operation.entityId, operation.payload.expectedDetailRevision, context.workspaceId)
+                        : undefined,
                     baseEntityRevision: operation.baseEntityRevision, baseLifecycleRevision: operation.baseLifecycleRevision,
                 });
             },
@@ -187,11 +191,15 @@ export function createWorkspaceSyncV3CloudOperationHandlers() {
             supports: (envelope) => envelope.operation.domain === 'task' && envelope.operation.mutationKind === 'set-status',
             apply: (envelope, context) => {
                 const operation = envelope.operation;
-                const { originActor, ...payload } = operation.payload;
+                const { originActor, expectedDetailRevision, ...payload } = operation.payload;
                 return runDurableTaskStatusMutation({
                     ...withDeferredOriginActor(context, originActor),
                     taskId: operation.entityId,
                     payload,
+                    expectedDetailRevision,
+                    assertPrecondition: expectedDetailRevision && context.core.assertTaskDetailRevisionForUpdate
+                        ? () => context.core.assertTaskDetailRevisionForUpdate(operation.entityId, expectedDetailRevision, context.workspaceId)
+                        : undefined,
                     baseEntityRevision: operation.baseEntityRevision,
                     baseLifecycleRevision: operation.baseLifecycleRevision,
                 });
@@ -261,6 +269,7 @@ export function createWorkspaceSyncV3CloudOperationHandlers() {
                     ...withDeferredOriginActor(context, operation.payload.originActor),
                     taskId: operation.entityId,
                     links: operation.payload.links,
+                    cardCoverAssetId: operation.payload.cardCoverAssetId,
                     baseEntityRevision: operation.baseEntityRevision,
                     baseLifecycleRevision: operation.baseLifecycleRevision,
                 });

package/dist/sync/v3/workspaceSyncV3CombinedFeedOrchestrator.js

@@ -221,6 +221,12 @@ function peerReadinessError(response) {
         ? `Cloud combined workspace sync prerequisite is not ready (${firstMissing}).`
         : 'Cloud combined workspace sync capability attestation is missing or incompatible.';
 }
+function repairResponseError(response, workspaceId, expected) {
+    const code = String(response.data?.code || '').trim();
+    return code && !['CURSOR_EXPIRED', 'COVERAGE_CHANGED', 'EXPLICIT_REPAIR'].includes(code)
+        ? invalidRepairResponseError(response, workspaceId, expected)
+        : peerReadinessError(response);
+}
 function isUnavailablePersistedRepairCursor(response) {
     if (response.data?.success !== false)
         return false;
@@ -319,10 +325,14 @@ async function runWorkspaceSyncV3CombinedProjectionCycleInternal(input, staleRep
     let projection = initial;
     let recoveryRepairApplied = false;
     let restartStaleRepair = false;
+    let restartCoverageRepair = false;
     let restartedStaleRepair = staleRepairAlreadyRestarted;
     const persistedCoverage = projectionCoverage(projection);
     if (!persistedCoverage)
         return localFailure(projection, 'Persisted combined workspace sync coverage is unsupported.');
+    restartCoverageRepair = projection.owner === 'v3'
+        && projection.repair !== null
+        && !exactCoverage(persistedCoverage, coverage);
     if (projection.coverageRepairRequired
         || (projection.owner === 'v3' && !projection.repair && !exactCoverage(persistedCoverage, coverage))) {
         const feed = await dependencies.pullFeed(input.resolveCloudAuthUrl, {
@@ -407,12 +417,12 @@ async function runWorkspaceSyncV3CombinedProjectionCycleInternal(input, staleRep
     }
     let restartExpiredRepair = false;
     let restartedExpiredRepair = false;
-    while (projection.owner === 'v2' || projection.repair || restartStaleRepair) {
-        const previousCursor = restartExpiredRepair || restartStaleRepair
+    while (projection.owner === 'v2' || projection.repair || restartStaleRepair || restartCoverageRepair) {
+        const previousCursor = restartExpiredRepair || restartStaleRepair || restartCoverageRepair
             ? null : projection.repair?.cursor || null;
         const feed = await dependencies.pullFeed(input.resolveCloudAuthUrl, {
             workspaceId: input.workspaceId,
-            ...(restartExpiredRepair || restartStaleRepair
+            ...(restartExpiredRepair || restartStaleRepair || restartCoverageRepair
                 ? { forceRepair: true }
                 : { repairCursor: previousCursor }),
             limit: 100,
@@ -431,7 +441,7 @@ async function runWorkspaceSyncV3CombinedProjectionCycleInternal(input, staleRep
         }
         const repair = repairFromFeed(feed, input.workspaceId, coverage);
         if (!repair)
-            return localFailure(projection, peerReadinessError(feed));
+            return localFailure(projection, repairResponseError(feed, input.workspaceId, coverage));
         const applied = await applySelectedProjection(dependencies, input.workspaceId, {
             kind: 'repair', epoch: projection.epoch, previousCursor, page: repair,
             ...(input.recoveryBatchId ? { recoveryBatchId: input.recoveryBatchId } : {}),
@@ -443,6 +453,7 @@ async function runWorkspaceSyncV3CombinedProjectionCycleInternal(input, staleRep
         projection = updated;
         restartExpiredRepair = false;
         restartStaleRepair = false;
+        restartCoverageRepair = false;
         if (repairSnapshotWasInvalidated(applied)) {
             if (restartedStaleRepair) {
                 return localFailure(projection, 'A refreshed combined repair snapshot still predates authoritative local state.');

package/dist/sync/v3/workspaceSyncV3CombinedLocalApply.js

@@ -6,7 +6,7 @@ import { validateWorkspaceSyncV3CombinedRepairPage, WorkspaceSyncV3CombinedProje
 import { fingerprintWorkspaceSyncPayload, WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
 import { WorkflowStore } from '../../storage/workflowStore.js';
 import { serializeTaskRelationshipForSync } from './workspaceSyncV3TaskRelationshipProjection.js';
-import { serializeWorkspaceSyncV3EntityEventPayload, serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskChecklistPayload, serializeWorkspaceSyncV3TaskCommentsPayload, validateWorkspaceSyncV3EntityEventPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+import { serializeWorkspaceSyncV3EntityEventPayload, serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskAttachmentLinksV2Payload, serializeWorkspaceSyncV3TaskChecklistPayload, serializeWorkspaceSyncV3TaskCommentsPayload, validateWorkspaceSyncV3EntityEventPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
 import { applyWorkspaceSyncV3NestedTaskEntries, WorkspaceSyncV3TaskCommentAggregateDivergenceError, } from './workspaceSyncV3NestedTaskApply.js';
 import { LocalSyncIdentityStore } from './localSyncIdentityStore.js';
 import { enqueueLocalTaskCommentReconciliation } from './localTaskCommentOutboxService.js';
@@ -25,7 +25,8 @@ function combinedRepairBaselineMarker(page) {
     })}`;
 }
 const NESTED_TASK_PROJECTIONS = new Set([
-    'task-comments/full-v1', 'task-checklist/full-v1', 'task-attachment-links/full-v1', 'entity-event/full-v1',
+    'task-comments/full-v1', 'task-checklist/full-v1', 'task-attachment-links/full-v1',
+    'task-attachment-links/full-v2', 'entity-event/full-v1',
 ]);
 const WORKFLOW_RUNTIME_PROJECTIONS = new Set([
     'workflow-published-definition/full-v2',
@@ -59,7 +60,8 @@ function coveredDomains(projections) {
         domains.push('task-comments');
     if (projections.has('task-checklist/full-v1'))
         domains.push('task-checklist');
-    if (projections.has('task-attachment-links/full-v1'))
+    if (projections.has('task-attachment-links/full-v1')
+        || projections.has('task-attachment-links/full-v2'))
         domains.push('task-attachment-links');
     if (projections.has('entity-event/full-v1'))
         domains.push('entity-event');
@@ -172,6 +174,24 @@ function isExactNestedProjectionReplay(input) {
         && input.current.lastSequence === input.entry.sequence
         && input.current.canonicalFingerprint === (input.entry.canonicalFingerprint || input.entry.payloadFingerprint);
 }
+function isExactPlanningRootProjectionReplay(input) {
+    return (input.entry.projection === 'initiative/full-v1'
+        || input.entry.projection === 'workstream/full-v1')
+        && input.current.owned
+        && input.current.entityRevision === input.entry.entityRevision
+        && input.current.lifecycleRevision === input.entry.lifecycleRevision
+        && input.current.lastSequence === input.entry.sequence
+        && input.current.canonicalFingerprint === (input.entry.canonicalFingerprint || input.entry.payloadFingerprint);
+}
+function parentOwnedNestedTaskId(entry) {
+    if (entry.projection === 'task-comments/full-v1'
+        || entry.projection === 'task-checklist/full-v1'
+        || entry.projection === 'task-attachment-links/full-v1'
+        || entry.projection === 'task-attachment-links/full-v2') {
+        return entry.entityId;
+    }
+    return null;
+}
 function applyEntries(input) {
     const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
     const workflowApply = prepareWorkspaceSyncV3WorkflowRuntimeApply({
@@ -191,13 +211,18 @@ function applyEntries(input) {
                 throw coveredLocalOperationsError('Combined feed apply is blocked by covered local operations.');
             }
             const notices = notifications();
+            const deletedTaskRoots = new Set();
             for (const entry of input.entries) {
                 let taskChange = null;
                 let nestedTaskChangeId = null;
+                const nestedTaskId = parentOwnedNestedTaskId(entry);
+                if (nestedTaskId && deletedTaskRoots.has(nestedTaskId))
+                    continue;
                 const current = store.readWorkspaceDomainOwnership({ tenantId: input.tenantId,
                     workspaceId: input.workspaceId, domain: entry.domain, entityId: entry.entityId });
                 const exactTaskRootReplay = isExactTaskRootProjectionReplay({ entry, current });
                 const exactNestedReplay = isExactNestedProjectionReplay({ entry, current });
+                const exactPlanningRootReplay = isExactPlanningRootProjectionReplay({ entry, current });
                 const applyEntry = () => {
                     if (entry.projection === 'task/root-v1') {
                         taskChange = applyTaskEntry({ core: input.core, workspaceId: input.workspaceId, entry });
@@ -259,7 +284,7 @@ function applyEntries(input) {
                     }
                 };
                 let applied;
-                if (exactTaskRootReplay || exactNestedReplay) {
+                if (exactTaskRootReplay || exactNestedReplay || exactPlanningRootReplay) {
                     const result = applyEntry();
                     applied = result?.state === 'deferred'
                         ? { state: 'deferred' }
@@ -278,6 +303,16 @@ function applyEntries(input) {
                         shouldRecordRevision: (result) => result?.state !== 'deferred',
                     });
                 }
+                if (entry.projection === 'task/root-v1') {
+                    if (taskChange === 'upsert') {
+                        deletedTaskRoots.delete(entry.entityId);
+                    }
+                    else if (taskChange === 'delete'
+                        || (!input.core.getTask(entry.entityId, input.workspaceId)
+                            && input.core.hasTaskDeletionMarkerForSync(entry.entityId, input.workspaceId))) {
+                        deletedTaskRoots.add(entry.entityId);
+                    }
+                }
                 if (applied.state !== 'applied')
                     continue;
                 if (entry.projection === 'task/root-v1' && entry.mutationKind !== 'delete') {
@@ -356,12 +391,19 @@ function listLocalTaskNestedProjection(core, workspaceId, projection) {
                     taskId: task.id, items: task.checklistItems || [],
                 }));
             }
-            else {
+            else if (projection === 'task-attachment-links/full-v1') {
                 values.set(task.id, serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
                     taskId: task.id,
                     links: core.listTaskAttachmentLinksForDurableSync(task.id, workspaceId),
                 }));
             }
+            else {
+                values.set(task.id, serializeWorkspaceSyncV3TaskAttachmentLinksV2Payload({
+                    taskId: task.id,
+                    links: core.listTaskAttachmentLinksForDurableSync(task.id, workspaceId),
+                    cardCoverAssetId: task.cardCoverAssetId ?? null,
+                }));
+            }
         }
         const last = page.at(-1);
         cursor = page.length === 1000 && last
@@ -406,6 +448,9 @@ function nestedLocalDomains(core, workspaceId, projections, liveEntityIds) {
     if (projections.has('task-attachment-links/full-v1')) {
         domains.push(['task-attachment-links', listLocalTaskNestedProjection(core, workspaceId, 'task-attachment-links/full-v1')]);
     }
+    else if (projections.has('task-attachment-links/full-v2')) {
+        domains.push(['task-attachment-links', listLocalTaskNestedProjection(core, workspaceId, 'task-attachment-links/full-v2')]);
+    }
     if (projections.has('entity-event/full-v1')) {
         domains.push(['entity-event', listLocalEntityEvents(core, workspaceId, liveEntityIds)]);
     }
@@ -550,13 +595,18 @@ function isCompatibleLegacyAttachmentLinks(core, workspaceId, local, incoming) {
             if (!value || typeof value !== 'object' || Array.isArray(value))
                 return false;
             const incomingLink = value;
-            if (localLink.role !== incomingLink.role)
-                return false;
             const localAsset = store.get(String(localLink.assetId || ''), workspaceId);
             const incomingAsset = store.get(String(incomingLink.assetId || ''), workspaceId);
             if (!localAsset || !incomingAsset || localAsset.deletedAt || incomingAsset.deletedAt
                 || localAsset.storageKey !== incomingAsset.storageKey)
                 return false;
+            const compatibleRole = localLink.role === incomingLink.role
+                || (localAsset.storageProvider === 'external'
+                    && localLink.role === 'reference'
+                    && incomingAsset.storageProvider !== 'external'
+                    && incomingLink.role === (incomingAsset.kind === 'image' ? 'image' : 'attachment'));
+            if (!compatibleRole)
+                return false;
             const sameContent = localAsset.contentSha256 === incomingAsset.contentSha256
                 && localAsset.sizeBytes === incomingAsset.sizeBytes;
             const authoritativeMaterialization = localAsset.storageProvider === 'external'
@@ -574,15 +624,15 @@ function isCompatibleLegacyAttachmentLinks(core, workspaceId, local, incoming) {
                 if (!value || typeof value !== 'object' || Array.isArray(value))
                     return false;
                 const incomingLink = value;
-                if (localLink.role !== incomingLink.role)
-                    return false;
                 const incomingAsset = store.get(String(incomingLink.assetId || ''), workspaceId);
                 return Boolean(incomingAsset && !incomingAsset.deletedAt
                     && incomingAsset.storageProvider !== 'external'
+                    && localLink.role === 'reference'
+                    && incomingLink.role === (incomingAsset.kind === 'image' ? 'image' : 'attachment')
                     && incomingAsset.storageKey === localAsset.storageKey
                     && incomingAsset.sizeBytes >= localAsset.sizeBytes);
             }));
-    }) && unmatched.length === 0;
+    });
     return compatible;
 }
 function assertLocalInventoryReady(input) {
@@ -957,25 +1007,28 @@ export function applyWorkspaceSyncV3CombinedRepairPage(input) {
         })();
     }
     const recoveryTargets = recoveryBatchId
-        ? recoveryStore.listOutboxRecoveryTargets({ tenantId, workspaceId, recoveryBatchId })
+        ? recoveryStore.listOutboxRecoveryBaselineTargets({ tenantId, workspaceId, recoveryBatchId })
         : [];
     const selectRecoveryEntries = (entries) => {
         const byTarget = new Map(entries.map((entry) => [`${entry.domain}\0${entry.entityId}`, entry]));
         return recoveryTargets.map((target) => {
             const entry = byTarget.get(`${target.domain}\0${target.entityId}`);
             if (!entry) {
+                if (!target.required)
+                    return null;
                 throw staleRepairSnapshotError(target.domain, target.entityId);
             }
             const supportedTarget = ((target.domain === 'task' && entry.projection === 'task/root-v1')
                 || (target.domain === 'task-comments' && entry.projection === 'task-comments/full-v1')
                 || (target.domain === 'task-attachment-links'
-                    && entry.projection === 'task-attachment-links/full-v1')
+                    && (entry.projection === 'task-attachment-links/full-v1'
+                        || entry.projection === 'task-attachment-links/full-v2'))
                 || (target.domain === 'entity-event' && entry.projection === 'entity-event/full-v1'));
             if (!supportedTarget) {
                 throw new Error('Targeted workspace sync recovery does not support this projection.');
             }
             return entry;
-        });
+        }).filter((entry) => entry !== null);
     };
     const projections = coveredProjections(input.page);
     let notices = notifications();

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

@@ -7,6 +7,8 @@ export declare function prepareWorkspaceSyncV3CombinedRepairSnapshot(input: {
     nestedCoverage?: boolean;
     workflowCoverage?: boolean;
     planningOrderCoverage?: boolean;
+    taskCoverCoverage?: boolean;
+    coveredLegacyWritesFenced?: boolean;
 }): {
     highWatermark: string;
     insertedEntities: number;
@@ -20,16 +22,25 @@ export declare function prepareWorkspaceSyncV3NestedRepairSnapshot(input: {
     core: TaskforceCore;
     workspaceId: string;
     now?: string;
+    coveredLegacyWritesFenced?: boolean;
 }): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
 export declare function prepareWorkspaceSyncV3WorkflowRepairSnapshot(input: {
     core: TaskforceCore;
     workspaceId: string;
     now?: string;
+    coveredLegacyWritesFenced?: boolean;
 }): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
 export declare function prepareWorkspaceSyncV3PlanningOrderRepairSnapshot(input: {
     core: TaskforceCore;
     workspaceId: string;
     now?: string;
+    coveredLegacyWritesFenced?: boolean;
+}): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
+export declare function prepareWorkspaceSyncV3TaskCoverRepairSnapshot(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+    now?: string;
+    coveredLegacyWritesFenced?: boolean;
 }): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
 export declare function ensureWorkspaceSyncV3CombinedRepairBaselines(input: {
     core: TaskforceCore;

package/dist/sync/v3/workspaceSyncV3CombinedRepairBaseline.js

@@ -3,16 +3,17 @@ 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, buildWorkspaceSyncV3WorkflowRepairSnapshot, listWorkspaceSyncV3CombinedRepairCandidates, listWorkspaceSyncV3NestedRepairCandidates, listWorkspaceSyncV3PlanningOrderRepairCandidates, listWorkspaceSyncV3WorkflowRepairCandidates, } from './workspaceSyncV3CombinedRepairSnapshot.js';
+import { buildWorkspaceSyncV3CombinedRepairSnapshot, buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates, buildWorkspaceSyncV3NestedRepairSnapshot, buildWorkspaceSyncV3PlanningOrderRepairSnapshot, buildWorkspaceSyncV3TaskCoverRepairSnapshot, buildWorkspaceSyncV3WorkflowRepairSnapshot, listWorkspaceSyncV3CombinedRepairCandidates, listWorkspaceSyncV3NestedRepairCandidates, listWorkspaceSyncV3PlanningOrderRepairCandidates, listWorkspaceSyncV3TaskCoverRepairCandidates, listWorkspaceSyncV3WorkflowRepairCandidates, } 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 { serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskCommentsPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
 import { projectWorkspaceSyncV3NestedTaskJournalRow } from './workspaceSyncV3NestedTaskProjection.js';
 import { serializeTaskRelationshipForSync } from './workspaceSyncV3TaskRelationshipProjection.js';
 import { projectWorkspaceSyncV3TaskRootJournalRow, serializeTaskRootForSync, } from './workspaceSyncV3TaskRootProjection.js';
-const SQL_BATCH_SIZE = 400;
+import { workspaceSyncV3RepairEntityReadBatchSize } from './workspaceSyncV3RepairSqlBatching.js';
 const BASELINE_CLIENT_ID = 'sync-v3-repair';
 const LEGACY_REPAIRABLE_NESTED_DOMAINS = new Set([
     'task-comments', 'task-checklist', 'task-attachment-links',
@@ -84,10 +85,11 @@ function lifecycleState(candidate) {
 function readRevisions(input) {
     const result = new Map();
     const db = input.core.getDatabaseAdapter();
+    const batchSize = workspaceSyncV3RepairEntityReadBatchSize(db);
     for (const domain of [...new Set(input.candidates.map((candidate) => candidate.domain))]) {
         const ids = input.candidates.filter((candidate) => candidate.domain === domain).map((candidate) => candidate.entityId);
-        for (let offset = 0; offset < ids.length; offset += SQL_BATCH_SIZE) {
-            const batch = ids.slice(offset, offset + SQL_BATCH_SIZE);
+        for (let offset = 0; offset < ids.length; offset += batchSize) {
+            const batch = ids.slice(offset, offset + batchSize);
             const placeholders = batch.map(() => '?').join(', ');
             const rows = db.prepare(`
                 SELECT entity_id, contract_version,
@@ -250,6 +252,7 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
     const tenantId = input.core.getTenantId();
     const db = input.core.getDatabaseAdapter();
     return db.transaction(() => {
+        const startedAt = Date.now();
         const lock = db.prepare(`
             INSERT INTO workspace_sync_sequences (tenant_id, workspace_id, last_sequence, updated_at)
             VALUES (?, ?, 0, ?)
@@ -257,17 +260,22 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
             RETURNING CAST(last_sequence AS TEXT) AS last_sequence
         `).get(tenantId, workspaceId, now);
         sequence(lock?.last_sequence);
+        const lockCompletedAt = Date.now();
         const candidates = input.workflowCoverage
             ? listWorkspaceSyncV3WorkflowRepairCandidates(input.core, workspaceId)
-            : input.planningOrderCoverage
-                ? listWorkspaceSyncV3PlanningOrderRepairCandidates(input.core, workspaceId)
-                : input.nestedCoverage
-                    ? listWorkspaceSyncV3NestedRepairCandidates(input.core, workspaceId)
-                    : listWorkspaceSyncV3CombinedRepairCandidates(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)
             throw new Error('Combined repair baseline contains duplicate entities.');
         const revisions = readRevisions({ core: input.core, tenantId, workspaceId, candidates });
+        const revisionsCompletedAt = Date.now();
         const missing = [];
         const legacyRelationshipSkews = [];
         const legacyNestedDrifts = [];
@@ -383,6 +391,7 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
                 });
             }
         }
+        const validationCompletedAt = Date.now();
         const rowCount = legacyRelationshipSkews.length + legacyNestedDrifts.length + missing.reduce((count, candidate) => {
             if (candidate.domain === 'workflow-published-definition'
                 || candidate.domain === 'workflow-execution'
@@ -541,13 +550,16 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
             if (Number(updated.changes) !== 1)
                 throw repairConflict('legacy-nested-repair-raced', repair.candidate);
         }
+        const baselineWritesCompletedAt = Date.now();
         const profile = input.workflowCoverage
             ? WORKSPACE_SYNC_V3_WORKFLOW_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;
+            : 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
@@ -557,9 +569,10 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
         `).get(tenantId, workspaceId, WORKSPACE_SYNC_COMBINED_PROJECTION, WORKSPACE_SYNC_CONTRACT_VERSION, profile.coverageProfileId, profile.coverageVersion, profile.coverageDigest);
         // Exact active v3 ownership closes every ordinary writer over the same
         // sequence lock, so the inventory read above remains the authoritative
-        // cut. Activation repair still re-inventories because legacy/v2 writers
-        // do not reserve that lock and could otherwise create undetectable drift.
-        const snapshot = activeOwner?.active === 1
+        // cut. The cloud activation route may attest the same invariant by
+        // fencing covered legacy/v2 writers. Unfenced rollback repair still
+        // re-inventories because those writers do not reserve this lock.
+        const snapshot = activeOwner?.active === 1 || input.coveredLegacyWritesFenced === true
             ? buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates({
                 core: input.core,
                 workspaceId,
@@ -568,17 +581,36 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
                 nestedCoverage: input.nestedCoverage === true,
                 workflowCoverage: input.workflowCoverage === true,
                 planningOrderCoverage: input.planningOrderCoverage === true,
+                taskCoverCoverage: input.taskCoverCoverage === true,
             })
             : input.workflowCoverage
                 ? buildWorkspaceSyncV3WorkflowRepairSnapshot({ core: input.core, workspaceId })
-                : input.planningOrderCoverage
-                    ? buildWorkspaceSyncV3PlanningOrderRepairSnapshot({ core: input.core, workspaceId })
-                    : input.nestedCoverage
-                        ? buildWorkspaceSyncV3NestedRepairSnapshot({ core: input.core, workspaceId })
-                        : buildWorkspaceSyncV3CombinedRepairSnapshot({ 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',
+            candidates: candidates.length,
+            lock: lockCompletedAt - startedAt,
+            inventory: inventoryCompletedAt - lockCompletedAt,
+            revisions: revisionsCompletedAt - inventoryCompletedAt,
+            validation: validationCompletedAt - revisionsCompletedAt,
+            baselineWrites: baselineWritesCompletedAt - validationCompletedAt,
+            snapshot: snapshotCompletedAt - baselineWritesCompletedAt,
+            total: snapshotCompletedAt - startedAt,
+        }));
         return { highWatermark, insertedEntities: missing.length + legacyRelationshipSkews.length + legacyNestedDrifts.length,
             insertedJournalRows: rowCount, snapshot };
     })();
@@ -592,6 +624,9 @@ export function prepareWorkspaceSyncV3WorkflowRepairSnapshot(input) {
 export function prepareWorkspaceSyncV3PlanningOrderRepairSnapshot(input) {
     return prepareWorkspaceSyncV3CombinedRepairSnapshot({ ...input, planningOrderCoverage: true });
 }
+export function prepareWorkspaceSyncV3TaskCoverRepairSnapshot(input) {
+    return prepareWorkspaceSyncV3CombinedRepairSnapshot({ ...input, taskCoverCoverage: true });
+}
 export function ensureWorkspaceSyncV3CombinedRepairBaselines(input) {
     const { snapshot: _snapshot, ...result } = prepareWorkspaceSyncV3CombinedRepairSnapshot(input);
     return result;

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

@@ -3,6 +3,7 @@ import { WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE } from './workspaceSyncV3Co
 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 { type WorkspaceSyncV3FeedEntry } from './workspaceSyncV3Feed.js';
 import { type WorkspaceSyncV3FeedCursorKeyring } from './workspaceSyncV3FeedCursorKeys.js';
 export interface WorkspaceSyncV3CombinedRepairCursor {
@@ -21,7 +22,7 @@ export interface WorkspaceSyncV3CombinedRepairPage {
     success: true;
     protocolVersion: 3;
     workspaceId: string;
-    coverage: typeof WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE;
+    coverage: typeof WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE;
     snapshotId: string;
     snapshotSequence: string;
     expiresAt: string;
@@ -47,6 +48,8 @@ export declare function decodeWorkspaceSyncV3CombinedRepairCursor(raw: string |
 export declare function decodeWorkspaceSyncV3NestedRepairCursor(raw: string | null | undefined, keyring: WorkspaceSyncV3FeedCursorKeyring): WorkspaceSyncV3CombinedRepairCursor | null;
 export declare function decodeWorkspaceSyncV3WorkflowRepairCursor(raw: string | null | undefined, keyring: WorkspaceSyncV3FeedCursorKeyring): WorkspaceSyncV3CombinedRepairCursor | null;
 export declare function decodeWorkspaceSyncV3PlanningOrderRepairCursor(raw: string | null | undefined, keyring: WorkspaceSyncV3FeedCursorKeyring): WorkspaceSyncV3CombinedRepairCursor | null;
+export declare function decodeWorkspaceSyncV3TaskCoverRepairCursor(raw: string | null | undefined, keyring: WorkspaceSyncV3FeedCursorKeyring): WorkspaceSyncV3CombinedRepairCursor | null;
+export declare const WORKSPACE_SYNC_REPAIR_SNAPSHOT_CLEANUP_BATCH_SIZE = 500;
 export declare function buildWorkspaceSyncV3CombinedRepairPage(input: {
     core: TaskforceCore;
     workspaceId: string;
@@ -59,7 +62,10 @@ export declare function buildWorkspaceSyncV3CombinedRepairPage(input: {
     nestedCoverage?: boolean;
     workflowCoverage?: boolean;
     planningOrderCoverage?: boolean;
+    taskCoverCoverage?: boolean;
+    coveredLegacyWritesFenced?: boolean;
 }): WorkspaceSyncV3CombinedRepairPage;
-export declare function buildWorkspaceSyncV3NestedRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage'>): WorkspaceSyncV3CombinedRepairPage;
-export declare function buildWorkspaceSyncV3WorkflowRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage'>): WorkspaceSyncV3CombinedRepairPage;
-export declare function buildWorkspaceSyncV3PlanningOrderRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage'>): WorkspaceSyncV3CombinedRepairPage;
+export declare function buildWorkspaceSyncV3NestedRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
+export declare function buildWorkspaceSyncV3WorkflowRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
+export declare function buildWorkspaceSyncV3PlanningOrderRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
+export declare function buildWorkspaceSyncV3TaskCoverRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;