@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/v3/workspaceSyncV3CombinedLocalApply.js

@@ -0,0 +1,1149 @@
+import { createHash } from 'crypto';
+import { serializeInitiativeForSync, serializeWorkstreamForSync } from '../planningSyncPayload.js';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { serializeTaxonomyStateForSync } from './taxonomySyncPayload.js';
+import { validateWorkspaceSyncV3CombinedRepairPage, WorkspaceSyncV3CombinedProjectionStateStore, WORKSPACE_SYNC_V3_REPAIR_SNAPSHOT_STALE, } from './workspaceSyncV3CombinedProjectionState.js';
+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 { applyWorkspaceSyncV3NestedTaskEntries, WorkspaceSyncV3TaskCommentAggregateDivergenceError, } from './workspaceSyncV3NestedTaskApply.js';
+import { LocalSyncIdentityStore } from './localSyncIdentityStore.js';
+import { enqueueLocalTaskCommentReconciliation } from './localTaskCommentOutboxService.js';
+import { buildWorkspaceSyncV3TaskCommentReconcileProvenance, indexWorkspaceSyncV3TaskCommentProvenanceEvidence, } from './taskCommentReconcileProvenance.js';
+import { serializeTaskRootForSync, } from './workspaceSyncV3TaskRootProjection.js';
+import { prepareWorkspaceSyncV3WorkflowRuntimeApply } from './workspaceSyncV3WorkflowRuntimeApply.js';
+import { serializeWorkflowExecutionEventSyncPayload, serializeWorkflowExecutionRootSyncPayload, serializeWorkflowPublishedDefinitionSyncPayload, } from './workflowRuntimeSync.js';
+import { serializeWorkstreamTaskOrderForSync } from './workstreamTaskOrderSync.js';
+import { validateWorkspaceSyncV3WorkstreamTaskOrderFeedEntry } from './workspaceSyncV3WorkstreamTaskOrderProjection.js';
+function combinedRepairBaselineMarker(page) {
+    return `combined-repair-v1:${fingerprintWorkspaceSyncPayload({
+        coverage: page.coverage,
+        snapshotId: page.snapshotId,
+        snapshotSequence: page.snapshotSequence,
+        resumeCursor: page.resumeCursor,
+    })}`;
+}
+const NESTED_TASK_PROJECTIONS = new Set([
+    'task-comments/full-v1', 'task-checklist/full-v1', 'task-attachment-links/full-v1', 'entity-event/full-v1',
+]);
+const WORKFLOW_RUNTIME_PROJECTIONS = new Set([
+    'workflow-published-definition/full-v2',
+    'workflow-execution/root-v1',
+    'workflow-execution-event/full-v1',
+]);
+function coveredLocalOperationsError(message) {
+    return Object.assign(new Error(message), {
+        code: 'WORKSPACE_SYNC_V3_COVERED_LOCAL_OPERATIONS',
+    });
+}
+function staleRepairSnapshotError(domain, entityId) {
+    return Object.assign(new Error(`Combined repair snapshot predates authoritative local ${domain}/${entityId}.`), { code: WORKSPACE_SYNC_V3_REPAIR_SNAPSHOT_STALE });
+}
+function coveredProjections(page) {
+    return new Set(page.coverage.projections.map((projection) => projection.projectionId));
+}
+function coveredDomains(projections) {
+    const domains = [];
+    if (projections.has('task/root-v1'))
+        domains.push('task');
+    if (projections.has('task-relationship/full-v1'))
+        domains.push('task-relationship');
+    if (projections.has('taxonomy/full-v1'))
+        domains.push('taxonomy');
+    if (projections.has('initiative/full-v1'))
+        domains.push('initiative');
+    if (projections.has('workstream/full-v1'))
+        domains.push('workstream');
+    if (projections.has('task-comments/full-v1'))
+        domains.push('task-comments');
+    if (projections.has('task-checklist/full-v1'))
+        domains.push('task-checklist');
+    if (projections.has('task-attachment-links/full-v1'))
+        domains.push('task-attachment-links');
+    if (projections.has('entity-event/full-v1'))
+        domains.push('entity-event');
+    if (projections.has('workflow-published-definition/full-v2'))
+        domains.push('workflow-published-definition');
+    if (projections.has('workflow-execution/root-v1'))
+        domains.push('workflow-execution');
+    if (projections.has('workflow-execution-event/full-v1'))
+        domains.push('workflow-execution-event');
+    if (projections.has('workstream-task-order/full-v1'))
+        domains.push('workstream-task-order');
+    return domains;
+}
+function notifications() {
+    return { taskUpsertIds: new Set(), taskDeleteIds: new Set(), relationships: new Map(),
+        initiativeIds: new Set(), workstreamIds: new Set(), taxonomy: false, workflowExecutionIds: new Set() };
+}
+function assertFingerprint(payload, expected, label) {
+    if (fingerprintWorkspaceSyncPayload(payload) !== expected) {
+        throw new Error(`${label} does not match the authoritative combined feed payload.`);
+    }
+}
+function applyTaskEntry(input) {
+    const { core, workspaceId, entry } = input;
+    if (entry.mutationKind === 'delete') {
+        const payload = entry.payload;
+        const existing = core.getTask(entry.entityId, workspaceId);
+        if (existing) {
+            core.deleteTaskForSync(entry.entityId, workspaceId, {
+                persistBackup: false, emitRealtime: false, deletedAt: payload.deletedAt,
+                actor: 'system', actorType: 'system', source: 'sync',
+            });
+        }
+        if (core.getTask(entry.entityId, workspaceId))
+            throw new Error('Authoritative task delete was not installed.');
+        assertFingerprint(payload, entry.payloadFingerprint, 'Task tombstone');
+        return 'delete';
+    }
+    if (entry.mutationKind === 'taxonomy-remap') {
+        const payload = entry.payload;
+        const installed = core.applyTaskTaxonomyRemapForDurableSync({ workspaceId, taskId: entry.entityId,
+            patch: { category: payload.category, type: payload.type, priority: payload.priority }, updatedAt: payload.updatedAt });
+        assertFingerprint({ id: installed.id, category: installed.category, type: installed.type,
+            priority: installed.priority, updatedAt: installed.updatedAt }, entry.payloadFingerprint, 'Task taxonomy remap');
+        return 'upsert';
+    }
+    const payload = entry.payload;
+    core.installWorkspaceSyncV3TaskRootAuthoritativeForSync(payload, workspaceId);
+    const installed = core.getTask(entry.entityId, workspaceId);
+    if (!installed)
+        throw new Error('Authoritative task root was not installed.');
+    assertFingerprint(serializeTaskRootForSync(installed), entry.payloadFingerprint, 'Task root');
+    return 'upsert';
+}
+function applyRelationshipEntry(input) {
+    const payload = serializeTaskRelationshipForSync(input.entry.payload);
+    input.core.installDurableTaskRelationshipAuthoritativeForSync(payload, input.workspaceId);
+    const installed = input.core.getTaskRelationshipForSync(input.entry.entityId, input.workspaceId);
+    if (!installed)
+        throw new Error('Authoritative task relationship was not installed.');
+    assertFingerprint(serializeTaskRelationshipForSync(installed), input.entry.payloadFingerprint, 'Task relationship');
+    return installed;
+}
+function applyTaxonomyEntry(input) {
+    const payload = serializeTaxonomyStateForSync(input.entry.payload);
+    const installed = input.core.replaceTaxonomyStateForDurableSync({
+        workspaceId: input.workspaceId, taxonomyState: payload, updatedAt: input.entry.occurredAt,
+    });
+    assertFingerprint(serializeTaxonomyStateForSync(installed), input.entry.payloadFingerprint, 'Taxonomy state');
+}
+function applyWorkstreamTaskOrderEntry(input) {
+    validateWorkspaceSyncV3WorkstreamTaskOrderFeedEntry(input.entry);
+    const payload = serializeWorkstreamTaskOrderForSync(input.entry.payload);
+    input.core.replaceWorkstreamTaskOrder(payload.workstreamId, payload.taskIds, input.workspaceId);
+    const installed = serializeWorkstreamTaskOrderForSync({
+        workstreamId: payload.workstreamId,
+        taskIds: input.core.getWorkstreamTaskOrderForSync(payload.workstreamId, input.workspaceId),
+    });
+    assertFingerprint(installed, input.entry.payloadFingerprint, 'Workstream task order');
+    return installed.taskIds;
+}
+function applyInitiativeEntry(input) {
+    const payload = serializeInitiativeForSync(input.entry.payload);
+    const installed = input.core.installDurableInitiativeAuthoritativeForSync(payload, input.workspaceId);
+    assertFingerprint(serializeInitiativeForSync(installed), input.entry.payloadFingerprint, 'Initiative');
+}
+function applyWorkstreamEntry(input) {
+    const payload = serializeWorkstreamForSync(input.entry.payload);
+    const installed = input.core.installDurableWorkstreamAuthoritativeForSync(payload, input.workspaceId);
+    assertFingerprint(serializeWorkstreamForSync(installed), input.entry.payloadFingerprint, 'Workstream');
+}
+const FULL_TASK_ROOT_MUTATIONS = new Set([
+    'create', 'metadata-update', 'archive', 'unarchive', 'complete', 'reopen', 'set-status',
+]);
+function isExactTaskRootProjectionReplay(input) {
+    return input.entry.projection === 'task/root-v1'
+        && FULL_TASK_ROOT_MUTATIONS.has(input.entry.mutationKind)
+        && 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.current.canonicalFingerprint !== input.entry.payloadFingerprint;
+}
+function isExactNestedProjectionReplay(input) {
+    return NESTED_TASK_PROJECTIONS.has(input.entry.projection)
+        && 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 applyEntries(input) {
+    const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
+    const workflowApply = prepareWorkspaceSyncV3WorkflowRuntimeApply({
+        store: new WorkflowStore(input.core.getDatabaseAdapter(), input.tenantId),
+        workspaceId: input.workspaceId,
+        entries: input.entries,
+    });
+    return store.runWorkspaceDomainCoexistenceTransaction({
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        direction: 'local-pull',
+        targets: input.entries.map((entry) => ({ domain: entry.domain, entityId: entry.entityId })),
+        now: input.now,
+        apply: () => {
+            if (!input.allowUnrelatedActiveOutbox
+                && hasActiveCoveredOutbox(input.core, input.tenantId, input.workspaceId, input.coveredProjections)) {
+                throw coveredLocalOperationsError('Combined feed apply is blocked by covered local operations.');
+            }
+            const notices = notifications();
+            for (const entry of input.entries) {
+                let taskChange = null;
+                let nestedTaskChangeId = null;
+                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 applyEntry = () => {
+                    if (entry.projection === 'task/root-v1') {
+                        taskChange = applyTaskEntry({ core: input.core, workspaceId: input.workspaceId, entry });
+                    }
+                    else if (entry.projection === 'task-relationship/full-v1') {
+                        notices.relationships.set(entry.entityId, applyRelationshipEntry({ core: input.core, workspaceId: input.workspaceId, entry }));
+                    }
+                    else if (entry.projection === 'taxonomy/full-v1') {
+                        applyTaxonomyEntry({ core: input.core, workspaceId: input.workspaceId, entry });
+                    }
+                    else if (entry.projection === 'initiative/full-v1') {
+                        applyInitiativeEntry({ core: input.core, workspaceId: input.workspaceId, entry });
+                    }
+                    else if (entry.projection === 'workstream/full-v1') {
+                        applyWorkstreamEntry({ core: input.core, workspaceId: input.workspaceId, entry });
+                    }
+                    else if (entry.projection === 'workstream-task-order/full-v1') {
+                        for (const taskId of applyWorkstreamTaskOrderEntry({
+                            core: input.core,
+                            workspaceId: input.workspaceId,
+                            entry,
+                        }))
+                            notices.taskUpsertIds.add(taskId);
+                    }
+                    else if (NESTED_TASK_PROJECTIONS.has(entry.projection)
+                        && input.coveredProjections.has(entry.projection)) {
+                        const nestedResult = applyWorkspaceSyncV3NestedTaskEntries({
+                            core: input.core,
+                            workspaceId: input.workspaceId,
+                            entries: [entry],
+                            now: input.now,
+                            authoritativeEntityEventRecoveryIds: input.authoritativeEntityEventRecoveryIds,
+                        });
+                        if (nestedResult.state === 'applied') {
+                            if (entry.projection !== 'entity-event/full-v1') {
+                                nestedTaskChangeId = entry.entityId;
+                            }
+                            else {
+                                const event = validateWorkspaceSyncV3EntityEventPayload(entry.payload);
+                                if (event.entityType === 'task')
+                                    nestedTaskChangeId = event.entityId;
+                                if (event.entityType === 'initiative')
+                                    notices.initiativeIds.add(event.entityId);
+                                if (event.entityType === 'workstream')
+                                    notices.workstreamIds.add(event.entityId);
+                            }
+                        }
+                        return nestedResult;
+                    }
+                    else if (WORKFLOW_RUNTIME_PROJECTIONS.has(entry.projection)
+                        && input.coveredProjections.has(entry.projection)) {
+                        workflowApply.applyEntry(entry);
+                        if (entry.projection === 'workflow-execution/root-v1') {
+                            notices.workflowExecutionIds.add(entry.entityId);
+                        }
+                    }
+                    else {
+                        throw new Error(`Unsupported combined local apply projection: ${entry.projection}.`);
+                    }
+                };
+                let applied;
+                if (exactTaskRootReplay || exactNestedReplay) {
+                    const result = applyEntry();
+                    applied = result?.state === 'deferred'
+                        ? { state: 'deferred' }
+                        : { state: 'applied' };
+                }
+                else {
+                    applied = store.applyReplicatedEntityRevision({ tenantId: input.tenantId, workspaceId: input.workspaceId,
+                        domain: entry.domain, entityId: entry.entityId, sequence: entry.sequence,
+                        entityRevision: entry.entityRevision, lifecycleRevision: entry.lifecycleRevision,
+                        canonicalFingerprint: entry.canonicalFingerprint || entry.payloadFingerprint, now: input.now,
+                        metadataOwned: entry.projection === 'task/root-v1' && entry.mutationKind !== 'taxonomy-remap',
+                        reopenAssigneeOwned: entry.projection === 'task/root-v1' && entry.mutationKind !== 'taxonomy-remap',
+                        allowAuthoritativeEqualRevisionReplacement: input.allowAuthoritativeEqualRevisionReplacement,
+                        allowAuthoritativeRevisionReset: input.allowAuthoritativeRevisionReset,
+                        applyMutation: applyEntry,
+                        shouldRecordRevision: (result) => result?.state !== 'deferred',
+                    });
+                }
+                if (applied.state !== 'applied')
+                    continue;
+                if (entry.projection === 'task/root-v1' && entry.mutationKind !== 'delete') {
+                    store.markTaskTaxonomyProjectionOwned({ tenantId: input.tenantId, workspaceId: input.workspaceId,
+                        taskIds: [entry.entityId], now: input.now });
+                }
+                if (taskChange === 'upsert') {
+                    notices.taskDeleteIds.delete(entry.entityId);
+                    notices.taskUpsertIds.add(entry.entityId);
+                }
+                if (taskChange === 'delete') {
+                    notices.taskUpsertIds.delete(entry.entityId);
+                    notices.taskDeleteIds.add(entry.entityId);
+                }
+                if (nestedTaskChangeId)
+                    notices.taskUpsertIds.add(nestedTaskChangeId);
+                if (entry.projection === 'taxonomy/full-v1')
+                    notices.taxonomy = true;
+                if (entry.projection === 'initiative/full-v1')
+                    notices.initiativeIds.add(entry.entityId);
+                if (entry.projection === 'workstream/full-v1')
+                    notices.workstreamIds.add(entry.entityId);
+            }
+            return notices;
+        },
+    });
+}
+function hasActiveCoveredOutbox(core, tenantId, workspaceId, projections) {
+    const domains = coveredDomains(projections);
+    if (domains.length === 0)
+        return false;
+    const placeholders = domains.map(() => '?').join(', ');
+    const row = core.getDatabaseAdapter().prepare(`
+        SELECT 1 AS active FROM workspace_sync_outbox AS outbox
+        WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+          AND outbox.status IN ('pending', 'in_flight', 'blocked')
+          AND (
+            outbox.domain IN (${placeholders})
+            OR EXISTS (
+                SELECT 1 FROM workspace_sync_outbox_targets AS target
+                WHERE target.tenant_id = outbox.tenant_id AND target.workspace_id = outbox.workspace_id
+                  AND target.client_id = outbox.client_id AND target.operation_id = outbox.operation_id
+                  AND target.domain IN (${placeholders})
+            )
+          ) LIMIT 1
+    `).get(tenantId, workspaceId, ...domains, ...domains);
+    return Number(row?.active || 0) === 1;
+}
+function listLocalTaskRoots(core, workspaceId) {
+    const values = new Map();
+    let cursor = null;
+    do {
+        const page = core.listTasksForSync(workspaceId, cursor, 1000);
+        for (const entry of page)
+            values.set(entry.task.id, serializeTaskRootForSync(entry.task));
+        const last = page.at(-1);
+        cursor = page.length === 1000 && last
+            ? { watermark: String(last.task.updatedAt || last.task.createdAt), id: last.task.id } : null;
+    } while (cursor);
+    return values;
+}
+function listLocalTaskNestedProjection(core, workspaceId, projection) {
+    const values = new Map();
+    let cursor = null;
+    do {
+        const page = core.listTasksForSync(workspaceId, cursor, 1000);
+        for (const entry of page) {
+            const task = entry.task;
+            if (projection === 'task-comments/full-v1') {
+                values.set(task.id, serializeWorkspaceSyncV3TaskCommentsPayload({
+                    taskId: task.id, comments: task.comments || [],
+                }));
+            }
+            else if (projection === 'task-checklist/full-v1') {
+                values.set(task.id, serializeWorkspaceSyncV3TaskChecklistPayload({
+                    taskId: task.id, items: task.checklistItems || [],
+                }));
+            }
+            else {
+                values.set(task.id, serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
+                    taskId: task.id,
+                    links: core.listTaskAttachmentLinksForDurableSync(task.id, workspaceId),
+                }));
+            }
+        }
+        const last = page.at(-1);
+        cursor = page.length === 1000 && last
+            ? { watermark: String(last.task.updatedAt || last.task.createdAt), id: last.task.id } : null;
+    } while (cursor);
+    return values;
+}
+function listLocalEntityEvents(core, workspaceId, liveEntityIds) {
+    const values = new Map();
+    let cursor = null;
+    do {
+        const page = core.listEntityEventsForSync({ workspaceId, cursor, limit: 1000 });
+        for (const event of page) {
+            if (liveEntityIds.has(`${event.entityType}\0${event.entityId}`)) {
+                values.set(event.id, serializeWorkspaceSyncV3EntityEventPayload(event));
+            }
+        }
+        const last = page.at(-1);
+        if (page.length === 1000 && last) {
+            const canonical = serializeWorkspaceSyncV3EntityEventPayload(last);
+            cursor = {
+                watermark: canonical.createdAt,
+                id: canonical.entityType === 'task'
+                    ? `task-event:${canonical.id}`
+                    : `${canonical.entityType}:${canonical.entityId}:event:${canonical.id}`,
+            };
+        }
+        else {
+            cursor = null;
+        }
+    } while (cursor);
+    return values;
+}
+function nestedLocalDomains(core, workspaceId, projections, liveEntityIds) {
+    const domains = [];
+    if (projections.has('task-comments/full-v1')) {
+        domains.push(['task-comments', listLocalTaskNestedProjection(core, workspaceId, 'task-comments/full-v1')]);
+    }
+    if (projections.has('task-checklist/full-v1')) {
+        domains.push(['task-checklist', listLocalTaskNestedProjection(core, workspaceId, 'task-checklist/full-v1')]);
+    }
+    if (projections.has('task-attachment-links/full-v1')) {
+        domains.push(['task-attachment-links', listLocalTaskNestedProjection(core, workspaceId, 'task-attachment-links/full-v1')]);
+    }
+    if (projections.has('entity-event/full-v1')) {
+        domains.push(['entity-event', listLocalEntityEvents(core, workspaceId, liveEntityIds)]);
+    }
+    return domains;
+}
+function workflowLocalDomains(core, workspaceId, projections) {
+    if (!projections.has('workflow-execution/root-v1'))
+        return [];
+    const store = new WorkflowStore(core.getDatabaseAdapter(), core.getTenantId());
+    const definitions = new Map();
+    const executions = new Map();
+    const events = new Map();
+    for (const execution of store.listExecutions(workspaceId)) {
+        const assignment = store.getAssignmentForExecutionSync(workspaceId, execution.id);
+        if (!assignment) {
+            throw new Error(`Local workflow execution ${execution.id} has an incomplete definition or history.`);
+        }
+        definitions.set(assignment.version.id, serializeWorkflowPublishedDefinitionSyncPayload(assignment));
+        executions.set(assignment.execution.id, serializeWorkflowExecutionRootSyncPayload(assignment.execution));
+        for (const event of assignment.events) {
+            events.set(event.id, serializeWorkflowExecutionEventSyncPayload(event));
+        }
+    }
+    return [
+        ['workflow-published-definition', definitions],
+        ['workflow-execution', executions],
+        ['workflow-execution-event', events],
+    ];
+}
+function planningOrderLocalDomains(core, workspaceId, projections, workstreams) {
+    if (!projections.has('workstream-task-order/full-v1'))
+        return [];
+    const orders = new Map();
+    for (const workstreamId of workstreams.keys()) {
+        orders.set(workstreamId, serializeWorkstreamTaskOrderForSync({
+            workstreamId,
+            taskIds: core.getWorkstreamTaskOrderForSync(workstreamId, workspaceId),
+        }));
+    }
+    return [['workstream-task-order', orders]];
+}
+function listLocalRelationships(core, workspaceId) {
+    const values = new Map();
+    let cursor = null;
+    do {
+        const page = core.listTaskRelationshipsForSync(workspaceId, cursor, 1000);
+        for (const entry of page)
+            values.set(entry.id, serializeTaskRelationshipForSync(entry));
+        const last = page.at(-1);
+        cursor = page.length === 1000 && last
+            ? { watermark: last.updatedAt, id: `task-relationship:${last.id}` } : null;
+    } while (cursor);
+    return values;
+}
+function listLocalInitiatives(core, workspaceId) {
+    const values = new Map();
+    let afterId = null;
+    do {
+        const page = core.listInitiativesForSync(workspaceId, afterId, 1000);
+        for (const entry of page)
+            values.set(entry.id, serializeInitiativeForSync(entry));
+        afterId = page.length === 1000 ? page.at(-1)?.id || null : null;
+    } while (afterId);
+    return values;
+}
+function listLocalWorkstreams(core, workspaceId) {
+    const values = new Map();
+    let afterId = null;
+    do {
+        const page = core.listWorkstreamsForSync(workspaceId, afterId, 1000);
+        for (const entry of page)
+            values.set(entry.id, serializeWorkstreamForSync(entry));
+        afterId = page.length === 1000 ? page.at(-1)?.id || null : null;
+    } while (afterId);
+    return values;
+}
+function isCompatibleLegacyRelationship(local, incoming) {
+    if (!local || typeof local !== 'object' || Array.isArray(local)
+        || !incoming || typeof incoming !== 'object' || Array.isArray(incoming))
+        return false;
+    const left = local;
+    const right = incoming;
+    return left.id === right.id
+        && left.workspaceId === right.workspaceId
+        && left.sourceTaskId === right.sourceTaskId
+        && left.targetTaskId === right.targetTaskId
+        && left.kind === right.kind
+        && Boolean(left.deletedAt) === Boolean(right.deletedAt);
+}
+function isCompatibleLegacyComments(local, incoming) {
+    if (!local || typeof local !== 'object' || Array.isArray(local)
+        || !incoming || typeof incoming !== 'object' || Array.isArray(incoming))
+        return false;
+    const left = local;
+    const right = incoming;
+    if (left.taskId !== right.taskId || !Array.isArray(left.comments) || !Array.isArray(right.comments))
+        return false;
+    const incomingById = new Map(right.comments.map((comment) => [
+        String(comment?.id || ''), comment,
+    ]));
+    return left.comments.every((comment) => {
+        const id = String(comment?.id || '');
+        const authoritative = incomingById.get(id);
+        return Boolean(id && authoritative
+            && canonicalWorkspaceSyncJson(comment) === canonicalWorkspaceSyncJson(authoritative));
+    });
+}
+function isCompatibleLegacyAttachmentLinks(core, workspaceId, local, incoming) {
+    if (!local || typeof local !== 'object' || Array.isArray(local)
+        || !incoming || typeof incoming !== 'object' || Array.isArray(incoming))
+        return false;
+    const left = local;
+    const right = incoming;
+    if (left.taskId !== right.taskId || !Array.isArray(left.links) || !Array.isArray(right.links))
+        return false;
+    const localLinks = left.links;
+    const incomingLinks = right.links;
+    if (localLinks.some((candidate) => !candidate || typeof candidate !== 'object' || Array.isArray(candidate))) {
+        return false;
+    }
+    const store = core.getWorkspaceAssetStore();
+    const unmatched = [...incomingLinks];
+    const pendingLocal = localLinks.filter((candidate) => {
+        const localLink = candidate;
+        const exactIndex = unmatched.findIndex((value) => canonicalWorkspaceSyncJson(value)
+            === canonicalWorkspaceSyncJson(localLink));
+        if (exactIndex >= 0) {
+            unmatched.splice(exactIndex, 1);
+            return false;
+        }
+        return true;
+    }).sort((leftCandidate, rightCandidate) => {
+        const providerRank = (candidate) => {
+            const link = candidate;
+            return store.get(String(link.assetId || ''), workspaceId)?.storageProvider === 'external' ? 1 : 0;
+        };
+        return providerRank(leftCandidate) - providerRank(rightCandidate);
+    });
+    const compatible = pendingLocal.every((candidate) => {
+        const localLink = candidate;
+        const alternateIndex = unmatched.findIndex((value) => {
+            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 sameContent = localAsset.contentSha256 === incomingAsset.contentSha256
+                && localAsset.sizeBytes === incomingAsset.sizeBytes;
+            const authoritativeMaterialization = localAsset.storageProvider === 'external'
+                && incomingAsset.storageProvider !== 'external'
+                && incomingAsset.sizeBytes >= localAsset.sizeBytes;
+            return sameContent || authoritativeMaterialization;
+        });
+        if (alternateIndex >= 0) {
+            unmatched.splice(alternateIndex, 1);
+            return true;
+        }
+        const localAsset = store.get(String(localLink.assetId || ''), workspaceId);
+        return Boolean(localAsset && !localAsset.deletedAt && localAsset.storageProvider === 'external'
+            && incomingLinks.some((value) => {
+                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'
+                    && incomingAsset.storageKey === localAsset.storageKey
+                    && incomingAsset.sizeBytes >= localAsset.sizeBytes);
+            }));
+    }) && unmatched.length === 0;
+    return compatible;
+}
+function assertLocalInventoryReady(input) {
+    if (hasActiveCoveredOutbox(input.core, input.tenantId, input.workspaceId, input.coveredProjections)) {
+        throw coveredLocalOperationsError('Combined repair cannot activate while covered local operations are pending.');
+    }
+    const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
+    const newerOwned = store.listOwnedWorkspaceDomainRevisionsAfter({
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        domains: coveredDomains(input.coveredProjections),
+        sequence: input.snapshotSequence,
+    })[0];
+    if (newerOwned) {
+        throw staleRepairSnapshotError(newerOwned.domain, newerOwned.entityId);
+    }
+    const authoritative = new Map(input.entries.map((entry) => [`${entry.domain}\0${entry.entityId}`, entry]));
+    const tasks = listLocalTaskRoots(input.core, input.workspaceId);
+    const initiatives = listLocalInitiatives(input.core, input.workspaceId);
+    const workstreams = listLocalWorkstreams(input.core, input.workspaceId);
+    const liveEntityIds = new Set([
+        ...Array.from(tasks.keys(), (entityId) => `task\0${entityId}`),
+        ...Array.from(initiatives.keys(), (entityId) => `initiative\0${entityId}`),
+        ...Array.from(workstreams.keys(), (entityId) => `workstream\0${entityId}`),
+    ]);
+    const localDomains = [
+        ['task', tasks],
+        ['task-relationship', listLocalRelationships(input.core, input.workspaceId)],
+        ['initiative', initiatives],
+        ['workstream', workstreams],
+        ...nestedLocalDomains(input.core, input.workspaceId, input.coveredProjections, liveEntityIds),
+        ...workflowLocalDomains(input.core, input.workspaceId, input.coveredProjections),
+        ...planningOrderLocalDomains(input.core, input.workspaceId, input.coveredProjections, workstreams),
+    ];
+    for (const [domain, local] of localDomains) {
+        for (const [entityId, payload] of local) {
+            const incoming = authoritative.get(`${domain}\0${entityId}`);
+            const ownership = store.readWorkspaceDomainOwnership({
+                tenantId: input.tenantId, workspaceId: input.workspaceId, domain, entityId,
+            });
+            if (!incoming) {
+                if (domain === 'entity-event' && ownership.owned
+                    && ownership.lastSequence !== null
+                    && BigInt(ownership.lastSequence) <= BigInt(input.snapshotSequence)) {
+                    // Entity events are append-only. Preserve acknowledged
+                    // local history beyond the authoritative snapshot's lower
+                    // bound instead of deleting it or blocking activation.
+                    continue;
+                }
+                if (domain === 'entity-event') {
+                    // Entity events are append-only. An unowned local event
+                    // must be adopted before an authoritative repair can
+                    // replace the covered inventory, so discard this stale
+                    // snapshot and let the next repair preflight enqueue that
+                    // adoption instead of treating the event as disposable
+                    // legacy divergence.
+                    throw staleRepairSnapshotError(domain, entityId);
+                }
+                throw new Error(`Combined repair snapshot is missing local ${domain} state ${entityId}; `
+                    + 'complete v2 reconciliation first.');
+            }
+            const payloadMatches = fingerprintWorkspaceSyncPayload(payload) === incoming.payloadFingerprint;
+            const compatibleLegacyRelationship = domain === 'task-relationship'
+                && isCompatibleLegacyRelationship(payload, incoming.payload);
+            const compatibleLegacyComments = domain === 'task-comments'
+                && isCompatibleLegacyComments(payload, incoming.payload);
+            const compatibleLegacyAttachmentLinks = domain === 'task-attachment-links'
+                && isCompatibleLegacyAttachmentLinks(input.core, input.workspaceId, payload, incoming.payload);
+            if (!ownership.owned && !payloadMatches && !compatibleLegacyRelationship && !compatibleLegacyComments
+                && !compatibleLegacyAttachmentLinks && domain !== 'workstream-task-order') {
+                throw new Error(`Combined repair found divergent legacy local ${domain} state; complete v2 reconciliation first.`);
+            }
+        }
+    }
+    const taxonomy = authoritative.get('taxonomy\0__taxonomy_config__');
+    if (!taxonomy)
+        throw new Error('Combined repair snapshot is missing taxonomy state.');
+    const ownership = store.readWorkspaceDomainOwnership({ tenantId: input.tenantId, workspaceId: input.workspaceId,
+        domain: 'taxonomy', entityId: '__taxonomy_config__' });
+    const localTaxonomy = serializeTaxonomyStateForSync(input.core.getTaxonomyState(input.workspaceId));
+    if (!ownership.owned && fingerprintWorkspaceSyncPayload(localTaxonomy) !== taxonomy.payloadFingerprint) {
+        throw new Error('Combined repair found divergent legacy local taxonomy state; complete v2 reconciliation first.');
+    }
+}
+function assertRollbackInventoryReady(input) {
+    if (hasActiveCoveredOutbox(input.core, input.tenantId, input.workspaceId, input.coveredProjections)) {
+        throw coveredLocalOperationsError('Combined fallback repair cannot roll back while covered local operations are pending.');
+    }
+    const authoritative = new Map(input.entries.map((entry) => [`${entry.domain}\0${entry.entityId}`, entry]));
+    const tasks = listLocalTaskRoots(input.core, input.workspaceId);
+    const initiatives = listLocalInitiatives(input.core, input.workspaceId);
+    const workstreams = listLocalWorkstreams(input.core, input.workspaceId);
+    const liveEntityIds = new Set([
+        ...Array.from(tasks.keys(), (entityId) => `task\0${entityId}`),
+        ...Array.from(initiatives.keys(), (entityId) => `initiative\0${entityId}`),
+        ...Array.from(workstreams.keys(), (entityId) => `workstream\0${entityId}`),
+    ]);
+    const localDomains = [
+        ['task', tasks],
+        ['task-relationship', listLocalRelationships(input.core, input.workspaceId)],
+        ['initiative', initiatives],
+        ['workstream', workstreams],
+        ...nestedLocalDomains(input.core, input.workspaceId, input.coveredProjections, liveEntityIds),
+        ...workflowLocalDomains(input.core, input.workspaceId, input.coveredProjections),
+        ...planningOrderLocalDomains(input.core, input.workspaceId, input.coveredProjections, workstreams),
+    ];
+    const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
+    const removedTaskIds = [];
+    for (const [domain, local] of localDomains) {
+        for (const [entityId, payload] of local) {
+            const incoming = authoritative.get(`${domain}\0${entityId}`);
+            const ownership = store.readWorkspaceDomainOwnership({
+                tenantId: input.tenantId, workspaceId: input.workspaceId, domain, entityId,
+            });
+            if (!incoming) {
+                if (domain === 'task' && ownership.owned) {
+                    if (ownership.lastSequence === null
+                        || BigInt(ownership.lastSequence) > BigInt(input.snapshotSequence)) {
+                        throw new Error('Combined fallback repair snapshot predates an authoritative local task.');
+                    }
+                    removedTaskIds.push(entityId);
+                    continue;
+                }
+                if (domain === 'entity-event' && ownership.owned
+                    && ownership.lastSequence !== null
+                    && BigInt(ownership.lastSequence) <= BigInt(input.snapshotSequence)) {
+                    continue;
+                }
+                throw new Error(`Combined fallback repair snapshot is missing local ${domain} state ${entityId}.`);
+            }
+            const payloadMatches = fingerprintWorkspaceSyncPayload(payload) === incoming.payloadFingerprint;
+            if (!ownership.owned && !payloadMatches && domain !== 'workstream-task-order') {
+                throw new Error(`Combined fallback repair found divergent legacy local ${domain} state.`);
+            }
+            if (ownership.owned && BigInt(incoming.entityRevision) < BigInt(ownership.entityRevision)) {
+                throw new Error(`Combined fallback repair regresses owned local ${domain} revision.`);
+            }
+        }
+    }
+    for (const [domain, local] of localDomains) {
+        for (const entry of input.entries.filter((candidate) => candidate.domain === domain)) {
+            if (local.has(entry.entityId))
+                continue;
+            const ownership = store.readWorkspaceDomainOwnership({ tenantId: input.tenantId,
+                workspaceId: input.workspaceId, domain, entityId: entry.entityId });
+            if (ownership.owned && BigInt(entry.entityRevision) < BigInt(ownership.entityRevision)) {
+                throw new Error(`Combined fallback repair regresses missing owned local ${domain} revision.`);
+            }
+        }
+    }
+    const taxonomy = authoritative.get('taxonomy\0__taxonomy_config__');
+    if (!taxonomy)
+        throw new Error('Combined fallback repair snapshot is missing taxonomy state.');
+    const taxonomyOwnership = store.readWorkspaceDomainOwnership({ tenantId: input.tenantId,
+        workspaceId: input.workspaceId, domain: 'taxonomy', entityId: '__taxonomy_config__' });
+    const localTaxonomy = serializeTaxonomyStateForSync(input.core.getTaxonomyState(input.workspaceId));
+    const taxonomyMatches = fingerprintWorkspaceSyncPayload(localTaxonomy) === taxonomy.payloadFingerprint;
+    if (!taxonomyOwnership.owned && !taxonomyMatches) {
+        throw new Error('Combined fallback repair found divergent legacy local taxonomy state.');
+    }
+    if (taxonomyOwnership.owned && BigInt(taxonomy.entityRevision) < BigInt(taxonomyOwnership.entityRevision)) {
+        throw new Error('Combined fallback repair regresses owned local taxonomy revision.');
+    }
+    return removedTaskIds.sort();
+}
+function forceInstallCurrentSnapshotEntries(input) {
+    const notices = notifications();
+    const installedKeys = new Set();
+    const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
+    for (const entry of input.entries) {
+        const ownership = store.readWorkspaceDomainOwnership({ tenantId: input.tenantId,
+            workspaceId: input.workspaceId, domain: entry.domain, entityId: entry.entityId });
+        if (BigInt(entry.entityRevision) !== BigInt(ownership.entityRevision))
+            continue;
+        if (ownership.lifecycleRevision !== entry.lifecycleRevision || ownership.lastSequence !== entry.sequence) {
+            throw new Error(`Combined fallback repair found inconsistent owned local ${entry.domain} revision coordinates.`);
+        }
+        installedKeys.add(`${entry.domain}\0${entry.entityId}`);
+        if (entry.projection === 'task/root-v1') {
+            const change = applyTaskEntry({ core: input.core, workspaceId: input.workspaceId, entry });
+            if (entry.mutationKind !== 'delete') {
+                store.markTaskTaxonomyProjectionOwned({ tenantId: input.tenantId,
+                    workspaceId: input.workspaceId, taskIds: [entry.entityId], now: input.now });
+            }
+            if (change === 'upsert')
+                notices.taskUpsertIds.add(entry.entityId);
+            else
+                notices.taskDeleteIds.add(entry.entityId);
+        }
+        else if (entry.projection === 'task-relationship/full-v1') {
+            notices.relationships.set(entry.entityId, applyRelationshipEntry({ core: input.core, workspaceId: input.workspaceId, entry }));
+        }
+        else if (entry.projection === 'taxonomy/full-v1') {
+            applyTaxonomyEntry({ core: input.core, workspaceId: input.workspaceId, entry });
+            notices.taxonomy = true;
+        }
+        else if (entry.projection === 'initiative/full-v1') {
+            applyInitiativeEntry({ core: input.core, workspaceId: input.workspaceId, entry });
+            notices.initiativeIds.add(entry.entityId);
+        }
+        else if (entry.projection === 'workstream/full-v1') {
+            applyWorkstreamEntry({ core: input.core, workspaceId: input.workspaceId, entry });
+            notices.workstreamIds.add(entry.entityId);
+        }
+        else if (entry.projection === 'workstream-task-order/full-v1') {
+            for (const taskId of applyWorkstreamTaskOrderEntry({
+                core: input.core,
+                workspaceId: input.workspaceId,
+                entry,
+            }))
+                notices.taskUpsertIds.add(taskId);
+        }
+        else if (NESTED_TASK_PROJECTIONS.has(entry.projection)
+            && input.coveredProjections.has(entry.projection)) {
+            const nestedResult = applyWorkspaceSyncV3NestedTaskEntries({
+                core: input.core,
+                workspaceId: input.workspaceId,
+                entries: [entry],
+                now: input.now,
+            });
+            if (nestedResult.state === 'deferred') {
+                installedKeys.delete(`${entry.domain}\0${entry.entityId}`);
+                continue;
+            }
+            if (entry.projection !== 'entity-event/full-v1') {
+                notices.taskUpsertIds.add(entry.entityId);
+            }
+            else {
+                const event = validateWorkspaceSyncV3EntityEventPayload(entry.payload);
+                if (event.entityType === 'task')
+                    notices.taskUpsertIds.add(event.entityId);
+                if (event.entityType === 'initiative')
+                    notices.initiativeIds.add(event.entityId);
+                if (event.entityType === 'workstream')
+                    notices.workstreamIds.add(event.entityId);
+            }
+        }
+        else {
+            throw new Error(`Unsupported combined fallback projection: ${entry.projection}.`);
+        }
+    }
+    return { notices, installedKeys };
+}
+function applyRollbackSnapshot(input) {
+    const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
+    return store.runWorkspaceDomainCoexistenceTransaction({
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        direction: 'local-pull',
+        targets: [
+            ...input.entries.map((entry) => ({ domain: entry.domain, entityId: entry.entityId })),
+            ...input.removedTaskIds.map((entityId) => ({ domain: 'task', entityId })),
+        ],
+        now: input.now,
+        apply: () => {
+            if (hasActiveCoveredOutbox(input.core, input.tenantId, input.workspaceId, input.coveredProjections)) {
+                throw coveredLocalOperationsError('Combined fallback repair is blocked by covered local operations.');
+            }
+            const notices = notifications();
+            for (const taskId of input.removedTaskIds) {
+                if (input.core.getTask(taskId, input.workspaceId)) {
+                    input.core.deleteTaskForSync(taskId, input.workspaceId, {
+                        persistBackup: false, emitRealtime: false, deletedAt: input.now,
+                        actor: 'system', actorType: 'system', source: 'sync',
+                    });
+                }
+                if (input.core.getTask(taskId, input.workspaceId)) {
+                    throw new Error('Combined fallback repair did not remove an absent authoritative task.');
+                }
+                notices.taskDeleteIds.add(taskId);
+            }
+            const restored = forceInstallCurrentSnapshotEntries(input);
+            for (const taskId of restored.notices.taskUpsertIds) {
+                notices.taskDeleteIds.delete(taskId);
+                notices.taskUpsertIds.add(taskId);
+            }
+            for (const taskId of restored.notices.taskDeleteIds) {
+                notices.taskUpsertIds.delete(taskId);
+                notices.taskDeleteIds.add(taskId);
+            }
+            for (const [id, relationship] of restored.notices.relationships)
+                notices.relationships.set(id, relationship);
+            for (const id of restored.notices.initiativeIds)
+                notices.initiativeIds.add(id);
+            for (const id of restored.notices.workstreamIds)
+                notices.workstreamIds.add(id);
+            notices.taxonomy = restored.notices.taxonomy;
+            const applied = applyEntries({ core: input.core, tenantId: input.tenantId,
+                workspaceId: input.workspaceId,
+                entries: input.entries.filter((entry) => !restored.installedKeys.has(`${entry.domain}\0${entry.entityId}`)),
+                now: input.now, coveredProjections: input.coveredProjections });
+            for (const taskId of applied.taskUpsertIds) {
+                notices.taskDeleteIds.delete(taskId);
+                notices.taskUpsertIds.add(taskId);
+            }
+            for (const taskId of applied.taskDeleteIds) {
+                notices.taskUpsertIds.delete(taskId);
+                notices.taskDeleteIds.add(taskId);
+            }
+            for (const [id, relationship] of applied.relationships)
+                notices.relationships.set(id, relationship);
+            for (const id of applied.initiativeIds)
+                notices.initiativeIds.add(id);
+            for (const id of applied.workstreamIds)
+                notices.workstreamIds.add(id);
+            notices.taxonomy ||= applied.taxonomy;
+            return notices;
+        }
+    });
+}
+function assertNoOverlappingInitiativeProjection(core, tenantId, workspaceId) {
+    const existing = core.getDatabaseAdapter().prepare(`
+        SELECT owner_mode FROM workspace_sync_projection_state
+        WHERE tenant_id = ? AND workspace_id = ? AND projection_id = 'initiative/full-v1'
+        LIMIT 1
+    `).get(tenantId, workspaceId);
+    if (existing?.owner_mode === 'v3') {
+        throw new Error('Combined projection activation requires an atomic handoff from initiative/full-v1 ownership.');
+    }
+}
+function notify(core, workspaceId, notices) {
+    try {
+        if (notices.taskUpsertIds.size > 0 || notices.taskDeleteIds.size > 0) {
+            core.notifyWorkspaceSyncV3TaskRootsCommitted(workspaceId, {
+                upsertIds: [...notices.taskUpsertIds], deleteIds: [...notices.taskDeleteIds],
+            });
+        }
+        for (const relationship of notices.relationships.values()) {
+            core.notifyDurableTaskRelationshipCommitted(workspaceId, relationship, relationship.deletedAt ? 'delete' : 'upsert');
+        }
+        if (notices.taxonomy)
+            core.notifyDurableTaxonomyCommitted(workspaceId);
+        for (const initiativeId of notices.initiativeIds)
+            core.notifyDurableInitiativeCommitted(workspaceId, initiativeId);
+        for (const workstreamId of notices.workstreamIds)
+            core.notifyDurableWorkstreamCommitted(workspaceId, workstreamId);
+        const workflowNotifier = core.notifyDurableWorkflowRuntimeCommitted;
+        for (const executionId of notices.workflowExecutionIds) {
+            workflowNotifier?.call(core, workspaceId, executionId);
+        }
+    }
+    catch { /* canonical bodies, revisions, and cursor already committed */ }
+}
+export function applyWorkspaceSyncV3CombinedRepairPage(input) {
+    const tenantId = input.core.getTenantId();
+    const workspaceId = String(input.workspaceId || '').trim();
+    const now = input.now || new Date().toISOString();
+    const state = new WorkspaceSyncV3CombinedProjectionStateStore(input.core.getDatabaseAdapter());
+    const recoveryBatchId = String(input.recoveryBatchId || '').trim();
+    const recoveryStore = recoveryBatchId
+        ? new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter())
+        : null;
+    const recovery = recoveryBatchId ? recoveryStore.readOutboxRecovery({
+        tenantId, workspaceId, recoveryBatchId,
+    }) : null;
+    if (recoveryBatchId && !recovery)
+        throw new Error('Workspace sync recovery batch does not exist.');
+    if (recovery && recovery.state !== 'awaiting_baseline') {
+        return input.core.getDatabaseAdapter().transaction(() => {
+            validateWorkspaceSyncV3CombinedRepairPage(input.page, workspaceId, now, true);
+            if (!recovery.baselineMarker
+                || recovery.baselineMarker !== combinedRepairBaselineMarker(input.page)) {
+                throw new Error('Workspace sync recovery page does not match the committed baseline.');
+            }
+            input.transactionHooks?.beforeApply?.();
+            const result = {
+                state: 'duplicate',
+                projection: state.read({ tenantId, workspaceId }),
+            };
+            input.transactionHooks?.beforeCommit?.(result);
+            return result;
+        })();
+    }
+    const recoveryTargets = recoveryBatchId
+        ? recoveryStore.listOutboxRecoveryTargets({ 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) {
+                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')
+                || (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;
+        });
+    };
+    const projections = coveredProjections(input.page);
+    let notices = notifications();
+    const result = state.applyRepairPage({ tenantId, workspaceId, expectedEpoch: input.expectedEpoch,
+        previousRepairCursor: input.previousRepairCursor, page: input.page, now,
+        assertReadyToActivate: (entries) => {
+            if (recoveryBatchId)
+                selectRecoveryEntries(entries);
+            else
+                assertLocalInventoryReady({
+                    core: input.core, tenantId, workspaceId, entries,
+                    snapshotSequence: input.page.snapshotSequence,
+                    coveredProjections: projections,
+                });
+        },
+        applySnapshot: (entries) => {
+            const applicableEntries = recoveryBatchId ? selectRecoveryEntries(entries) : entries;
+            notices = applyEntries({
+                core: input.core, tenantId, workspaceId, entries: applicableEntries, now,
+                coveredProjections: projections,
+                allowAuthoritativeEqualRevisionReplacement: true,
+                allowAuthoritativeRevisionReset: Boolean(recoveryBatchId),
+                allowUnrelatedActiveOutbox: Boolean(recoveryBatchId),
+                ...(recoveryBatchId ? {
+                    authoritativeEntityEventRecoveryIds: new Set(recoveryTargets
+                        .filter((target) => target.domain === 'entity-event')
+                        .map((target) => target.entityId)),
+                } : {}),
+            });
+        },
+        recoveryOnly: Boolean(recoveryBatchId),
+        ...input.transactionHooks,
+        ...(recoveryBatchId ? {
+            afterActivate: () => {
+                recoveryStore.recordOutboxRecoveryBaseline({
+                    tenantId,
+                    workspaceId,
+                    recoveryBatchId,
+                    baselineMarker: combinedRepairBaselineMarker(input.page),
+                    now,
+                });
+                recoveryStore.prepareTaskRootOutboxRecoveryReplay({
+                    tenantId,
+                    workspaceId,
+                    recoveryBatchId,
+                    now,
+                });
+            },
+        } : {}),
+    });
+    if (result.state === 'activated' || result.state === 'recovered') {
+        notify(input.core, workspaceId, notices);
+    }
+    return result;
+}
+export function applyWorkspaceSyncV3CombinedDeltaPage(input) {
+    const tenantId = input.core.getTenantId();
+    const workspaceId = String(input.workspaceId || '').trim();
+    const now = input.now || new Date().toISOString();
+    const state = new WorkspaceSyncV3CombinedProjectionStateStore(input.core.getDatabaseAdapter());
+    const projections = coveredProjections(input.page);
+    let notices = notifications();
+    let result;
+    try {
+        result = state.applyDeltaPage({ tenantId, workspaceId, epoch: input.epoch,
+            previousCursor: input.previousCursor, page: input.page, now,
+            ...input.transactionHooks,
+            applyEntries: (entries) => {
+                assertNoOverlappingInitiativeProjection(input.core, tenantId, workspaceId);
+                if (hasActiveCoveredOutbox(input.core, tenantId, workspaceId, projections)) {
+                    throw coveredLocalOperationsError('Combined feed apply is blocked by covered local operations.');
+                }
+                notices = applyEntries({ core: input.core, tenantId, workspaceId, entries, now,
+                    coveredProjections: projections });
+            },
+        });
+    }
+    catch (error) {
+        if (!(error instanceof WorkspaceSyncV3TaskCommentAggregateDivergenceError))
+            throw error;
+        const task = input.core.getTask(error.taskId, workspaceId);
+        if (!task)
+            throw error;
+        const comments = serializeWorkspaceSyncV3TaskCommentsPayload({
+            taskId: task.id,
+            comments: task.comments || [],
+        });
+        const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
+        const revision = store.readEntityRevisionCoordinates({
+            tenantId,
+            workspaceId,
+            domain: 'task-comments',
+            entityId: task.id,
+        });
+        const clientId = new LocalSyncIdentityStore(input.core.getDatabaseAdapter()).getOrCreateClientId(now);
+        const evidenceByCommentId = indexWorkspaceSyncV3TaskCommentProvenanceEvidence(input.core.listTaskEvents(task.id, workspaceId));
+        const operationFingerprint = fingerprintWorkspaceSyncPayload({
+            taskId: task.id,
+            entityRevision: revision.entityRevision,
+            comments,
+            actorEvidence: comments.comments.map((comment) => ({
+                commentId: comment.id,
+                ...evidenceByCommentId.get(comment.id),
+            })),
+        });
+        const operationId = `task-comment-reconcile-${createHash('sha256')
+            .update(operationFingerprint)
+            .digest('hex')
+            .slice(0, 32)}`;
+        enqueueLocalTaskCommentReconciliation({
+            store,
+            core: input.core,
+            identity: {
+                tenantId,
+                workspaceId,
+                clientId,
+                operationId,
+            },
+            taskId: task.id,
+            comments: comments.comments,
+            provenance: buildWorkspaceSyncV3TaskCommentReconcileProvenance({
+                workspaceId,
+                clientId,
+                operationId,
+                taskId: task.id,
+                comments: comments.comments,
+                evidenceByCommentId,
+                aiProfiles: input.core.listAiProfiles(workspaceId),
+            }),
+            now,
+        });
+        throw new WorkspaceSyncV3TaskCommentReconciliationQueuedError(task.id);
+    }
+    if (result.state === 'applied')
+        notify(input.core, workspaceId, notices);
+    return result;
+}
+export class WorkspaceSyncV3TaskCommentReconciliationQueuedError extends Error {
+    taskId;
+    code = 'WORKSPACE_SYNC_TASK_COMMENTS_RECONCILIATION_QUEUED';
+    constructor(taskId) {
+        super('Task comment divergence was captured for automatic durable reconciliation.');
+        this.taskId = taskId;
+        this.name = 'WorkspaceSyncV3TaskCommentReconciliationQueuedError';
+    }
+}
+export function applyWorkspaceSyncV3CombinedFallbackRepairPage(input) {
+    const tenantId = input.core.getTenantId();
+    const workspaceId = String(input.workspaceId || '').trim();
+    const now = input.now || new Date().toISOString();
+    const state = new WorkspaceSyncV3CombinedProjectionStateStore(input.core.getDatabaseAdapter());
+    const projections = coveredProjections(input.page);
+    let notices = notifications();
+    let removedTaskIds = [];
+    const result = state.applyFallbackRepairPage({ tenantId, workspaceId,
+        expectedEpoch: input.expectedEpoch, previousRepairCursor: input.previousRepairCursor,
+        page: input.page, now,
+        ...input.transactionHooks,
+        assertReadyToRollback: (entries) => {
+            removedTaskIds = assertRollbackInventoryReady({ core: input.core, tenantId, workspaceId,
+                entries, snapshotSequence: input.page.snapshotSequence, coveredProjections: projections });
+        },
+        applySnapshot: (entries) => {
+            notices = applyRollbackSnapshot({ core: input.core, tenantId, workspaceId,
+                entries, removedTaskIds, now, coveredProjections: projections });
+        },
+    });
+    if (result.state === 'rolled-back')
+        notify(input.core, workspaceId, notices);
+    return result;
+}