@taskforcehq/taskforce 0.3.326 → 0.3.327

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

@@ -0,0 +1,42 @@
+import type { TaskforceCore } from '../../core/Taskforce.js';
+import type { WorkspaceSyncV3FeedEntry } from './workspaceSyncV3Feed.js';
+export declare function prepareWorkspaceSyncV3CombinedRepairSnapshot(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+    now?: string;
+    nestedCoverage?: boolean;
+    workflowCoverage?: boolean;
+    planningOrderCoverage?: boolean;
+}): {
+    highWatermark: string;
+    insertedEntities: number;
+    insertedJournalRows: number;
+    snapshot: {
+        snapshotSequence: string;
+        entries: WorkspaceSyncV3FeedEntry[];
+    };
+};
+export declare function prepareWorkspaceSyncV3NestedRepairSnapshot(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+    now?: string;
+}): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
+export declare function prepareWorkspaceSyncV3WorkflowRepairSnapshot(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+    now?: string;
+}): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
+export declare function prepareWorkspaceSyncV3PlanningOrderRepairSnapshot(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+    now?: string;
+}): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
+export declare function ensureWorkspaceSyncV3CombinedRepairBaselines(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+    now?: string;
+}): {
+    highWatermark: string;
+    insertedEntities: number;
+    insertedJournalRows: number;
+};

package/dist/sync/v3/workspaceSyncV3CombinedRepairBaseline.js

@@ -0,0 +1,598 @@
+import { createHash } from 'crypto';
+import { serializeInitiativeForSync, serializeWorkstreamForSync } from '../planningSyncPayload.js';
+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 { 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 { 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;
+const BASELINE_CLIENT_ID = 'sync-v3-repair';
+const LEGACY_REPAIRABLE_NESTED_DOMAINS = new Set([
+    'task-comments', 'task-checklist', 'task-attachment-links',
+]);
+function sequence(value) {
+    const text = String(value ?? '').trim();
+    if (!/^\d+$/.test(text))
+        throw new Error('Combined repair baseline sequence is invalid.');
+    return BigInt(text).toString(10);
+}
+function occurredAt(candidate, fallback) {
+    const payload = candidate.payload;
+    const nested = candidate.domain === 'workflow-published-definition'
+        ? payload.version
+        : candidate.domain === 'workflow-execution'
+            ? payload.execution
+            : candidate.domain === 'workflow-execution-event'
+                ? payload.event
+                : undefined;
+    const value = String(nested?.publishedAt || nested?.updatedAt || nested?.createdAt
+        || payload.updatedAt || payload.createdAt || fallback).trim();
+    if (!Number.isFinite(Date.parse(value)))
+        throw new Error(`Combined repair baseline time is invalid: ${candidate.entityId}.`);
+    return new Date(value).toISOString();
+}
+function operationIdentity(workspaceId, domain, entityId, mutationKind) {
+    const digest = createHash('sha256').update(canonicalWorkspaceSyncJson({
+        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+        workspaceId,
+        domain,
+        entityId,
+        mutationKind,
+        purpose: 'combined-repair-baseline',
+    })).digest('hex');
+    return { operationId: `repair-baseline-${digest}`, eventId: `entity-event-sync-v3-${digest}` };
+}
+function repairConflict(stage, candidate) {
+    return new WorkspaceSyncRevisionConflictError({ stage, domain: candidate.domain, entityId: candidate.entityId });
+}
+function activePayload(candidate) {
+    const payload = candidate.payload;
+    if (candidate.domain === 'task') {
+        return payload.isArchived === true
+            ? serializeTaskRootForSync({ ...payload, isArchived: false })
+            : candidate.payload;
+    }
+    if (candidate.domain === 'task-relationship') {
+        return serializeTaskRelationshipForSync({ ...payload, deletedAt: null, deletedBy: null });
+    }
+    if (candidate.domain === 'initiative')
+        return serializeInitiativeForSync({ ...payload, isArchived: false });
+    if (candidate.domain === 'workstream')
+        return serializeWorkstreamForSync({ ...payload, isArchived: false });
+    return candidate.payload;
+}
+function lifecycleState(candidate) {
+    const payload = candidate.payload;
+    if (candidate.domain === 'task' || candidate.domain === 'initiative' || candidate.domain === 'workstream') {
+        return payload.isArchived === true;
+    }
+    if (candidate.domain === 'task-relationship')
+        return payload.deletedAt !== null;
+    if (candidate.domain === 'workflow-execution') {
+        const execution = payload.execution;
+        return ['completed', 'failed', 'ended'].includes(String(execution?.status || ''));
+    }
+    return false;
+}
+function readRevisions(input) {
+    const result = new Map();
+    const db = input.core.getDatabaseAdapter();
+    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);
+            const placeholders = batch.map(() => '?').join(', ');
+            const rows = db.prepare(`
+                SELECT entity_id, contract_version,
+                       CAST(entity_revision AS TEXT) AS entity_revision,
+                       CAST(lifecycle_revision AS TEXT) AS lifecycle_revision,
+                       CAST(last_sequence AS TEXT) AS last_sequence,
+                       canonical_fingerprint
+                FROM workspace_sync_entity_revisions
+                WHERE tenant_id = ? AND workspace_id = ? AND domain = ?
+                  AND entity_id IN (${placeholders})
+            `).all(input.tenantId, input.workspaceId, domain, ...batch);
+            for (const row of rows)
+                result.set(`${domain}\0${String(row.entity_id || '')}`, row);
+        }
+    }
+    return result;
+}
+function journalRow(row) {
+    return {
+        sequence: String(row.sequence), contractVersion: Number(row.contract_version),
+        operationId: String(row.operation_id || ''), clientId: String(row.client_id || ''),
+        domain: String(row.domain || ''), entityId: String(row.entity_id || ''),
+        mutationKind: String(row.mutation_kind || ''), entityRevision: String(row.entity_revision),
+        lifecycleRevision: String(row.lifecycle_revision),
+        contentSha256: row.content_sha256 == null ? null : String(row.content_sha256),
+        sizeBytes: row.size_bytes == null ? null : String(row.size_bytes),
+        payloadJson: String(row.payload_json || ''), occurredAt: String(row.occurred_at || ''),
+    };
+}
+function assertLegacyNestedRevisionProvenance(input) {
+    const row = input.core.getDatabaseAdapter().prepare(`
+        SELECT sequence, contract_version, operation_id, client_id, domain, entity_id, mutation_kind,
+               CAST(entity_revision AS TEXT) AS entity_revision,
+               CAST(lifecycle_revision AS TEXT) AS lifecycle_revision,
+               content_sha256, size_bytes, payload_json, occurred_at
+        FROM workspace_sync_journal
+        WHERE tenant_id = ? AND workspace_id = ? AND domain = ? AND entity_id = ? AND sequence = ?
+    `).get(input.tenantId, input.workspaceId, input.candidate.domain, input.candidate.entityId, input.lastSequence);
+    if (!row)
+        throw repairConflict('legacy-nested-provenance-row-missing', input.candidate);
+    const journal = journalRow(row);
+    let projected;
+    try {
+        if (input.candidate.domain === 'task-attachment-links') {
+            const raw = JSON.parse(journal.payloadJson);
+            if (raw.taskId !== input.candidate.entityId || !Array.isArray(raw.links)
+                || fingerprintWorkspaceSyncPayload(raw) !== input.canonicalFingerprint) {
+                throw new Error('Legacy task attachment-link provenance is invalid.');
+            }
+            const normalized = serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
+                taskId: input.candidate.entityId,
+                links: raw.links
+                    .map((link) => ({ ...link }))
+                    .sort((left, right) => Number(left.order) - Number(right.order)
+                    || (String(left.assetId) < String(right.assetId) ? -1 : String(left.assetId) > String(right.assetId) ? 1 : 0)
+                    || (String(left.role) < String(right.role) ? -1 : String(left.role) > String(right.role) ? 1 : 0))
+                    .map((link, order) => ({ ...link, order })),
+            });
+            projected = {
+                sequence: journal.sequence,
+                projection: 'task-attachment-links/full-v1',
+                domain: journal.domain,
+                entityId: journal.entityId,
+                mutationKind: journal.mutationKind,
+                entityRevision: journal.entityRevision,
+                lifecycleRevision: journal.lifecycleRevision,
+                canonicalFingerprint: input.canonicalFingerprint,
+                payloadFingerprint: fingerprintWorkspaceSyncPayload(normalized),
+                payload: normalized,
+                occurredAt: journal.occurredAt,
+            };
+        }
+        else {
+            projected = projectWorkspaceSyncV3NestedTaskJournalRow(journal);
+        }
+    }
+    catch {
+        throw repairConflict('legacy-nested-provenance-invalid', input.candidate);
+    }
+    if (!projected
+        || projected.domain !== input.candidate.domain
+        || projected.entityId !== input.candidate.entityId
+        || projected.sequence !== input.lastSequence
+        || projected.entityRevision !== input.entityRevision
+        || projected.lifecycleRevision !== input.lifecycleRevision
+        || projected.canonicalFingerprint !== input.canonicalFingerprint) {
+        throw repairConflict('legacy-nested-provenance-coordinate-mismatch', input.candidate);
+    }
+    return { journal, projected };
+}
+function priorTaskCommentsAggregate(input) {
+    if (input.projected.mutationKind === 'replace') {
+        return serializeWorkspaceSyncV3TaskCommentsPayload(input.projected.payload);
+    }
+    if (input.projected.mutationKind !== 'append' || !input.journal.operationId || !input.journal.clientId
+        || BigInt(input.journal.sequence) < 2n) {
+        throw new WorkspaceSyncRevisionConflictError({
+            stage: 'legacy-comment-append-root-missing', domain: 'task-comments', entityId: input.journal.entityId,
+        });
+    }
+    const rootSequence = (BigInt(input.journal.sequence) - 1n).toString(10);
+    const rows = input.core.getDatabaseAdapter().prepare(`
+        SELECT sequence, contract_version, operation_id, client_id, domain, entity_id, mutation_kind,
+               CAST(entity_revision AS TEXT) AS entity_revision,
+               CAST(lifecycle_revision AS TEXT) AS lifecycle_revision,
+               content_sha256, size_bytes, payload_json, occurred_at
+        FROM workspace_sync_journal
+        WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+          AND domain = 'task' AND entity_id = ? AND sequence = ?
+    `).all(input.tenantId, input.workspaceId, input.journal.clientId, input.journal.operationId, input.journal.entityId, rootSequence);
+    if (rows.length !== 1)
+        throw new WorkspaceSyncRevisionConflictError({
+            stage: 'legacy-comment-append-root-ambiguous', domain: 'task-comments', entityId: input.journal.entityId,
+        });
+    const rootJournal = journalRow(rows[0]);
+    let rootProjected;
+    let rootPayload;
+    try {
+        rootProjected = projectWorkspaceSyncV3TaskRootJournalRow(rootJournal);
+        rootPayload = serializeTaskForSync(JSON.parse(rootJournal.payloadJson));
+    }
+    catch {
+        throw new WorkspaceSyncRevisionConflictError({
+            stage: 'legacy-comment-append-root-invalid', domain: 'task-comments', entityId: input.journal.entityId,
+        });
+    }
+    if (!rootProjected || rootProjected.domain !== 'task'
+        || rootProjected.entityId !== input.journal.entityId
+        || rootProjected.mutationKind !== 'metadata-update') {
+        throw new WorkspaceSyncRevisionConflictError({
+            stage: 'legacy-comment-append-root-mismatch', domain: 'task-comments', entityId: input.journal.entityId,
+        });
+    }
+    const aggregate = serializeWorkspaceSyncV3TaskCommentsPayload({
+        taskId: input.journal.entityId, comments: rootPayload.comments || [],
+    });
+    if (fingerprintWorkspaceSyncPayload(aggregate) !== input.projected.canonicalFingerprint) {
+        throw new WorkspaceSyncRevisionConflictError({
+            stage: 'legacy-comment-append-aggregate-mismatch',
+            domain: 'task-comments', entityId: input.journal.entityId,
+        });
+    }
+    return aggregate;
+}
+function assertTaskCommentsAppendCompatible(prior, current) {
+    const aggregate = serializeWorkspaceSyncV3TaskCommentsPayload(current.payload);
+    const byId = new Map(aggregate.comments.map((comment) => [comment.id, comment]));
+    if (prior.taskId !== aggregate.taskId || prior.comments.some((comment) => {
+        const candidate = byId.get(comment.id);
+        return !candidate || canonicalWorkspaceSyncJson(candidate) !== canonicalWorkspaceSyncJson(comment);
+    })) {
+        throw repairConflict('legacy-comment-aggregate-destructive-drift', current);
+    }
+}
+export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
+    const workspaceId = String(input.workspaceId || '').trim();
+    if (!workspaceId)
+        throw new Error('Workspace id is required.');
+    const now = new Date(input.now || Date.now()).toISOString();
+    const tenantId = input.core.getTenantId();
+    const db = input.core.getDatabaseAdapter();
+    return db.transaction(() => {
+        const lock = db.prepare(`
+            INSERT INTO workspace_sync_sequences (tenant_id, workspace_id, last_sequence, updated_at)
+            VALUES (?, ?, 0, ?)
+            ON CONFLICT (tenant_id, workspace_id) DO UPDATE SET updated_at = excluded.updated_at
+            RETURNING CAST(last_sequence AS TEXT) AS last_sequence
+        `).get(tenantId, workspaceId, now);
+        sequence(lock?.last_sequence);
+        const candidates = input.workflowCoverage
+            ? listWorkspaceSyncV3WorkflowRepairCandidates(input.core, workspaceId)
+            : input.planningOrderCoverage
+                ? listWorkspaceSyncV3PlanningOrderRepairCandidates(input.core, workspaceId)
+                : input.nestedCoverage
+                    ? listWorkspaceSyncV3NestedRepairCandidates(input.core, workspaceId)
+                    : listWorkspaceSyncV3CombinedRepairCandidates(input.core, workspaceId);
+        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 missing = [];
+        const legacyRelationshipSkews = [];
+        const legacyNestedDrifts = [];
+        for (const candidate of candidates) {
+            const current = revisions.get(`${candidate.domain}\0${candidate.entityId}`);
+            if (!current) {
+                missing.push(candidate);
+                continue;
+            }
+            const entityRevision = sequence(current.entity_revision);
+            const lifecycleRevision = sequence(current.lifecycle_revision);
+            const lastSequence = sequence(current.last_sequence);
+            if (Number(current.contract_version) !== WORKSPACE_SYNC_CONTRACT_VERSION
+                || !/^[a-f0-9]{64}$/.test(String(current.canonical_fingerprint || ''))
+                || BigInt(entityRevision) < 1n
+                || (lifecycleState(candidate) && BigInt(lifecycleRevision) < 1n)
+                || BigInt(lastSequence) < 1n) {
+                throw repairConflict('current-revision-invalid', candidate);
+            }
+            const canonicalFingerprint = fingerprintWorkspaceSyncPayload(candidate.payload);
+            if (candidate.domain === 'workstream-task-order'
+                && String(current.canonical_fingerprint) !== canonicalFingerprint) {
+                if (lifecycleRevision !== '0')
+                    throw repairConflict('workstream-task-order-lifecycle-invalid', candidate);
+                legacyNestedDrifts.push({
+                    candidate,
+                    entityRevision,
+                    lifecycleRevision,
+                    lastSequence,
+                    previousCanonicalFingerprint: String(current.canonical_fingerprint),
+                    canonicalFingerprint,
+                });
+            }
+            if (LEGACY_REPAIRABLE_NESTED_DOMAINS.has(candidate.domain)
+                && String(current.canonical_fingerprint) !== canonicalFingerprint) {
+                if (lifecycleRevision !== '0')
+                    throw repairConflict('legacy-nested-lifecycle-invalid', candidate);
+                const provenance = assertLegacyNestedRevisionProvenance({
+                    core: input.core, tenantId, workspaceId, candidate,
+                    entityRevision, lifecycleRevision, lastSequence,
+                    canonicalFingerprint: String(current.canonical_fingerprint),
+                });
+                if (candidate.domain === 'task-comments') {
+                    assertTaskCommentsAppendCompatible(priorTaskCommentsAggregate({
+                        core: input.core, tenantId, workspaceId,
+                        journal: provenance.journal, projected: provenance.projected,
+                    }), candidate);
+                }
+                legacyNestedDrifts.push({
+                    candidate, entityRevision, lifecycleRevision, lastSequence,
+                    previousCanonicalFingerprint: String(current.canonical_fingerprint),
+                    canonicalFingerprint,
+                });
+            }
+            if (candidate.domain === 'task-relationship'
+                && BigInt(lifecycleRevision) > BigInt(entityRevision)) {
+                const history = db.prepare(`
+                    SELECT sequence, contract_version, domain, entity_id, mutation_kind,
+                           CAST(entity_revision AS TEXT) AS entity_revision,
+                           CAST(lifecycle_revision AS TEXT) AS lifecycle_revision,
+                           content_sha256, size_bytes, payload_json
+                    FROM workspace_sync_journal
+                    WHERE tenant_id = ? AND workspace_id = ?
+                      AND domain = 'task-relationship' AND entity_id = ?
+                    ORDER BY sequence
+                `).all(tenantId, workspaceId, candidate.entityId);
+                const lifecycle = BigInt(lifecycleRevision);
+                if (entityRevision !== '1'
+                    || lifecycle > BigInt(Number.MAX_SAFE_INTEGER - 1)
+                    || history.length !== Number(lifecycle + 1n)) {
+                    throw repairConflict('legacy-relationship-history-size-invalid', candidate);
+                }
+                const canonicalCurrent = candidate.payload;
+                for (let index = 0; index < history.length; index += 1) {
+                    const row = history[index];
+                    let payload;
+                    try {
+                        payload = JSON.parse(String(row.payload_json || ''));
+                    }
+                    catch {
+                        throw repairConflict('legacy-relationship-history-payload-invalid', candidate);
+                    }
+                    const expectedMutation = index % 2 === 0 ? 'link' : 'unlink';
+                    const canonicalPayload = canonicalWorkspaceSyncJson(serializeTaskRelationshipForSync(payload));
+                    if (Number(row.contract_version) !== WORKSPACE_SYNC_CONTRACT_VERSION
+                        || row.domain !== 'task-relationship'
+                        || row.entity_id !== candidate.entityId
+                        || row.mutation_kind !== expectedMutation
+                        || sequence(row.entity_revision) !== '1'
+                        || sequence(row.lifecycle_revision) !== String(index)
+                        || row.content_sha256 != null
+                        || row.size_bytes != null
+                        || canonicalPayload !== row.payload_json
+                        || payload.id !== canonicalCurrent.id
+                        || payload.workspaceId !== canonicalCurrent.workspaceId
+                        || payload.sourceTaskId !== canonicalCurrent.sourceTaskId
+                        || payload.targetTaskId !== canonicalCurrent.targetTaskId
+                        || payload.kind !== canonicalCurrent.kind
+                        || payload.createdAt !== canonicalCurrent.createdAt
+                        || payload.createdBy !== canonicalCurrent.createdBy
+                        || (expectedMutation === 'link' ? payload.deletedAt !== null : payload.deletedAt == null)) {
+                        throw repairConflict('legacy-relationship-history-invalid', candidate);
+                    }
+                }
+                const prior = history.at(-1);
+                if (sequence(prior.sequence) !== lastSequence
+                    || prior.payload_json !== canonicalWorkspaceSyncJson(candidate.payload)
+                    || String(current.canonical_fingerprint) !== fingerprintWorkspaceSyncPayload(candidate.payload)) {
+                    throw repairConflict('legacy-relationship-current-mismatch', candidate);
+                }
+                legacyRelationshipSkews.push({
+                    candidate, entityRevision, lifecycleRevision, lastSequence,
+                });
+            }
+        }
+        const rowCount = legacyRelationshipSkews.length + legacyNestedDrifts.length + missing.reduce((count, candidate) => {
+            if (candidate.domain === 'workflow-published-definition'
+                || candidate.domain === 'workflow-execution'
+                || candidate.domain === 'workflow-execution-event')
+                return count + 1;
+            if (candidate.domain === 'workstream-task-order')
+                return count + 1;
+            if (candidate.domain === 'task-comments' || candidate.domain === 'task-checklist'
+                || candidate.domain === 'task-attachment-links' || candidate.domain === 'entity-event')
+                return count + 1;
+            if (candidate.domain === 'taxonomy')
+                return count + 1;
+            if (candidate.domain === 'task-relationship')
+                return count + (lifecycleState(candidate) ? 2 : 1);
+            return count + (lifecycleState(candidate) ? 4 : 2);
+        }, 0);
+        const high = db.prepare(`
+            INSERT INTO workspace_sync_sequences (tenant_id, workspace_id, last_sequence, updated_at)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT (tenant_id, workspace_id) DO UPDATE SET
+                last_sequence = workspace_sync_sequences.last_sequence + excluded.last_sequence,
+                updated_at = excluded.updated_at
+            RETURNING CAST(last_sequence AS TEXT) AS last_sequence
+        `).get(tenantId, workspaceId, rowCount, now);
+        const highWatermark = sequence(high?.last_sequence);
+        let next = BigInt(highWatermark) - BigInt(rowCount) + 1n;
+        const insertJournal = (candidate, mutationKind, entityRevision, lifecycleRevision, payload, operationId) => {
+            const value = next.toString(10);
+            db.prepare(`
+                INSERT INTO workspace_sync_journal (
+                    tenant_id, workspace_id, sequence, contract_version, operation_id, client_id,
+                    domain, entity_id, mutation_kind, entity_revision, lifecycle_revision,
+                    content_sha256, size_bytes, payload_json, occurred_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?)
+            `).run(tenantId, workspaceId, value, WORKSPACE_SYNC_CONTRACT_VERSION, operationId, BASELINE_CLIENT_ID, candidate.domain, candidate.entityId, mutationKind, entityRevision, lifecycleRevision, canonicalWorkspaceSyncJson(payload), occurredAt(candidate, now));
+            next += 1n;
+            return value;
+        };
+        const insertEvent = (candidate, identity) => {
+            const value = next.toString(10);
+            const event = {
+                id: identity.eventId,
+                workspaceId,
+                entityType: candidate.domain === 'initiative' || candidate.domain === 'workstream'
+                    ? candidate.domain : 'task',
+                entityId: candidate.entityId,
+                ...(candidate.domain === 'task' ? { taskId: candidate.entityId } : {}),
+                action: 'sync-v3-repair-baseline',
+                actor: 'system',
+                actorType: 'system',
+                details: {},
+                createdAt: occurredAt(candidate, now),
+            };
+            db.prepare(`
+                INSERT INTO workspace_sync_journal (
+                    tenant_id, workspace_id, sequence, contract_version, operation_id, client_id,
+                    domain, entity_id, mutation_kind, entity_revision, lifecycle_revision,
+                    content_sha256, size_bytes, payload_json, occurred_at
+                ) VALUES (?, ?, ?, ?, ?, ?, 'entity-event', ?, 'append', 1, 0, NULL, NULL, ?, ?)
+            `).run(tenantId, workspaceId, value, WORKSPACE_SYNC_CONTRACT_VERSION, identity.operationId, BASELINE_CLIENT_ID, identity.eventId, canonicalWorkspaceSyncJson(event), occurredAt(candidate, now));
+            db.prepare(`
+                INSERT INTO workspace_sync_entity_revisions (
+                    tenant_id, workspace_id, domain, entity_id, contract_version, entity_revision,
+                    lifecycle_revision, coexistence_owned, metadata_owned, reopen_assignee_owned,
+                    last_sequence, canonical_fingerprint, updated_at
+                ) VALUES (?, ?, 'entity-event', ?, ?, 1, 0, 0, 0, 0, ?, ?, ?)
+            `).run(tenantId, workspaceId, identity.eventId, WORKSPACE_SYNC_CONTRACT_VERSION, value, fingerprintWorkspaceSyncPayload(event), now);
+            next += 1n;
+        };
+        for (const candidate of missing) {
+            let entityRevision = 1;
+            let lifecycleRevision = 0;
+            let lastSequence;
+            if (candidate.domain === 'workflow-published-definition') {
+                const identity = operationIdentity(workspaceId, candidate.domain, candidate.entityId, 'publish');
+                lastSequence = insertJournal(candidate, 'publish', 1, 0, candidate.payload, identity.operationId);
+            }
+            else if (candidate.domain === 'workflow-execution') {
+                const identity = operationIdentity(workspaceId, candidate.domain, candidate.entityId, 'create');
+                lifecycleRevision = lifecycleState(candidate) ? 1 : 0;
+                lastSequence = insertJournal(candidate, 'create', entityRevision, lifecycleRevision, candidate.payload, identity.operationId);
+            }
+            else if (candidate.domain === 'workflow-execution-event') {
+                const identity = operationIdentity(workspaceId, candidate.domain, candidate.entityId, 'append');
+                lastSequence = insertJournal(candidate, 'append', 1, 0, candidate.payload, identity.operationId);
+            }
+            else if (candidate.domain === 'workstream-task-order') {
+                const identity = operationIdentity(workspaceId, candidate.domain, candidate.entityId, 'replace');
+                lastSequence = insertJournal(candidate, 'replace', 1, 0, candidate.payload, identity.operationId);
+            }
+            else if (candidate.domain === 'task-comments' || candidate.domain === 'task-checklist'
+                || candidate.domain === 'task-attachment-links' || candidate.domain === 'entity-event') {
+                const identity = operationIdentity(workspaceId, candidate.domain, candidate.entityId, candidate.mutationKind);
+                lastSequence = insertJournal(candidate, candidate.mutationKind, 1, 0, candidate.payload, identity.operationId);
+            }
+            else if (candidate.domain === 'taxonomy') {
+                const identity = operationIdentity(workspaceId, candidate.domain, candidate.entityId, 'replace-state');
+                lastSequence = insertJournal(candidate, 'replace-state', 1, 0, candidate.payload, identity.operationId);
+            }
+            else if (candidate.domain === 'task-relationship') {
+                const link = operationIdentity(workspaceId, candidate.domain, candidate.entityId, 'link');
+                lastSequence = insertJournal(candidate, 'link', 1, 0, activePayload(candidate), link.operationId);
+                if (lifecycleState(candidate)) {
+                    entityRevision = 2;
+                    lifecycleRevision = 1;
+                    const unlink = operationIdentity(workspaceId, candidate.domain, candidate.entityId, 'unlink');
+                    lastSequence = insertJournal(candidate, 'unlink', 2, 1, candidate.payload, unlink.operationId);
+                }
+            }
+            else {
+                const metadata = operationIdentity(workspaceId, candidate.domain, candidate.entityId, 'metadata-update');
+                lastSequence = insertJournal(candidate, 'metadata-update', 1, 0, activePayload(candidate), metadata.operationId);
+                insertEvent(candidate, metadata);
+                if (lifecycleState(candidate)) {
+                    entityRevision = 2;
+                    lifecycleRevision = 1;
+                    const archive = operationIdentity(workspaceId, candidate.domain, candidate.entityId, 'archive');
+                    lastSequence = insertJournal(candidate, 'archive', 2, 1, candidate.payload, archive.operationId);
+                    insertEvent(candidate, archive);
+                }
+            }
+            db.prepare(`
+                INSERT INTO workspace_sync_entity_revisions (
+                    tenant_id, workspace_id, domain, entity_id, contract_version, entity_revision,
+                    lifecycle_revision, coexistence_owned, metadata_owned, reopen_assignee_owned,
+                    last_sequence, canonical_fingerprint, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, 0, 0, 0, ?, ?, ?)
+            `).run(tenantId, workspaceId, candidate.domain, candidate.entityId, WORKSPACE_SYNC_CONTRACT_VERSION, entityRevision, lifecycleRevision, lastSequence, fingerprintWorkspaceSyncPayload(candidate.payload), now);
+        }
+        for (const repair of legacyRelationshipSkews) {
+            const mutationKind = lifecycleState(repair.candidate) ? 'unlink' : 'link';
+            const entityRevision = (BigInt(repair.lifecycleRevision) + 1n).toString(10);
+            const identity = operationIdentity(workspaceId, repair.candidate.domain, repair.candidate.entityId, `repair-lifecycle-skew-${mutationKind}-${repair.lastSequence}`);
+            const lastSequence = insertJournal(repair.candidate, mutationKind, entityRevision, repair.lifecycleRevision, repair.candidate.payload, identity.operationId);
+            const updated = db.prepare(`
+                UPDATE workspace_sync_entity_revisions
+                SET entity_revision = ?, last_sequence = ?, canonical_fingerprint = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND domain = 'task-relationship'
+                  AND entity_id = ? AND contract_version = ?
+                  AND entity_revision = ? AND lifecycle_revision = ? AND last_sequence = ?
+            `).run(entityRevision, lastSequence, fingerprintWorkspaceSyncPayload(repair.candidate.payload), now, tenantId, workspaceId, repair.candidate.entityId, WORKSPACE_SYNC_CONTRACT_VERSION, repair.entityRevision, repair.lifecycleRevision, repair.lastSequence);
+            if (Number(updated.changes) !== 1)
+                throw repairConflict('legacy-relationship-repair-raced', repair.candidate);
+        }
+        for (const repair of legacyNestedDrifts) {
+            const entityRevision = (BigInt(repair.entityRevision) + 1n).toString(10);
+            const identity = operationIdentity(workspaceId, repair.candidate.domain, repair.candidate.entityId, `repair-legacy-drift-${repair.lastSequence}`);
+            const lastSequence = insertJournal(repair.candidate, 'replace', entityRevision, repair.lifecycleRevision, repair.candidate.payload, identity.operationId);
+            const updated = db.prepare(`
+                UPDATE workspace_sync_entity_revisions
+                SET entity_revision = ?, last_sequence = ?, canonical_fingerprint = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND domain = ? AND entity_id = ?
+                  AND contract_version = ? AND entity_revision = ? AND lifecycle_revision = ?
+                  AND last_sequence = ? AND canonical_fingerprint = ?
+            `).run(entityRevision, lastSequence, repair.canonicalFingerprint, now, tenantId, workspaceId, repair.candidate.domain, repair.candidate.entityId, WORKSPACE_SYNC_CONTRACT_VERSION, repair.entityRevision, repair.lifecycleRevision, repair.lastSequence, repair.previousCanonicalFingerprint);
+            if (Number(updated.changes) !== 1)
+                throw repairConflict('legacy-nested-repair-raced', repair.candidate);
+        }
+        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;
+        const activeOwner = db.prepare(`
+            SELECT 1 AS active
+            FROM workspace_sync_projection_state
+            WHERE tenant_id = ? AND workspace_id = ? AND projection_id = ?
+              AND owner_mode = 'v3' AND contract_version = ?
+              AND coverage_profile_id = ? AND coverage_version = ? AND coverage_digest = ?
+        `).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
+            ? buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates({
+                core: input.core,
+                workspaceId,
+                snapshotSequence: highWatermark,
+                inventory: candidates,
+                nestedCoverage: input.nestedCoverage === true,
+                workflowCoverage: input.workflowCoverage === true,
+                planningOrderCoverage: input.planningOrderCoverage === 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 });
+        if (snapshot.snapshotSequence !== highWatermark) {
+            throw new Error('Combined repair baseline snapshot sequence changed while locked.');
+        }
+        return { highWatermark, insertedEntities: missing.length + legacyRelationshipSkews.length + legacyNestedDrifts.length,
+            insertedJournalRows: rowCount, snapshot };
+    })();
+}
+export function prepareWorkspaceSyncV3NestedRepairSnapshot(input) {
+    return prepareWorkspaceSyncV3CombinedRepairSnapshot({ ...input, nestedCoverage: true });
+}
+export function prepareWorkspaceSyncV3WorkflowRepairSnapshot(input) {
+    return prepareWorkspaceSyncV3CombinedRepairSnapshot({ ...input, workflowCoverage: true });
+}
+export function prepareWorkspaceSyncV3PlanningOrderRepairSnapshot(input) {
+    return prepareWorkspaceSyncV3CombinedRepairSnapshot({ ...input, planningOrderCoverage: true });
+}
+export function ensureWorkspaceSyncV3CombinedRepairBaselines(input) {
+    const { snapshot: _snapshot, ...result } = prepareWorkspaceSyncV3CombinedRepairSnapshot(input);
+    return result;
+}