@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/sync/v3/syncDurabilityStore.js

@@ -0,0 +1,4635 @@
+import { createHash, randomUUID } from 'crypto';
+import { normalizePlanningComments, } from '../planningCanonicalFields.js';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { buildTaskCreateActivityEventId } from './taskCreateActivityIdentity.js';
+import { buildTaskCommentActivityEventId } from './taskCommentActivityIdentity.js';
+import { buildTaskLifecycleActivityEventId, } from './taskLifecycleActivityIdentity.js';
+import { buildTaskMetadataActivityEventId } from './taskMetadataActivityIdentity.js';
+import { parseWorkspaceSyncV3OriginActor } from './workspaceSyncV3OriginActor.js';
+import { WorkspaceSyncJournalReader } from './workspaceSyncJournalReader.js';
+import { isLegacyEntityEventAdoptionIdentity, LEGACY_ENTITY_EVENT_ADOPTION_MAX_PAYLOAD_BYTES, } from './entityEventLegacyAdoptionContract.js';
+import { validateWorkspaceSyncV3EntityEventPayload } from './workspaceSyncV3NestedTaskCodecs.js';
+import { fingerprintWorkspaceSyncPayload } from './workspaceSyncPayloadFingerprint.js';
+export { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+export { fingerprintWorkspaceSyncPayload } from './workspaceSyncPayloadFingerprint.js';
+export const WORKSPACE_SYNC_CONTRACT_VERSION = 3;
+export const WORKSPACE_SYNC_INITIATIVE_PROJECTION_LOCK = 'projection:initiative/full-v1';
+export const WORKSPACE_SYNC_COMBINED_PROJECTION = 'coverage/task-planning-metadata-v1';
+export const WORKSPACE_SYNC_COMBINED_PROJECTION_LOCK = 'workspace-sync-v3-combined-projection';
+const MAX_OUTBOX_FUTURE_DEADLINE_MS = 48 * 60 * 60_000;
+const TASK_AGGREGATE_SUCCESSOR_MUTATIONS = new Map([
+    ['task-comments', new Set(['append', 'reconcile'])],
+    ['task-checklist', new Set(['replace'])],
+    ['task-attachment-links', new Set(['replace'])],
+]);
+const TASK_ROOT_SUCCESSOR_MUTATIONS = new Set([
+    'metadata-update', 'set-status', 'archive', 'unarchive', 'complete', 'reopen',
+]);
+const TASK_CREATE_RECOVERY_ERROR_CODES = new Set([
+    'TASK_CREATE_ID_CONFLICT',
+    'WORKSPACE_SYNC_REVISION_CONFLICT',
+]);
+const TASK_CREATE_FIELDS = new Set([
+    'title', 'description', 'priority', 'complexity', 'type', 'category', 'assignee',
+    'status', 'scheduledDate', 'dueDate', 'orderInDay', 'workstreamId', 'taxonomies',
+]);
+const TASK_ATTACHMENT_LINK_FIELDS = new Set([
+    'assetId', 'role', 'order', 'caption', 'displayName', 'originalFilename',
+    'referenceNumber', 'referenceLabel',
+]);
+const TASK_ATTACHMENT_FORBIDDEN_METADATA_VALUE = /^(?:file|data|blob):|^https?:\/\/|^(?:~(?:\/|$)|\/(?:Users|home|private|tmp|var)(?:\/|$))|^[A-Za-z]:[\\/]/i;
+const TASK_LIFECYCLE_ACTIVITY_MUTATIONS = new Set([
+    'archive', 'unarchive', 'complete', 'reopen', 'set-status', 'restore',
+]);
+function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function normalizeWorkspaceSyncLockTargets(targets) {
+    return Array.from(new Map(targets.map((target) => {
+        const domain = requireText(target.domain, 'Domain');
+        const entityId = requireText(target.entityId, 'Entity id');
+        return [`${domain}\u0000${entityId}`, { domain, entityId }];
+    })).values()).sort((left, right) => (compareCodeUnits(left.domain, right.domain) || compareCodeUnits(left.entityId, right.entityId)));
+}
+function requiresInitiativeProjectionLock(targets) {
+    return targets.some((target) => (target.domain === 'initiative'
+        || target.domain === 'initiative-assets'
+        || target.domain === 'initiative-owners'));
+}
+function requiresCombinedProjectionLock(targets) {
+    return targets.some((target) => (target.domain === 'task'
+        || target.domain === 'task-relationship'
+        || target.domain === 'taxonomy'
+        || target.domain === 'initiative'
+        || target.domain === 'workstream'));
+}
+export class WorkspaceSyncIdempotencyConflictError extends Error {
+    code = 'WORKSPACE_SYNC_IDEMPOTENCY_CONFLICT';
+    statusCode = 409;
+    constructor() {
+        super('The operation id is already bound to a different request.');
+        this.name = 'WorkspaceSyncIdempotencyConflictError';
+    }
+}
+export class WorkspaceSyncPlanningOwnershipChangedError extends Error {
+    code = 'WORKSPACE_SYNC_PLANNING_OWNERSHIP_CHANGED';
+    statusCode = 409;
+    constructor() {
+        super('Durable planning ownership changed before the local operation could be captured.');
+        this.name = 'WorkspaceSyncPlanningOwnershipChangedError';
+    }
+}
+export class WorkspaceSyncLeaseLostError extends Error {
+    code = 'WORKSPACE_SYNC_LEASE_LOST';
+    constructor() {
+        super('The workspace sync operation lease is no longer owned by this caller.');
+        this.name = 'WorkspaceSyncLeaseLostError';
+    }
+}
+export class WorkspaceSyncRevisionConflictError extends Error {
+    code = 'WORKSPACE_SYNC_REVISION_CONFLICT';
+    statusCode = 409;
+    details;
+    constructor(details) {
+        super('The workspace entity revision no longer matches the operation base revision.');
+        this.name = 'WorkspaceSyncRevisionConflictError';
+        this.details = details;
+    }
+}
+export class WorkspaceSyncEntityBusyError extends Error {
+    code = 'WORKSPACE_SYNC_ENTITY_BUSY';
+    statusCode = 409;
+    details;
+    retryable;
+    retryAfterAt;
+    retryHint;
+    constructor(input) {
+        super('The workspace entity already has an unaccepted local operation.');
+        this.name = 'WorkspaceSyncEntityBusyError';
+        this.details = input?.details;
+        this.retryable = input?.retryable !== false;
+        this.retryAfterAt = input?.retryAfterAt;
+        this.retryHint = input?.retryHint || (this.retryable
+            ? this.retryAfterAt
+                ? `Wait until at least ${this.retryAfterAt} for Sync Manager to retry the blocking operation, then retry the same tool call. Refresh alone will not clear it.`
+                : 'Let Sync Manager dispatch the blocking operation, then retry the same tool call. Refresh alone will not clear it.'
+            : 'The blocking sync operation needs recovery. Do not keep retrying this mutation; open Sync Manager and resolve the reported blocked operation first.');
+    }
+}
+export function resolveWorkspaceSyncActiveOperationState(input) {
+    const status = String(input.status || '');
+    if (status === 'blocked')
+        return 'blocked';
+    const nowMs = Date.parse(input.now);
+    const nextAttemptMs = input.nextAttemptAt == null
+        ? Number.NaN
+        : Date.parse(String(input.nextAttemptAt));
+    const leaseExpiresMs = input.leaseExpiresAt == null
+        ? Number.NaN
+        : Date.parse(String(input.leaseExpiresAt));
+    if (status === 'in_flight') {
+        return Number.isFinite(leaseExpiresMs) && leaseExpiresMs <= nowMs
+            ? 'stale'
+            : 'in-flight';
+    }
+    return Number.isFinite(nextAttemptMs) && nextAttemptMs > nowMs
+        ? 'retry-scheduled'
+        : 'pending';
+}
+function workspaceSyncEntityBusyError(input) {
+    const nowMs = Date.parse(input.now);
+    const allBlockingOperations = input.active.map((row) => {
+        const status = String(row.status || '');
+        const nextAttemptAt = row.next_attempt_at == null ? null : String(row.next_attempt_at);
+        const leaseExpiresAt = row.lease_expires_at == null ? null : String(row.lease_expires_at);
+        const state = resolveWorkspaceSyncActiveOperationState({
+            status,
+            nextAttemptAt,
+            leaseExpiresAt,
+            now: input.now,
+        });
+        return {
+            operationId: String(row.operation_id || ''),
+            domain: String(row.domain || ''),
+            entityId: String(row.entity_id || ''),
+            mutationKind: String(row.mutation_kind || ''),
+            state,
+            attemptCount: Number(row.attempt_count || 0),
+            createdAt: String(row.created_at || ''),
+            updatedAt: String(row.updated_at || ''),
+            ...(nextAttemptAt ? { nextAttemptAt } : {}),
+            ...(leaseExpiresAt ? { leaseExpiresAt } : {}),
+            ...(row.last_error_code ? { errorCode: String(row.last_error_code) } : {}),
+        };
+    });
+    const blockingOperations = allBlockingOperations.slice(0, 5);
+    const retryable = allBlockingOperations.every((operation) => operation.state !== 'blocked');
+    const retryAfterAt = retryable
+        ? allBlockingOperations
+            .flatMap((operation) => [operation.nextAttemptAt, operation.leaseExpiresAt])
+            .filter((value) => typeof value === 'string' && Date.parse(value) > nowMs)
+            .sort((left, right) => Date.parse(right) - Date.parse(left))[0]
+        : undefined;
+    const retryHint = retryable && !retryAfterAt
+        && allBlockingOperations.some((operation) => operation.state === 'stale')
+        ? 'The blocking operation has an expired lease and is reclaimable. Run or check Sync Manager, then retry the same tool call after it reclaims the operation. Refresh alone will not clear it.'
+        : undefined;
+    return new WorkspaceSyncEntityBusyError({
+        retryable,
+        retryAfterAt,
+        retryHint,
+        details: {
+            target: input.target,
+            blockingOperations,
+            blockingOperationCount: input.active.length,
+            diagnosticsTruncated: input.active.length > blockingOperations.length,
+        },
+    });
+}
+function requireText(value, label) {
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        throw new Error(`${label} is required.`);
+    return normalized;
+}
+function requireOutboxDispatchClass(value) {
+    const normalized = requireText(value, 'Outbox dispatch class');
+    if (normalized !== 'ordinary' && normalized !== 'legacy-adoption') {
+        throw new Error('Outbox dispatch class is invalid.');
+    }
+    return normalized;
+}
+function requireIsoTimestamp(value, label) {
+    const normalized = requireText(value, label);
+    const epochMs = Date.parse(normalized);
+    if (!Number.isFinite(epochMs))
+        throw new Error(`${label} must be an ISO timestamp.`);
+    return new Date(epochMs).toISOString();
+}
+/**
+ * Authoritative feed apply may replace a provisional entity event only after
+ * durable recovery has explicitly superseded the operation that created it.
+ * Persisted targets or a recognized deterministic task-root identity provide
+ * the provenance proof; arbitrary same-ID conflicts continue to fail closed.
+ */
+export function hasCompletedRecoveryForSupersededEntityEvent(db, input) {
+    const tenantId = requireText(input.tenantId, 'Tenant id');
+    const workspaceId = requireText(input.workspaceId, 'Workspace id');
+    const entityType = requireText(input.entityType, 'Entity type');
+    const entityId = requireText(input.entityId, 'Entity id');
+    const eventId = requireText(input.eventId, 'Entity event id');
+    const explicitTarget = db.prepare(`
+        SELECT 1 AS proven
+        FROM workspace_sync_outbox AS source
+        INNER JOIN workspace_sync_outbox_recoveries AS recovery
+          ON recovery.tenant_id = source.tenant_id
+         AND recovery.workspace_id = source.workspace_id
+         AND recovery.recovery_batch_id = source.recovery_batch_id
+        INNER JOIN workspace_sync_outbox_targets AS event_target
+          ON event_target.tenant_id = source.tenant_id
+         AND event_target.workspace_id = source.workspace_id
+         AND event_target.client_id = source.client_id
+         AND event_target.operation_id = source.operation_id
+         AND event_target.domain = 'entity-event'
+         AND event_target.entity_id = ?
+        INNER JOIN workspace_sync_outbox_targets AS parent_target
+          ON parent_target.tenant_id = source.tenant_id
+         AND parent_target.workspace_id = source.workspace_id
+         AND parent_target.client_id = source.client_id
+         AND parent_target.operation_id = source.operation_id
+         AND parent_target.domain = ?
+         AND parent_target.entity_id = ?
+        WHERE source.tenant_id = ?
+          AND source.workspace_id = ?
+          AND source.status = 'superseded'
+          AND recovery.state = 'completed'
+          AND recovery.completed_at IS NOT NULL
+        LIMIT 1
+    `).get(eventId, entityType, entityId, tenantId, workspaceId);
+    if (Number(explicitTarget?.proven || 0) === 1)
+        return true;
+    if (entityType !== 'task')
+        return false;
+    const sources = db.prepare(`
+        SELECT source.client_id, source.operation_id, source.mutation_kind
+        FROM workspace_sync_outbox AS source
+        INNER JOIN workspace_sync_outbox_recoveries AS recovery
+          ON recovery.tenant_id = source.tenant_id
+         AND recovery.workspace_id = source.workspace_id
+         AND recovery.recovery_batch_id = source.recovery_batch_id
+        WHERE source.tenant_id = ?
+          AND source.workspace_id = ?
+          AND source.domain = 'task'
+          AND source.entity_id = ?
+          AND source.status = 'superseded'
+          AND recovery.state = 'completed'
+          AND recovery.completed_at IS NOT NULL
+    `).all(tenantId, workspaceId, entityId);
+    return sources.some((source) => {
+        const clientId = String(source.client_id || '').trim();
+        const operationId = String(source.operation_id || '').trim();
+        const mutationKind = String(source.mutation_kind || '').trim();
+        if (!clientId || !operationId)
+            return false;
+        if (mutationKind === 'create') {
+            return buildTaskCreateActivityEventId({
+                workspaceId, clientId, operationId, taskId: entityId,
+            }) === eventId;
+        }
+        if (mutationKind === 'metadata-update') {
+            return buildTaskMetadataActivityEventId({
+                workspaceId, clientId, operationId, taskId: entityId,
+            }) === eventId;
+        }
+        if (TASK_LIFECYCLE_ACTIVITY_MUTATIONS.has(mutationKind)) {
+            return buildTaskLifecycleActivityEventId({
+                workspaceId,
+                clientId,
+                operationId,
+                taskId: entityId,
+                mutationKind: mutationKind,
+            }) === eventId;
+        }
+        return false;
+    });
+}
+function buildRecoveryReplayOperationId(recoveryBatchId, baselineMarker, clientId, operationId) {
+    const digest = createHash('sha256')
+        .update(`${recoveryBatchId}\0${baselineMarker}\0${clientId}\0${operationId}`, 'utf8')
+        .digest('hex');
+    return `recovery-${digest}`;
+}
+function buildEntityEventAdoptionRecoveryReplayOperationId(recoveryBatchId, baselineMarker, clientId, operationId) {
+    const digest = createHash('sha256')
+        .update(`${recoveryBatchId}\0${baselineMarker}\0${clientId}\0${operationId}`, 'utf8')
+        .digest('hex');
+    return `legacy-entity-event-adoption-${digest}`;
+}
+function normalizeSequence(value) {
+    if (typeof value === 'number' && !Number.isSafeInteger(value)) {
+        throw new Error('Workspace sync sequence exceeded the JavaScript safe integer range.');
+    }
+    const normalized = String(value ?? '').trim();
+    if (!/^\d+$/.test(normalized))
+        throw new Error('Workspace sync sequence is invalid.');
+    return BigInt(normalized).toString(10);
+}
+function normalizeRevisionKind(value) {
+    if (value === 'metadata' || value === 'lifecycle' || value === 'both')
+        return value;
+    throw new Error('Revision kind must be metadata, lifecycle, or both.');
+}
+function operationParams(identity) {
+    return [
+        requireText(identity.tenantId, 'Tenant id'),
+        requireText(identity.workspaceId, 'Workspace id'),
+        requireText(identity.clientId, 'Client id'),
+        requireText(identity.operationId, 'Operation id'),
+    ];
+}
+export class WorkspaceSyncDurabilityStore {
+    db;
+    journalReader;
+    constructor(db) {
+        this.db = db;
+        this.journalReader = new WorkspaceSyncJournalReader(db);
+    }
+    readEntityRevisionCoordinates(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const domain = requireText(input.domain, 'Domain');
+        const entityId = requireText(input.entityId, 'Entity id');
+        return this.journalReader.readEntityRevisionCoordinates({ tenantId, workspaceId, domain, entityId });
+    }
+    readInitiativeProjectionOwnership(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const rows = this.db.prepare(`
+            SELECT projection_id, owner_mode, CAST(epoch AS TEXT) AS epoch
+            FROM workspace_sync_projection_state
+            WHERE tenant_id = ? AND workspace_id = ?
+              AND projection_id IN (?, 'initiative/full-v1')
+        `).all(tenantId, workspaceId, WORKSPACE_SYNC_COMBINED_PROJECTION);
+        let combined = null;
+        let initiative = null;
+        for (const row of rows) {
+            if ((row.owner_mode !== 'v2' && row.owner_mode !== 'v3')
+                || !/^\d+$/.test(String(row.epoch ?? ''))) {
+                throw new Error('Workspace sync initiative projection ownership is invalid.');
+            }
+            const ownership = {
+                owner: row.owner_mode,
+                epoch: BigInt(String(row.epoch)).toString(10),
+            };
+            if (row.projection_id === WORKSPACE_SYNC_COMBINED_PROJECTION)
+                combined = ownership;
+            else if (row.projection_id === 'initiative/full-v1')
+                initiative = ownership;
+            else
+                throw new Error('Workspace sync initiative projection ownership is invalid.');
+        }
+        if (combined?.owner === 'v3')
+            return combined;
+        if (initiative)
+            return initiative;
+        if (combined) {
+            if (combined.owner !== 'v2') {
+                throw new Error('Workspace sync combined projection ownership is invalid.');
+            }
+            return { owner: 'v2', epoch: '0' };
+        }
+        return { owner: 'v2', epoch: '0' };
+    }
+    readCombinedProjectionOwnership(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const row = this.db.prepare(`
+            SELECT owner_mode, CAST(epoch AS TEXT) AS epoch
+            FROM workspace_sync_projection_state
+            WHERE tenant_id = ? AND workspace_id = ? AND projection_id = ?
+        `).get(tenantId, workspaceId, WORKSPACE_SYNC_COMBINED_PROJECTION);
+        if (!row)
+            return { owner: 'v2', epoch: '0' };
+        if ((row.owner_mode !== 'v2' && row.owner_mode !== 'v3')
+            || !/^\d+$/.test(String(row.epoch ?? ''))) {
+            throw new Error('Workspace sync combined projection ownership is invalid.');
+        }
+        return {
+            owner: row.owner_mode,
+            epoch: BigInt(String(row.epoch)).toString(10),
+        };
+    }
+    runCombinedProjectionTransaction(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Combined projection transaction time');
+        return this.db.transaction(() => {
+            this.db.prepare(`
+                INSERT INTO workspace_sync_domain_locks (tenant_id, workspace_id, domain, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT (tenant_id, workspace_id, domain) DO UPDATE SET updated_at = excluded.updated_at
+            `).run(tenantId, workspaceId, WORKSPACE_SYNC_COMBINED_PROJECTION_LOCK, now);
+            return input.apply(this.readCombinedProjectionOwnership({ tenantId, workspaceId }));
+        })();
+    }
+    readWorkspaceDomainOwnership(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const domain = requireText(input.domain, 'Domain');
+        const entityId = requireText(input.entityId, 'Entity id');
+        const revision = this.db.prepare(`
+            SELECT 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, coexistence_owned
+            FROM workspace_sync_entity_revisions
+            WHERE tenant_id = ? AND workspace_id = ? AND contract_version = ?
+              AND domain = ? AND entity_id = ?
+        `).get(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, domain, entityId);
+        const active = this.db.prepare(`
+            SELECT 1 AS active
+            FROM workspace_sync_outbox AS outbox
+            WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+              AND outbox.contract_version = ?
+              AND outbox.status IN ('pending', 'in_flight', 'blocked')
+              AND (
+                (outbox.domain = ? AND outbox.entity_id = ?)
+                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 = ? AND target.entity_id = ?
+                )
+              )
+            LIMIT 1
+        `).get(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, domain, entityId, domain, entityId);
+        const entityRevision = normalizeSequence(revision?.entity_revision ?? 0);
+        return {
+            domain,
+            entityId,
+            activeOperation: Number(active?.active || 0) === 1,
+            owned: BigInt(entityRevision) > 0n && Number(revision?.coexistence_owned) === 1,
+            entityRevision,
+            lifecycleRevision: normalizeSequence(revision?.lifecycle_revision ?? 0),
+            lastSequence: revision?.last_sequence === undefined ? null : normalizeSequence(revision.last_sequence),
+            canonicalFingerprint: revision?.canonical_fingerprint
+                ? requireText(revision.canonical_fingerprint, 'Canonical fingerprint')
+                : null,
+        };
+    }
+    listWorkspaceDomainOwnership(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const domain = requireText(input.domain, 'Domain');
+        const entityIds = Array.from(new Set(input.entityIds
+            .map((entityId) => requireText(entityId, 'Entity id'))))
+            .sort();
+        if (entityIds.length === 0)
+            return [];
+        if (entityIds.length > 100)
+            throw new Error('Domain ownership lookup supports at most 100 entity ids.');
+        const values = entityIds.map(() => '(?)').join(', ');
+        const rows = this.db.prepare(`
+            WITH requested(entity_id) AS (VALUES ${values})
+            SELECT requested.entity_id,
+                   CAST(revision.entity_revision AS TEXT) AS entity_revision,
+                   CAST(revision.lifecycle_revision AS TEXT) AS lifecycle_revision,
+                   CAST(revision.last_sequence AS TEXT) AS last_sequence,
+                   revision.canonical_fingerprint,
+                   revision.coexistence_owned,
+                   CASE WHEN EXISTS (
+                       SELECT 1
+                       FROM workspace_sync_outbox AS outbox
+                       WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+                         AND outbox.contract_version = ?
+                         AND outbox.status IN ('pending', 'in_flight', 'blocked')
+                         AND (
+                           (outbox.domain = ? AND outbox.entity_id = requested.entity_id)
+                           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 = ? AND target.entity_id = requested.entity_id
+                           )
+                         )
+                   ) THEN 1 ELSE 0 END AS active_operation
+            FROM requested
+            LEFT JOIN workspace_sync_entity_revisions AS revision
+              ON revision.tenant_id = ? AND revision.workspace_id = ?
+             AND revision.contract_version = ? AND revision.domain = ?
+             AND revision.entity_id = requested.entity_id
+            ORDER BY requested.entity_id
+        `).all(...entityIds, tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, domain, domain, tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, domain);
+        return rows.map((row) => {
+            const entityRevision = normalizeSequence(row.entity_revision ?? 0);
+            return {
+                domain,
+                entityId: requireText(row.entity_id, 'Entity id'),
+                activeOperation: Number(row.active_operation || 0) === 1,
+                owned: BigInt(entityRevision) > 0n && Number(row.coexistence_owned) === 1,
+                entityRevision,
+                lifecycleRevision: normalizeSequence(row.lifecycle_revision ?? 0),
+                lastSequence: row.last_sequence === undefined || row.last_sequence === null
+                    ? null
+                    : normalizeSequence(row.last_sequence),
+                canonicalFingerprint: row.canonical_fingerprint
+                    ? requireText(row.canonical_fingerprint, 'Canonical fingerprint')
+                    : null,
+            };
+        });
+    }
+    listOwnedWorkspaceDomainRevisionsAfter(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const domains = Array.from(new Set(input.domains.map((domain) => requireText(domain, 'Domain')))).sort();
+        const sequence = normalizeSequence(input.sequence);
+        if (domains.length === 0)
+            return [];
+        const placeholders = domains.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+            SELECT domain, entity_id, CAST(last_sequence AS TEXT) AS last_sequence
+            FROM workspace_sync_entity_revisions
+            WHERE tenant_id = ? AND workspace_id = ? AND contract_version = ?
+              AND domain IN (${placeholders})
+              AND coexistence_owned = 1
+              AND entity_revision > 0
+              AND last_sequence IS NOT NULL
+              AND last_sequence > ?
+            ORDER BY domain ASC, entity_id ASC
+        `).all(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, ...domains, sequence);
+        return rows.map((row) => ({
+            domain: requireText(row.domain, 'Domain'),
+            entityId: requireText(row.entity_id, 'Entity id'),
+            lastSequence: normalizeSequence(row.last_sequence),
+        }));
+    }
+    applyReplicatedEntityRevision(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const domain = requireText(input.domain, 'Domain');
+        const entityId = requireText(input.entityId, 'Entity id');
+        const sequence = normalizeSequence(input.sequence);
+        const entityRevision = normalizeSequence(input.entityRevision);
+        const lifecycleRevision = normalizeSequence(input.lifecycleRevision);
+        const canonicalFingerprint = requireText(input.canonicalFingerprint, 'Canonical fingerprint');
+        const now = requireIsoTimestamp(input.now, 'Replicated revision timestamp');
+        if (BigInt(sequence) <= 0n || BigInt(entityRevision) <= 0n || !/^[a-f0-9]{64}$/.test(canonicalFingerprint)) {
+            throw new WorkspaceSyncRevisionConflictError({
+                domain,
+                entityId,
+                reason: 'invalid-replicated-revision',
+                incoming: { sequence, entityRevision, lifecycleRevision, canonicalFingerprint },
+            });
+        }
+        return this.db.transaction(() => {
+            const current = this.readWorkspaceDomainOwnership({ tenantId, workspaceId, domain, entityId });
+            const applyAuthoritativeRevision = () => {
+                const result = input.applyMutation();
+                if (input.shouldRecordRevision?.(result) === false) {
+                    return { state: 'deferred', result };
+                }
+                this.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 (?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?)
+                    ON CONFLICT (tenant_id, workspace_id, domain, entity_id) DO UPDATE SET
+                        contract_version = excluded.contract_version,
+                        entity_revision = excluded.entity_revision,
+                        lifecycle_revision = excluded.lifecycle_revision,
+                        coexistence_owned = 1,
+                        metadata_owned = CASE
+                            WHEN workspace_sync_entity_revisions.metadata_owned = 1 OR excluded.metadata_owned = 1 THEN 1
+                            ELSE 0
+                        END,
+                        reopen_assignee_owned = CASE
+                            WHEN workspace_sync_entity_revisions.reopen_assignee_owned = 1
+                                OR excluded.reopen_assignee_owned = 1 THEN 1
+                            ELSE 0
+                        END,
+                        last_sequence = excluded.last_sequence,
+                        canonical_fingerprint = excluded.canonical_fingerprint,
+                        updated_at = excluded.updated_at
+                `).run(tenantId, workspaceId, domain, entityId, WORKSPACE_SYNC_CONTRACT_VERSION, entityRevision, lifecycleRevision, input.metadataOwned ? 1 : 0, input.reopenAssigneeOwned ? 1 : 0, sequence, canonicalFingerprint, now);
+                return { state: 'applied', result };
+            };
+            const incomingEntity = BigInt(entityRevision);
+            const currentEntity = BigInt(current.entityRevision);
+            const incomingLifecycle = BigInt(lifecycleRevision);
+            const currentLifecycle = BigInt(current.lifecycleRevision);
+            if (input.allowAuthoritativeRevisionReset
+                && (incomingEntity < currentEntity || incomingLifecycle < currentLifecycle)) {
+                const reset = this.db.prepare(`
+                    UPDATE workspace_sync_entity_revisions
+                    SET entity_revision = ?, lifecycle_revision = ?, last_sequence = ?, updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND domain = ? AND entity_id = ?
+                      AND entity_revision = ? AND lifecycle_revision = ?
+                `).run(entityRevision, lifecycleRevision, sequence, now, tenantId, workspaceId, domain, entityId, current.entityRevision, current.lifecycleRevision);
+                if (Number(reset.changes || 0) !== 1) {
+                    throw new WorkspaceSyncRevisionConflictError({
+                        domain,
+                        entityId,
+                        reason: 'authoritative-recovery-revision-reset-raced',
+                        incoming: { sequence, entityRevision, lifecycleRevision, canonicalFingerprint },
+                        current,
+                    });
+                }
+                return { state: 'current' };
+            }
+            if (incomingEntity < currentEntity)
+                return { state: 'stale' };
+            if (incomingLifecycle < currentLifecycle) {
+                throw new WorkspaceSyncRevisionConflictError({
+                    domain,
+                    entityId,
+                    reason: 'lifecycle-revision-regression',
+                    incoming: { sequence, entityRevision, lifecycleRevision, canonicalFingerprint },
+                    current,
+                });
+            }
+            if (incomingEntity === currentEntity) {
+                const coordinatesMatch = current.lifecycleRevision === lifecycleRevision
+                    && current.lastSequence === sequence;
+                if (!coordinatesMatch)
+                    throw new WorkspaceSyncRevisionConflictError({
+                        domain,
+                        entityId,
+                        reason: 'equal-revision-divergence',
+                        incoming: { sequence, entityRevision, lifecycleRevision, canonicalFingerprint },
+                        current,
+                    });
+                if (current.canonicalFingerprint !== canonicalFingerprint) {
+                    if (!input.allowAuthoritativeEqualRevisionReplacement) {
+                        throw new WorkspaceSyncRevisionConflictError({
+                            domain,
+                            entityId,
+                            reason: 'equal-revision-divergence',
+                            incoming: { sequence, entityRevision, lifecycleRevision, canonicalFingerprint },
+                            current,
+                        });
+                    }
+                    const result = input.applyMutation();
+                    if (input.shouldRecordRevision?.(result) === false) {
+                        return { state: 'deferred', result };
+                    }
+                    const updated = this.db.prepare(`
+                        UPDATE workspace_sync_entity_revisions
+                        SET canonical_fingerprint = ?,
+                            metadata_owned = CASE WHEN metadata_owned = 1 OR ? = 1 THEN 1 ELSE 0 END,
+                            reopen_assignee_owned = CASE WHEN reopen_assignee_owned = 1 OR ? = 1 THEN 1 ELSE 0 END,
+                            updated_at = ?
+                        WHERE tenant_id = ? AND workspace_id = ? AND domain = ? AND entity_id = ?
+                          AND entity_revision = ? AND lifecycle_revision = ? AND last_sequence = ?
+                    `).run(canonicalFingerprint, input.metadataOwned ? 1 : 0, input.reopenAssigneeOwned ? 1 : 0, now, tenantId, workspaceId, domain, entityId, entityRevision, lifecycleRevision, sequence);
+                    if (Number(updated.changes || 0) !== 1) {
+                        throw new WorkspaceSyncRevisionConflictError({
+                            domain,
+                            entityId,
+                            reason: 'authoritative-equal-revision-replacement-raced',
+                            incoming: { sequence, entityRevision, lifecycleRevision, canonicalFingerprint },
+                        });
+                    }
+                    return { state: 'applied', result };
+                }
+                return { state: 'current' };
+            }
+            if (current.lastSequence !== null && BigInt(sequence) <= BigInt(current.lastSequence)) {
+                throw new WorkspaceSyncRevisionConflictError({
+                    domain,
+                    entityId,
+                    reason: 'sequence-regression',
+                    incoming: { sequence, entityRevision, lifecycleRevision, canonicalFingerprint },
+                    current,
+                });
+            }
+            return applyAuthoritativeRevision();
+        })();
+    }
+    runLocalTaskDeleteCaptureTransaction(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const taskId = requireText(input.taskId, 'Task id');
+        const now = requireIsoTimestamp(input.now, 'Delete capture time');
+        return this.db.transaction(() => {
+            const lock = this.db.prepare(`
+                INSERT INTO workspace_sync_domain_locks (tenant_id, workspace_id, domain, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT (tenant_id, workspace_id, domain) DO UPDATE SET updated_at = excluded.updated_at
+            `);
+            lock.run(tenantId, workspaceId, WORKSPACE_SYNC_COMBINED_PROJECTION_LOCK, now);
+            lock.run(tenantId, workspaceId, 'task-relationship', now);
+            lock.run(tenantId, workspaceId, `local-outbox:task:${taskId}`, now);
+            return input.apply();
+        })();
+    }
+    runLocalTaskRestoreCaptureTransaction(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const taskId = requireText(input.taskId, 'Task id');
+        const now = requireIsoTimestamp(input.now, 'Restore capture time');
+        return this.db.transaction(() => {
+            const lock = this.db.prepare(`
+                INSERT INTO workspace_sync_domain_locks (tenant_id, workspace_id, domain, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT (tenant_id, workspace_id, domain) DO UPDATE SET updated_at = excluded.updated_at
+            `);
+            lock.run(tenantId, workspaceId, WORKSPACE_SYNC_COMBINED_PROJECTION_LOCK, now);
+            lock.run(tenantId, workspaceId, `local-outbox:task:${taskId}`, now);
+            return input.apply();
+        })();
+    }
+    readOperation(input) {
+        const ids = operationParams(input.identity);
+        const requestFingerprint = requireText(input.requestFingerprint, 'Request fingerprint');
+        const row = this.readOperationRow(ids);
+        if (!row)
+            return null;
+        this.assertMatchingOperation(row, requestFingerprint);
+        if (row.status === 'committed') {
+            if (typeof row.response_json !== 'string')
+                throw new Error('Committed operation is missing its response.');
+            return {
+                state: 'committed',
+                responseJson: row.response_json,
+                acceptedSequence: row.accepted_sequence == null ? null : normalizeSequence(row.accepted_sequence),
+            };
+        }
+        return {
+            state: 'in_progress',
+            retryAt: requireIsoTimestamp(row.lease_expires_at, 'Existing lease expiry'),
+        };
+    }
+    readCommittedOperationResponse(identity) {
+        const row = this.db.prepare(`
+            SELECT response_json
+            FROM workspace_sync_operation_results
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+              AND status = 'committed'
+        `).get(...operationParams(identity));
+        if (!row)
+            return null;
+        if (typeof row.response_json !== 'string')
+            throw new Error('Committed operation is missing its response.');
+        return row.response_json;
+    }
+    readOperationReservationMetadata(identity) {
+        const row = this.db.prepare(`
+            SELECT status, created_at
+            FROM workspace_sync_operation_results
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+        `).get(...operationParams(identity));
+        if (!row)
+            return null;
+        if (row.status !== 'processing' && row.status !== 'committed') {
+            throw new Error('Workspace sync operation status is invalid.');
+        }
+        return {
+            status: row.status,
+            createdAt: requireIsoTimestamp(row.created_at, 'Operation reservation creation time'),
+        };
+    }
+    readOutboxOperation(identity) {
+        const row = this.db.prepare(`
+            SELECT tenant_id, workspace_id, client_id, operation_id, dispatch_class, domain, entity_id,
+                   mutation_kind, owns_task_metadata, owns_task_lifecycle, owns_task_assignee,
+                   CAST(base_entity_revision AS TEXT) AS base_entity_revision,
+                   CAST(base_lifecycle_revision AS TEXT) AS base_lifecycle_revision,
+                   payload_json, payload_fingerprint, status, attempt_count,
+                   initial_not_found_attempt_count,
+                   CAST(enqueue_sequence AS TEXT) AS enqueue_sequence,
+                   rebase_before_first_attempt, lease_owner, lease_expires_at
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+        `).get(...operationParams(identity));
+        return row ? this.mapOutboxRow(row) : null;
+    }
+    readV3DispatchSettlementEvidence(identity) {
+        const row = this.db.prepare(`
+            SELECT outbox.status, outbox.authoritative_response_json,
+                   CAST(outbox.accepted_sequence AS TEXT) AS accepted_sequence,
+                   outbox.recovery_batch_id, recovery.state AS recovery_state,
+                   recovery.baseline_marker, recovery.completed_at
+            FROM workspace_sync_outbox AS outbox
+            LEFT JOIN workspace_sync_outbox_recoveries AS recovery
+              ON recovery.tenant_id = outbox.tenant_id
+             AND recovery.workspace_id = outbox.workspace_id
+             AND recovery.recovery_batch_id = outbox.recovery_batch_id
+            WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+              AND outbox.client_id = ? AND outbox.operation_id = ?
+        `).get(...operationParams(identity));
+        if (!row)
+            return null;
+        if (row.status === 'accepted' && typeof row.authoritative_response_json === 'string') {
+            return {
+                kind: 'accepted',
+                acceptedSequence: row.accepted_sequence == null
+                    ? null
+                    : String(row.accepted_sequence),
+            };
+        }
+        if (row.status === 'superseded'
+            && row.recovery_state === 'completed'
+            && typeof row.recovery_batch_id === 'string'
+            && typeof row.baseline_marker === 'string'
+            && typeof row.completed_at === 'string') {
+            return {
+                kind: 'completed-recovery',
+                recoveryBatchId: row.recovery_batch_id,
+                baselineMarker: row.baseline_marker,
+                completedAt: requireIsoTimestamp(row.completed_at, 'Outbox recovery completion time'),
+            };
+        }
+        return null;
+    }
+    listBlockedInvalidOutboxOperations(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const limit = Math.max(1, Math.min(100, Math.floor(input.limit ?? 100)));
+        const rows = this.db.prepare(`
+            SELECT tenant_id, workspace_id, client_id, operation_id, dispatch_class, domain, entity_id,
+                   mutation_kind, owns_task_metadata, owns_task_lifecycle, owns_task_assignee,
+                   CAST(base_entity_revision AS TEXT) AS base_entity_revision,
+                   CAST(base_lifecycle_revision AS TEXT) AS base_lifecycle_revision,
+                   payload_json, payload_fingerprint, status, attempt_count,
+                   initial_not_found_attempt_count,
+                   CAST(enqueue_sequence AS TEXT) AS enqueue_sequence,
+                   rebase_before_first_attempt, lease_owner, lease_expires_at
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND contract_version = ?
+              AND last_error_code = 'WORKSPACE_SYNC_OUTBOX_INVALID'
+            ORDER BY enqueue_sequence
+            LIMIT ?
+        `).all(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, limit);
+        return rows.map((row) => this.mapOutboxRow(row));
+    }
+    requeueBlockedInvalidOutboxOperation(input) {
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                last_error_code = 'WORKSPACE_SYNC_OUTBOX_CONTRACT_UPGRADE_RECOVERY',
+                last_error_message = 'Requeued after the current local contract accepted the persisted operation.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+              AND contract_version = ?
+              AND status = 'blocked' AND last_error_code = 'WORKSPACE_SYNC_OUTBOX_INVALID'
+        `).run(now, now, ...operationParams(input.identity), WORKSPACE_SYNC_CONTRACT_VERSION);
+        return Number(result.changes || 0) === 1;
+    }
+    requeueAcceptedV3DispatchOperation(input) {
+        const now = requireIsoTimestamp(input.now, 'Accepted replay recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?,
+                lease_owner = NULL, lease_expires_at = NULL,
+                accepted_replay_recovery_count = accepted_replay_recovery_count + 1,
+                last_error_code = 'WORKSPACE_SYNC_ACCEPTED_REPLAY_RECOVERY',
+                last_error_message = 'Requeued the exact operation identity after the coordinator proved upstream acceptance before local acknowledgement committed.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+              AND contract_version = ?
+              AND status = 'blocked'
+              AND accepted_replay_recovery_count < 1
+              AND recovery_batch_id IS NULL
+        `).run(now, now, ...operationParams(input.identity), WORKSPACE_SYNC_CONTRACT_VERSION);
+        return Number(result.changes || 0) === 1;
+    }
+    requeueWorkstreamInitiativeDependencyAcknowledgements(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Workstream dependency recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?,
+                lease_owner = NULL, lease_expires_at = NULL,
+                accepted_replay_recovery_count = accepted_replay_recovery_count + 1,
+                last_error_code = 'WORKSPACE_SYNC_WORKSTREAM_INITIATIVE_DEPENDENCY_RECOVERY',
+                last_error_message = 'Requeued the accepted workstream once after authoritative parent dependency support became available.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ?
+              AND contract_version = ?
+              AND status = 'blocked'
+              AND domain = 'workstream' AND mutation_kind = 'metadata-update'
+              AND last_error_code = 'INITIATIVE_NOT_FOUND'
+              AND workstream_metadata_revision_rebase_count = 1
+              AND accepted_replay_recovery_count = 1
+              AND recovery_batch_id IS NULL
+        `).run(now, now, tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION);
+        return Number(result.changes || 0);
+    }
+    readWorkflowAssignmentDependencyState(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const executionId = requireText(input.executionId, 'Workflow execution id');
+        const beforeEnqueueSequence = normalizeSequence(input.beforeEnqueueSequence);
+        const rows = this.db.prepare(`
+            SELECT status, payload_json
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ?
+              AND domain = 'task' AND mutation_kind = 'set-status'
+              AND status IN ('pending', 'in_flight', 'blocked')
+              AND enqueue_sequence < ?
+            ORDER BY CASE status WHEN 'blocked' THEN 0 ELSE 1 END, enqueue_sequence
+        `).all(tenantId, workspaceId, beforeEnqueueSequence);
+        for (const row of rows) {
+            try {
+                const payload = JSON.parse(String(row.payload_json || ''));
+                if (String(payload.workflowAssignment?.execution?.id || '') !== executionId)
+                    continue;
+                return row.status === 'blocked' ? 'blocked' : 'pending';
+            }
+            catch {
+                // Invalid payloads are handled by their owning outbox handler.
+            }
+        }
+        return null;
+    }
+    getActiveEntityBusyError(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const target = {
+            domain: requireText(input.target.domain, 'Target domain'),
+            entityId: requireText(input.target.entityId, 'Target entity id'),
+        };
+        const mutationKind = String(input.mutationKind || '').trim();
+        const now = requireIsoTimestamp(input.now, 'Current time');
+        const active = this.db.prepare(`
+            SELECT outbox.operation_id, outbox.domain, outbox.entity_id, outbox.mutation_kind,
+                   outbox.status, outbox.attempt_count, outbox.next_attempt_at,
+                   outbox.lease_expires_at, outbox.last_error_code,
+                   outbox.created_at, outbox.updated_at
+            FROM workspace_sync_outbox AS outbox
+            WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+              AND outbox.status IN ('pending', 'in_flight', 'blocked')
+              AND (? = '' OR outbox.mutation_kind = ?)
+              AND (
+                (outbox.domain = ? AND outbox.entity_id = ?)
+                OR EXISTS (
+                    SELECT 1 FROM workspace_sync_outbox_targets AS persisted_target
+                    WHERE persisted_target.tenant_id = outbox.tenant_id
+                      AND persisted_target.workspace_id = outbox.workspace_id
+                      AND persisted_target.client_id = outbox.client_id
+                      AND persisted_target.operation_id = outbox.operation_id
+                      AND persisted_target.domain = ? AND persisted_target.entity_id = ?
+                )
+              )
+            ORDER BY CASE outbox.status
+                       WHEN 'blocked' THEN 0
+                       WHEN 'in_flight' THEN 1
+                       ELSE 2
+                     END,
+                     outbox.enqueue_sequence
+        `).all(tenantId, workspaceId, mutationKind, mutationKind, target.domain, target.entityId, target.domain, target.entityId);
+        return active.length > 0
+            ? workspaceSyncEntityBusyError({ target, active, now })
+            : null;
+    }
+    hasActiveOutboxSuccessor(identity) {
+        const ids = operationParams(identity);
+        const current = this.db.prepare(`
+            SELECT domain, entity_id, enqueue_sequence
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+        `).get(...ids);
+        if (!current)
+            throw new Error('Workspace sync outbox operation does not exist.');
+        const successor = this.db.prepare(`
+            SELECT 1 AS active
+            FROM workspace_sync_outbox AS successor
+            WHERE successor.tenant_id = ? AND successor.workspace_id = ?
+              AND successor.status IN ('pending', 'in_flight', 'blocked')
+              AND successor.enqueue_sequence > ?
+              AND EXISTS (
+                SELECT 1
+                FROM workspace_sync_outbox_targets AS current_target
+                INNER JOIN workspace_sync_outbox_targets AS successor_target
+                  ON successor_target.tenant_id = current_target.tenant_id
+                 AND successor_target.workspace_id = current_target.workspace_id
+                 AND successor_target.domain = current_target.domain
+                 AND successor_target.entity_id = current_target.entity_id
+                WHERE current_target.tenant_id = ? AND current_target.workspace_id = ?
+                  AND current_target.client_id = ? AND current_target.operation_id = ?
+                  AND successor_target.client_id = successor.client_id
+                  AND successor_target.operation_id = successor.operation_id
+              )
+            LIMIT 1
+        `).get(ids[0], ids[1], normalizeSequence(current.enqueue_sequence ?? 0), ...ids);
+        return Number(successor?.active || 0) === 1;
+    }
+    listActiveOutboxSuccessors(identity) {
+        const ids = operationParams(identity);
+        const current = this.db.prepare(`
+            SELECT domain, entity_id, enqueue_sequence
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+        `).get(...ids);
+        if (!current)
+            throw new Error('Workspace sync outbox operation does not exist.');
+        const rows = this.db.prepare(`
+            SELECT tenant_id, workspace_id, client_id, operation_id, dispatch_class, domain, entity_id,
+                   mutation_kind, owns_task_metadata, owns_task_lifecycle, owns_task_assignee,
+                   CAST(base_entity_revision AS TEXT) AS base_entity_revision,
+                   CAST(base_lifecycle_revision AS TEXT) AS base_lifecycle_revision,
+                   payload_json, payload_fingerprint, status, attempt_count,
+                   initial_not_found_attempt_count,
+                   CAST(enqueue_sequence AS TEXT) AS enqueue_sequence,
+                   rebase_before_first_attempt, lease_owner, lease_expires_at
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ?
+              AND status IN ('pending', 'in_flight', 'blocked')
+              AND enqueue_sequence > ?
+              AND EXISTS (
+                SELECT 1
+                FROM workspace_sync_outbox_targets AS current_target
+                INNER JOIN workspace_sync_outbox_targets AS successor_target
+                  ON successor_target.tenant_id = current_target.tenant_id
+                 AND successor_target.workspace_id = current_target.workspace_id
+                 AND successor_target.domain = current_target.domain
+                 AND successor_target.entity_id = current_target.entity_id
+                WHERE current_target.tenant_id = ? AND current_target.workspace_id = ?
+                  AND current_target.client_id = ? AND current_target.operation_id = ?
+                  AND successor_target.client_id = workspace_sync_outbox.client_id
+                  AND successor_target.operation_id = workspace_sync_outbox.operation_id
+              )
+            ORDER BY enqueue_sequence
+        `).all(ids[0], ids[1], normalizeSequence(current.enqueue_sequence ?? 0), ...ids);
+        return rows.map((row) => this.mapOutboxRow(row));
+    }
+    supersedeBlockedOutboxChain(input) {
+        const ids = operationParams(input.identity);
+        const recoveryBatchId = requireText(input.recoveryBatchId, 'Recovery batch id');
+        const now = requireIsoTimestamp(input.now, 'Supersession time');
+        const matchesRecoveryBatch = (recovery) => Boolean(recovery
+            && recovery.state === 'awaiting_baseline'
+            && (input.appendToExistingRecovery
+                || (recovery.root_client_id === ids[2] && recovery.root_operation_id === ids[3])));
+        const listRecoveryOperationIds = () => {
+            const rows = this.db.prepare(`
+                SELECT operation_id
+                FROM workspace_sync_outbox
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                  AND status = 'superseded'
+                ORDER BY enqueue_sequence, created_at, operation_id
+            `).all(ids[0], ids[1], recoveryBatchId);
+            return rows.map((row) => requireText(row.operation_id, 'Operation id'));
+        };
+        return this.db.transaction(() => {
+            const root = this.db.prepare(`
+                SELECT status, recovery_batch_id,
+                       CAST(enqueue_sequence AS TEXT) AS enqueue_sequence
+                FROM workspace_sync_outbox
+                WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                ${this.db.provider === 'postgres' ? 'FOR UPDATE' : ''}
+            `).get(...ids);
+            if (!root)
+                throw new Error('Workspace sync outbox operation does not exist.');
+            if (root.status === 'superseded') {
+                if (root.recovery_batch_id !== recoveryBatchId) {
+                    throw new Error('Workspace sync outbox operation belongs to a different recovery batch.');
+                }
+                const recovery = this.db.prepare(`
+                    SELECT root_client_id, root_operation_id, state
+                    FROM workspace_sync_outbox_recoveries
+                    WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                `).get(ids[0], ids[1], recoveryBatchId);
+                if (!matchesRecoveryBatch(recovery)) {
+                    throw new Error('Workspace sync outbox recovery batch root does not match.');
+                }
+                return {
+                    recoveryBatchId,
+                    operationIds: listRecoveryOperationIds(),
+                };
+            }
+            if (root.status !== 'blocked') {
+                throw new Error('Only a blocked workspace sync operation can start recovery.');
+            }
+            const rootKey = `${ids[2]}\0${ids[3]}`;
+            const affectedOperationKeys = new Set([rootKey]);
+            const affectedTargets = new Set();
+            const lockedTargets = new Set();
+            const lockTarget = this.db.prepare(`
+                INSERT INTO workspace_sync_domain_locks (tenant_id, workspace_id, domain, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT (tenant_id, workspace_id, domain) DO UPDATE SET updated_at = excluded.updated_at
+            `);
+            let candidates = [];
+            let targetsByOperation = new Map();
+            while (true) {
+                const targets = this.db.prepare(`
+                    SELECT client_id, operation_id, domain, entity_id
+                    FROM workspace_sync_outbox_targets
+                    WHERE tenant_id = ? AND workspace_id = ?
+                `).all(ids[0], ids[1]);
+                targetsByOperation = new Map();
+                for (const target of targets) {
+                    const operationKey = `${requireText(target.client_id, 'Client id')}\0${requireText(target.operation_id, 'Operation id')}`;
+                    const operationTargets = targetsByOperation.get(operationKey) || new Set();
+                    operationTargets.add(`${requireText(target.domain, 'Domain')}\0${requireText(target.entity_id, 'Entity id')}`);
+                    targetsByOperation.set(operationKey, operationTargets);
+                }
+                for (const target of targetsByOperation.get(rootKey) || [])
+                    affectedTargets.add(target);
+                if (affectedTargets.size === 0) {
+                    throw new Error('Blocked workspace sync recovery root has no durable targets.');
+                }
+                const unlockedTargets = [...affectedTargets]
+                    .filter((target) => !lockedTargets.has(target))
+                    .sort(compareCodeUnits);
+                for (const target of unlockedTargets) {
+                    const separator = target.indexOf('\0');
+                    const domain = target.slice(0, separator);
+                    const entityId = target.slice(separator + 1);
+                    lockTarget.run(ids[0], ids[1], `local-outbox:${domain}:${entityId}`, now);
+                    lockedTargets.add(target);
+                }
+                candidates = this.db.prepare(`
+                    SELECT client_id, operation_id, dispatch_class, domain, entity_id, mutation_kind,
+                           payload_json, payload_fingerprint, status, lease_expires_at,
+                           last_error_code, last_error_message,
+                           CAST(enqueue_sequence AS TEXT) AS enqueue_sequence,
+                           created_at
+                    FROM workspace_sync_outbox
+                    WHERE tenant_id = ? AND workspace_id = ?
+                      AND status IN ('pending', 'in_flight', 'blocked')
+                      AND enqueue_sequence >= ?
+                    ORDER BY enqueue_sequence, created_at, operation_id
+                    ${this.db.provider === 'postgres' ? 'FOR UPDATE' : ''}
+                `).all(ids[0], ids[1], normalizeSequence(root.enqueue_sequence ?? 0));
+                let changed = true;
+                while (changed) {
+                    changed = false;
+                    for (const candidate of candidates) {
+                        const candidateKey = `${requireText(candidate.client_id, 'Client id')}\0${requireText(candidate.operation_id, 'Operation id')}`;
+                        if (affectedOperationKeys.has(candidateKey))
+                            continue;
+                        const candidateTargets = targetsByOperation.get(candidateKey) || new Set();
+                        if (![...candidateTargets].some((target) => affectedTargets.has(target)))
+                            continue;
+                        affectedOperationKeys.add(candidateKey);
+                        for (const target of candidateTargets)
+                            affectedTargets.add(target);
+                        changed = true;
+                    }
+                }
+                if ([...affectedTargets].every((target) => lockedTargets.has(target)))
+                    break;
+            }
+            const selected = candidates.filter((candidate) => affectedOperationKeys.has(`${requireText(candidate.client_id, 'Client id')}\0${requireText(candidate.operation_id, 'Operation id')}`));
+            if (!selected.some((candidate) => (candidate.client_id === ids[2] && candidate.operation_id === ids[3]))) {
+                throw new Error('Blocked workspace sync recovery root was not selected.');
+            }
+            const activeLease = selected.find((candidate) => (candidate.status === 'in_flight'
+                && Date.parse(String(candidate.lease_expires_at || '')) > Date.parse(now)));
+            if (activeLease) {
+                throw new Error('A workspace sync operation in the recovery chain still owns an active lease.');
+            }
+            if (input.replayPolicy === 'task-root') {
+                for (const candidate of selected) {
+                    const supportedTaskRoot = candidate.domain === 'task'
+                        && TASK_ROOT_SUCCESSOR_MUTATIONS.has(String(candidate.mutation_kind || ''));
+                    const supportedTaskComment = candidate.domain === 'task-comments'
+                        && candidate.mutation_kind === 'append';
+                    const supportedTaskCreate = candidate.domain === 'task'
+                        && candidate.mutation_kind === 'create'
+                        && TASK_CREATE_RECOVERY_ERROR_CODES.has(String(candidate.last_error_code || ''));
+                    const supportedTaskAttachmentLinks = candidate.domain === 'task-attachment-links'
+                        && candidate.mutation_kind === 'replace';
+                    const supportedEntityEventAdoption = candidate.dispatch_class === 'legacy-adoption'
+                        && candidate.domain === 'entity-event'
+                        && candidate.mutation_kind === 'adopt-legacy-batch';
+                    if (!supportedTaskRoot && !supportedTaskComment
+                        && !supportedTaskCreate && !supportedTaskAttachmentLinks
+                        && !supportedEntityEventAdoption) {
+                        throw new Error('Workspace sync recovery replay currently supports task-root, task-comment append, '
+                            + 'task-create attachment-link, and legacy entity-event adoption intents only.');
+                    }
+                    if (supportedTaskCreate)
+                        this.readTaskCreateRecoveryIntent(candidate);
+                    else if (supportedTaskAttachmentLinks) {
+                        this.readTaskAttachmentLinksRecoveryIntent(candidate);
+                    }
+                    else if (supportedTaskComment
+                        && (candidate.client_id !== ids[2] || candidate.operation_id !== ids[3])) {
+                        // A successor comment still owns the active operation that will be
+                        // superseded with this chain. Validate its frozen intent now, then
+                        // require authoritative event ownership when the replay is prepared.
+                        this.readTaskCommentAppendRecoveryIntent(ids[1], candidate);
+                    }
+                    else {
+                        this.prepareRecoveryPayload(ids[0], ids[1], candidate);
+                    }
+                }
+            }
+            this.db.prepare(`
+                INSERT INTO workspace_sync_outbox_recoveries (
+                    tenant_id, workspace_id, recovery_batch_id,
+                    root_client_id, root_operation_id, state,
+                    created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, 'awaiting_baseline', ?, ?)
+                ON CONFLICT (tenant_id, workspace_id, recovery_batch_id) DO NOTHING
+            `).run(ids[0], ids[1], recoveryBatchId, ids[2], ids[3], now, now);
+            const recovery = this.db.prepare(`
+                SELECT root_client_id, root_operation_id, state
+                FROM workspace_sync_outbox_recoveries
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                ${this.db.provider === 'postgres' ? 'FOR UPDATE' : ''}
+            `).get(ids[0], ids[1], recoveryBatchId);
+            if (!matchesRecoveryBatch(recovery)) {
+                throw new Error('Workspace sync recovery batch identity is already in use.');
+            }
+            for (const candidate of selected) {
+                const clientId = requireText(candidate.client_id, 'Client id');
+                const operationId = requireText(candidate.operation_id, 'Operation id');
+                const result = this.db.prepare(`
+                    UPDATE workspace_sync_outbox
+                    SET status = 'superseded', recovery_batch_id = ?, superseded_at = ?,
+                        lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                      AND (
+                        status IN ('pending', 'blocked')
+                        OR (status = 'in_flight' AND lease_expires_at <= ?)
+                      )
+                `).run(recoveryBatchId, now, now, ids[0], ids[1], clientId, operationId, now);
+                if (Number(result.changes || 0) !== 1) {
+                    throw new Error('Workspace sync recovery chain changed while it was being superseded.');
+                }
+            }
+            return {
+                recoveryBatchId,
+                operationIds: listRecoveryOperationIds(),
+            };
+        })();
+    }
+    recordOutboxRecoveryBaseline(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const recoveryBatchId = requireText(input.recoveryBatchId, 'Recovery batch id');
+        const baselineMarker = requireText(input.baselineMarker, 'Recovery baseline marker');
+        const now = requireIsoTimestamp(input.now, 'Recovery baseline time');
+        this.db.transaction(() => {
+            const recovery = this.db.prepare(`
+                SELECT state, baseline_marker
+                FROM workspace_sync_outbox_recoveries
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                ${this.db.provider === 'postgres' ? 'FOR UPDATE' : ''}
+            `).get(tenantId, workspaceId, recoveryBatchId);
+            if (!recovery)
+                throw new Error('Workspace sync recovery batch does not exist.');
+            if (recovery.state === 'baseline_ready' || recovery.state === 'replay_queued') {
+                if (recovery.baseline_marker !== baselineMarker) {
+                    throw new Error('Workspace sync recovery baseline marker does not match.');
+                }
+                return;
+            }
+            if (recovery.state !== 'awaiting_baseline') {
+                throw new Error('Workspace sync recovery is not waiting for an authoritative baseline.');
+            }
+            const result = this.db.prepare(`
+                UPDATE workspace_sync_outbox_recoveries
+                SET state = 'baseline_ready', baseline_marker = ?,
+                    baseline_applied_at = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                  AND state = 'awaiting_baseline'
+            `).run(baselineMarker, now, now, tenantId, workspaceId, recoveryBatchId);
+            if (Number(result.changes || 0) !== 1) {
+                throw new Error('Workspace sync recovery phase changed while recording its baseline.');
+            }
+        })();
+    }
+    listOutboxRecoveryTargets(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const recoveryBatchId = requireText(input.recoveryBatchId, 'Recovery batch id');
+        const rows = this.db.prepare(`
+            SELECT DISTINCT target.domain, target.entity_id
+            FROM workspace_sync_outbox AS source
+            INNER JOIN workspace_sync_outbox_targets AS target
+              ON target.tenant_id = source.tenant_id
+             AND target.workspace_id = source.workspace_id
+             AND target.client_id = source.client_id
+             AND target.operation_id = source.operation_id
+            WHERE source.tenant_id = ? AND source.workspace_id = ?
+              AND source.recovery_batch_id = ?
+              AND source.status = 'superseded'
+              AND source.replay_of_operation_id IS NULL
+            ORDER BY target.domain, target.entity_id
+        `).all(tenantId, workspaceId, recoveryBatchId);
+        if (rows.length === 0)
+            throw new Error('Workspace sync recovery snapshot has no targets.');
+        return rows.map((row) => ({
+            domain: requireText(row.domain, 'Recovery target domain'),
+            entityId: requireText(row.entity_id, 'Recovery target entity id'),
+        }));
+    }
+    prepareTaskRootOutboxRecoveryReplay(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const recoveryBatchId = requireText(input.recoveryBatchId, 'Recovery batch id');
+        const now = requireIsoTimestamp(input.now, 'Recovery replay time');
+        return this.db.transaction(() => {
+            const recovery = this.db.prepare(`
+                SELECT state, baseline_marker
+                FROM workspace_sync_outbox_recoveries
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                ${this.db.provider === 'postgres' ? 'FOR UPDATE' : ''}
+            `).get(tenantId, workspaceId, recoveryBatchId);
+            if (!recovery)
+                throw new Error('Workspace sync recovery batch does not exist.');
+            const listReplayOperationIds = () => {
+                const rows = this.db.prepare(`
+                    SELECT operation_id
+                    FROM workspace_sync_outbox
+                    WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                      AND replay_of_operation_id IS NOT NULL
+                    ORDER BY enqueue_sequence, created_at, operation_id
+                `).all(tenantId, workspaceId, recoveryBatchId);
+                return rows.map((row) => requireText(row.operation_id, 'Replay operation id'));
+            };
+            if (recovery.state === 'replay_queued') {
+                return { recoveryBatchId, operationIds: listReplayOperationIds() };
+            }
+            if (recovery.state !== 'baseline_ready') {
+                throw new Error('Workspace sync recovery requires an authoritative baseline before replay.');
+            }
+            const baselineMarker = requireText(recovery.baseline_marker, 'Workspace sync recovery baseline marker');
+            const recoverySources = this.db.prepare(`
+                SELECT client_id, operation_id, dispatch_class, domain, entity_id, mutation_kind,
+                       owns_task_metadata, owns_task_lifecycle, owns_task_assignee,
+                       payload_json, payload_fingerprint, last_error_code, last_error_message,
+                       EXISTS (
+                           SELECT 1
+                           FROM workspace_sync_outbox AS replay_candidate
+                           WHERE replay_candidate.tenant_id = workspace_sync_outbox.tenant_id
+                             AND replay_candidate.workspace_id = workspace_sync_outbox.workspace_id
+                             AND replay_candidate.recovery_batch_id = workspace_sync_outbox.recovery_batch_id
+                             AND replay_candidate.replay_of_client_id = workspace_sync_outbox.client_id
+                             AND replay_candidate.replay_of_operation_id = workspace_sync_outbox.operation_id
+                             AND replay_candidate.status = 'superseded'
+                             AND (
+                                 (
+                                     workspace_sync_outbox.mutation_kind = 'archive'
+                                     AND replay_candidate.last_error_code = 'TASK_LIFECYCLE_ALREADY_ARCHIVED'
+                                 )
+                                 OR (
+                                     workspace_sync_outbox.mutation_kind = 'unarchive'
+                                     AND replay_candidate.last_error_code = 'TASK_LIFECYCLE_NOT_ARCHIVED'
+                                 )
+                                 OR (
+                                     workspace_sync_outbox.mutation_kind = 'archive'
+                                     AND replay_candidate.last_error_code = 'TASK_LIFECYCLE_STATE_CONFLICT'
+                                     AND replay_candidate.last_error_message = 'Task is already archived.'
+                                 )
+                                 OR (
+                                     workspace_sync_outbox.mutation_kind = 'unarchive'
+                                     AND replay_candidate.last_error_code = 'TASK_LIFECYCLE_STATE_CONFLICT'
+                                     AND replay_candidate.last_error_message = 'Task is not archived.'
+                                 )
+                             )
+                       ) AS baseline_satisfaction_candidate,
+                       CAST(enqueue_sequence AS TEXT) AS enqueue_sequence
+                FROM workspace_sync_outbox
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                  AND status = 'superseded' AND replay_of_operation_id IS NULL
+                ORDER BY enqueue_sequence, created_at, operation_id
+            `).all(tenantId, workspaceId, recoveryBatchId);
+            for (const source of recoverySources) {
+                if (source.domain === 'task-comments' && source.mutation_kind === 'append') {
+                    this.assertTaskCommentAppendRecoveryEventOwned(tenantId, workspaceId, source);
+                }
+                else if (source.domain === 'task' && source.mutation_kind === 'create') {
+                    this.readTaskCreateRecoveryIntent(source);
+                }
+                else if (source.domain === 'task-attachment-links'
+                    && source.mutation_kind === 'replace') {
+                    this.readTaskAttachmentLinksRecoveryIntent(source);
+                }
+                else if (source.dispatch_class === 'legacy-adoption'
+                    && source.domain === 'entity-event'
+                    && source.mutation_kind === 'adopt-legacy-batch') {
+                    this.readEntityEventLegacyAdoptionRecoveryIntent(workspaceId, source);
+                }
+            }
+            const latestAttachmentSourceByEntity = new Map();
+            for (const source of recoverySources) {
+                if (source.domain === 'task-attachment-links' && source.mutation_kind === 'replace') {
+                    latestAttachmentSourceByEntity.set(requireText(source.entity_id, 'Source entity id'), source);
+                }
+            }
+            const sources = recoverySources.filter((source) => {
+                if (source.domain === 'task-comments' && source.mutation_kind === 'append') {
+                    return !this.isTaskCommentAppendRecoveryIntentSatisfied(tenantId, workspaceId, source);
+                }
+                if (source.domain === 'task' && source.mutation_kind === 'create') {
+                    this.assertTaskCreateRecoveryIntentSatisfied(tenantId, workspaceId, source);
+                    return false;
+                }
+                if (source.domain === 'task-attachment-links'
+                    && source.mutation_kind === 'replace') {
+                    if (latestAttachmentSourceByEntity.get(requireText(source.entity_id, 'Source entity id')) !== source) {
+                        return false;
+                    }
+                    return !this.isTaskAttachmentLinksRecoveryIntentSatisfied(tenantId, workspaceId, source);
+                }
+                if (source.dispatch_class === 'legacy-adoption'
+                    && source.domain === 'entity-event'
+                    && source.mutation_kind === 'adopt-legacy-batch') {
+                    // Legacy adoption migrates immutable historical activity; it is
+                    // not a user-authored mutation that can be rebased. A targeted
+                    // authoritative baseline proves that every event identity exists
+                    // in cloud and installs the canonical cloud body locally. Trying
+                    // to replay the older frozen body can only re-create the same
+                    // identity/revision conflict forever, so the baseline itself
+                    // satisfies this migration intent.
+                    return false;
+                }
+                if (Number(source.baseline_satisfaction_candidate || 0) !== 1) {
+                    return true;
+                }
+                return !this.isTaskLifecycleRecoveryIntentSatisfied(tenantId, workspaceId, source);
+            });
+            if (sources.length === 0) {
+                const completed = this.db.prepare(`
+                    UPDATE workspace_sync_outbox_recoveries
+                    SET state = 'completed', completed_at = ?, updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                      AND state = 'baseline_ready'
+                `).run(now, now, tenantId, workspaceId, recoveryBatchId);
+                if (Number(completed.changes || 0) !== 1) {
+                    throw new Error('Workspace sync recovery phase changed while recording baseline satisfaction.');
+                }
+                return { recoveryBatchId, operationIds: [] };
+            }
+            const newerActive = this.db.prepare(`
+                SELECT active.operation_id
+                FROM workspace_sync_outbox AS active
+                WHERE active.tenant_id = ? AND active.workspace_id = ?
+                  AND active.status IN ('pending', 'in_flight', 'blocked')
+                  AND COALESCE(active.recovery_batch_id, '') <> ?
+                  AND EXISTS (
+                    SELECT 1
+                    FROM workspace_sync_outbox_targets AS recovered_target
+                    INNER JOIN workspace_sync_outbox AS recovered
+                      ON recovered.tenant_id = recovered_target.tenant_id
+                     AND recovered.workspace_id = recovered_target.workspace_id
+                     AND recovered.client_id = recovered_target.client_id
+                     AND recovered.operation_id = recovered_target.operation_id
+                    INNER JOIN workspace_sync_outbox_targets AS active_target
+                      ON active_target.tenant_id = recovered_target.tenant_id
+                     AND active_target.workspace_id = recovered_target.workspace_id
+                     AND active_target.domain = recovered_target.domain
+                     AND active_target.entity_id = recovered_target.entity_id
+                    WHERE recovered.tenant_id = active.tenant_id
+                      AND recovered.workspace_id = active.workspace_id
+                      AND recovered.recovery_batch_id = ?
+                      AND recovered.status = 'superseded'
+                      AND active_target.client_id = active.client_id
+                      AND active_target.operation_id = active.operation_id
+                )
+                LIMIT 1
+            `).get(tenantId, workspaceId, recoveryBatchId, recoveryBatchId);
+            if (newerActive) {
+                throw new Error('Workspace sync recovery has newer active intent that requires semantic reconciliation.');
+            }
+            const replayPayloads = new Map();
+            for (const source of sources) {
+                const supportedTaskRoot = source.domain === 'task'
+                    && TASK_ROOT_SUCCESSOR_MUTATIONS.has(String(source.mutation_kind || ''));
+                const supportedTaskComment = source.domain === 'task-comments'
+                    && source.mutation_kind === 'append';
+                const supportedTaskAttachmentLinks = source.domain === 'task-attachment-links'
+                    && source.mutation_kind === 'replace';
+                const supportedEntityEventAdoption = source.dispatch_class === 'legacy-adoption'
+                    && source.domain === 'entity-event'
+                    && source.mutation_kind === 'adopt-legacy-batch';
+                if (!supportedTaskRoot && !supportedTaskComment && !supportedTaskAttachmentLinks
+                    && !supportedEntityEventAdoption) {
+                    throw new Error('Workspace sync recovery replay currently supports task-root, task-comment append, '
+                        + 'task attachment-link, and legacy entity-event adoption intents only.');
+                }
+                replayPayloads.set(`${requireText(source.client_id, 'Source client id')}\0${requireText(source.operation_id, 'Source operation id')}`, this.prepareRecoveryPayload(tenantId, workspaceId, source));
+            }
+            for (const source of sources) {
+                const sourceClientId = requireText(source.client_id, 'Source client id');
+                const sourceOperationId = requireText(source.operation_id, 'Source operation id');
+                const operationId = source.dispatch_class === 'legacy-adoption'
+                    && source.domain === 'entity-event'
+                    && source.mutation_kind === 'adopt-legacy-batch'
+                    ? buildEntityEventAdoptionRecoveryReplayOperationId(recoveryBatchId, baselineMarker, sourceClientId, sourceOperationId)
+                    : buildRecoveryReplayOperationId(recoveryBatchId, baselineMarker, sourceClientId, sourceOperationId);
+                const replayPayload = replayPayloads.get(`${sourceClientId}\0${sourceOperationId}`);
+                if (!replayPayload)
+                    throw new Error('Workspace sync recovery replay payload is missing.');
+                const sourceTargets = this.db.prepare(`
+                    SELECT domain, entity_id, mutation_kind,
+                           owns_task_metadata, owns_task_lifecycle, owns_task_assignee
+                    FROM workspace_sync_outbox_targets
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                    ORDER BY domain, entity_id
+                `).all(tenantId, workspaceId, sourceClientId, sourceOperationId);
+                const replayTargets = source.domain === 'task-comments'
+                    && source.mutation_kind === 'append'
+                    ? sourceTargets.filter((target) => (target.domain === 'task-comments'
+                        && target.entity_id === source.entity_id))
+                    : sourceTargets;
+                if (replayTargets.length === 0)
+                    throw new Error('Workspace sync recovery source has no targets.');
+                const targetRevisions = replayTargets.map((target) => ({
+                    target,
+                    revision: this.readEntityRevisionCoordinates({
+                        tenantId,
+                        workspaceId,
+                        domain: requireText(target.domain, 'Target domain'),
+                        entityId: requireText(target.entity_id, 'Target entity id'),
+                    }),
+                }));
+                const primary = targetRevisions.find(({ target }) => (target.domain === source.domain && target.entity_id === source.entity_id));
+                if (!primary)
+                    throw new Error('Workspace sync recovery source primary target is missing.');
+                const enqueueSequence = this.allocateOutboxEnqueueSequence(tenantId, workspaceId, now);
+                this.db.prepare(`
+                    INSERT INTO workspace_sync_outbox (
+                        tenant_id, workspace_id, operation_id, contract_version, client_id,
+                        dispatch_class, domain, entity_id, mutation_kind,
+                        owns_task_metadata, owns_task_lifecycle, owns_task_assignee,
+                        base_entity_revision, base_lifecycle_revision,
+                        payload_json, payload_fingerprint, status, attempt_count,
+                        initial_not_found_attempt_count, enqueue_sequence, rebase_before_first_attempt,
+                        next_attempt_at, recovery_batch_id,
+                        replay_of_client_id, replay_of_operation_id, created_at, updated_at
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0, 0, ?, 1,
+                        ?, ?, ?, ?, ?, ?)
+                    ON CONFLICT (tenant_id, workspace_id, client_id, operation_id) DO NOTHING
+                `).run(tenantId, workspaceId, operationId, WORKSPACE_SYNC_CONTRACT_VERSION, sourceClientId, requireOutboxDispatchClass(source.dispatch_class), requireText(source.domain, 'Source domain'), requireText(source.entity_id, 'Source entity id'), replayPayload.replayMutationKind, Number(source.owns_task_metadata) === 1 ? 1 : 0, Number(source.owns_task_lifecycle) === 1 ? 1 : 0, Number(source.owns_task_assignee) === 1 ? 1 : 0, primary.revision.entityRevision, primary.revision.lifecycleRevision, replayPayload.payloadJson, replayPayload.payloadFingerprint, enqueueSequence, now, recoveryBatchId, sourceClientId, sourceOperationId, now, now);
+                this.db.prepare(`
+                    UPDATE workspace_sync_outbox
+                    SET base_entity_revision = ?, base_lifecycle_revision = ?,
+                        payload_json = ?, payload_fingerprint = ?,
+                        status = 'pending', attempt_count = 0, initial_not_found_attempt_count = 0,
+                        rebase_before_first_attempt = 1, next_attempt_at = ?,
+                        lease_owner = NULL, lease_expires_at = NULL,
+                        authoritative_response_json = NULL, accepted_sequence = NULL,
+                        last_error_code = NULL, last_error_message = NULL,
+                        superseded_at = NULL, updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                      AND recovery_batch_id = ? AND replay_of_client_id = ? AND replay_of_operation_id = ?
+                      AND status = 'superseded'
+                `).run(primary.revision.entityRevision, primary.revision.lifecycleRevision, replayPayload.payloadJson, replayPayload.payloadFingerprint, now, now, tenantId, workspaceId, sourceClientId, operationId, recoveryBatchId, sourceClientId, sourceOperationId);
+                if (replayPayload.workflowDependencyCoalesced) {
+                    this.db.prepare(`
+                        UPDATE workspace_sync_outbox
+                        SET last_error_code = 'WORKSPACE_SYNC_WORKFLOW_DEPENDENCY_COALESCED',
+                            last_error_message = 'Replayed after an earlier accepted operation satisfied the exact workflow activation dependency.',
+                            updated_at = ?
+                        WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                    `).run(now, tenantId, workspaceId, sourceClientId, operationId);
+                }
+                const replayRow = this.db.prepare(`
+                    SELECT domain, entity_id, mutation_kind, payload_fingerprint,
+                           recovery_batch_id, replay_of_client_id, replay_of_operation_id
+                    FROM workspace_sync_outbox
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                `).get(tenantId, workspaceId, sourceClientId, operationId);
+                if (!replayRow
+                    || replayRow.domain !== source.domain
+                    || replayRow.entity_id !== source.entity_id
+                    || replayRow.mutation_kind !== replayPayload.replayMutationKind
+                    || replayRow.payload_fingerprint !== replayPayload.payloadFingerprint
+                    || replayRow.recovery_batch_id !== recoveryBatchId
+                    || replayRow.replay_of_client_id !== sourceClientId
+                    || replayRow.replay_of_operation_id !== sourceOperationId) {
+                    throw new WorkspaceSyncIdempotencyConflictError();
+                }
+                for (const { target, revision } of targetRevisions) {
+                    this.db.prepare(`
+                        INSERT INTO workspace_sync_outbox_targets (
+                            tenant_id, workspace_id, client_id, operation_id,
+                            domain, entity_id, mutation_kind,
+                            base_entity_revision, base_lifecycle_revision,
+                            owns_task_metadata, owns_task_lifecycle, owns_task_assignee, created_at
+                        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                        ON CONFLICT (tenant_id, workspace_id, client_id, operation_id, domain, entity_id)
+                        DO NOTHING
+                    `).run(tenantId, workspaceId, sourceClientId, operationId, requireText(target.domain, 'Target domain'), requireText(target.entity_id, 'Target entity id'), target.domain === source.domain && target.entity_id === source.entity_id
+                        ? replayPayload.replayMutationKind
+                        : requireText(target.mutation_kind, 'Target mutation kind'), revision.entityRevision, revision.lifecycleRevision, Number(target.owns_task_metadata) === 1 ? 1 : 0, Number(target.owns_task_lifecycle) === 1 ? 1 : 0, Number(target.owns_task_assignee) === 1 ? 1 : 0, now);
+                    this.db.prepare(`
+                        UPDATE workspace_sync_outbox_targets
+                        SET base_entity_revision = ?, base_lifecycle_revision = ?
+                        WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                          AND domain = ? AND entity_id = ?
+                    `).run(revision.entityRevision, revision.lifecycleRevision, tenantId, workspaceId, sourceClientId, operationId, requireText(target.domain, 'Target domain'), requireText(target.entity_id, 'Target entity id'));
+                }
+            }
+            const updated = this.db.prepare(`
+                UPDATE workspace_sync_outbox_recoveries
+                SET state = 'replay_queued', replay_queued_at = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                  AND state = 'baseline_ready'
+            `).run(now, now, tenantId, workspaceId, recoveryBatchId);
+            if (Number(updated.changes || 0) !== 1) {
+                throw new Error('Workspace sync recovery phase changed while preparing replay.');
+            }
+            return { recoveryBatchId, operationIds: listReplayOperationIds() };
+        })();
+    }
+    readOpenOutboxRecovery(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const row = this.db.prepare(`
+            SELECT recovery_batch_id, root_client_id, root_operation_id, state,
+                   baseline_marker, created_at, updated_at, completed_at
+            FROM workspace_sync_outbox_recoveries
+            WHERE tenant_id = ? AND workspace_id = ? AND state <> 'completed'
+            ORDER BY created_at, recovery_batch_id
+            LIMIT 1
+        `).get(tenantId, workspaceId);
+        return row ? this.mapOutboxRecovery(tenantId, workspaceId, row) : null;
+    }
+    readOutboxRecovery(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const recoveryBatchId = requireText(input.recoveryBatchId, 'Recovery batch id');
+        const row = this.db.prepare(`
+            SELECT recovery_batch_id, root_client_id, root_operation_id, state,
+                   baseline_marker, created_at, updated_at, completed_at
+            FROM workspace_sync_outbox_recoveries
+            WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+        `).get(tenantId, workspaceId, recoveryBatchId);
+        return row ? this.mapOutboxRecovery(tenantId, workspaceId, row) : null;
+    }
+    findOldestBlockedOutboxIdentity(input) {
+        return this.listBlockedOutboxIdentities(input)[0] || null;
+    }
+    listBlockedOutboxIdentities(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const rows = this.db.prepare(`
+            SELECT client_id, operation_id
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+            ORDER BY enqueue_sequence, created_at, operation_id
+        `).all(tenantId, workspaceId);
+        return rows.map((row) => ({
+            tenantId,
+            workspaceId,
+            clientId: requireText(row.client_id, 'Client id'),
+            operationId: requireText(row.operation_id, 'Operation id'),
+        }));
+    }
+    restartOutboxRecoveryAfterRebaseConflict(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const recoveryBatchId = requireText(input.recoveryBatchId, 'Recovery batch id');
+        const now = requireIsoTimestamp(input.now, 'Recovery restart time');
+        return this.db.transaction(() => {
+            const recovery = this.db.prepare(`
+                SELECT state
+                FROM workspace_sync_outbox_recoveries
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                ${this.db.provider === 'postgres' ? 'FOR UPDATE' : ''}
+            `).get(tenantId, workspaceId, recoveryBatchId);
+            if (!recovery || recovery.state !== 'replay_queued')
+                return false;
+            const counts = this.db.prepare(`
+                SELECT
+                    COUNT(*) AS total,
+                    SUM(CASE WHEN status = 'accepted' THEN 1 ELSE 0 END) AS accepted,
+                    SUM(CASE WHEN status = 'in_flight' THEN 1 ELSE 0 END) AS in_flight,
+                    SUM(CASE WHEN status = 'blocked' THEN 1 ELSE 0 END) AS blocked,
+                    SUM(CASE
+                        WHEN status = 'blocked' AND last_error_code IN (
+                            'WORKSPACE_SYNC_REVISION_CONFLICT',
+                            'WORKSPACE_SYNC_IDEMPOTENCY_CONFLICT'
+                        )
+                        THEN 1 ELSE 0 END
+                    ) AS rebase_conflicts
+                FROM workspace_sync_outbox
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                  AND replay_of_operation_id IS NOT NULL
+            `).get(tenantId, workspaceId, recoveryBatchId);
+            if (Number(counts.total || 0) === 0
+                || Number(counts.accepted || 0) !== 0
+                || Number(counts.in_flight || 0) !== 0) {
+                return false;
+            }
+            const lifecycleConflicts = this.db.prepare(`
+                SELECT source.entity_id, source.mutation_kind, source.payload_json,
+                       replay.last_error_code, replay.last_error_message
+                FROM workspace_sync_outbox AS replay
+                INNER JOIN workspace_sync_outbox AS source
+                  ON source.tenant_id = replay.tenant_id
+                 AND source.workspace_id = replay.workspace_id
+                 AND source.client_id = replay.replay_of_client_id
+                 AND source.operation_id = replay.replay_of_operation_id
+                WHERE replay.tenant_id = ? AND replay.workspace_id = ?
+                  AND replay.recovery_batch_id = ?
+                  AND replay.status = 'blocked'
+                  AND replay.last_error_code IN (
+                      'TASK_LIFECYCLE_ALREADY_ARCHIVED',
+                      'TASK_LIFECYCLE_NOT_ARCHIVED',
+                      'TASK_LIFECYCLE_STATE_CONFLICT'
+                  )
+            `).all(tenantId, workspaceId, recoveryBatchId);
+            const baselineSatisfied = lifecycleConflicts.filter((row) => (this.isTargetStateLifecycleConflict(row)
+                && this.isTaskLifecycleRecoveryIntentSatisfied(tenantId, workspaceId, row)));
+            if (Number(counts.rebase_conflicts || 0) === 0 && baselineSatisfied.length === 0) {
+                return false;
+            }
+            if (Number(counts.blocked || 0)
+                !== Number(counts.rebase_conflicts || 0) + baselineSatisfied.length) {
+                return false;
+            }
+            this.db.prepare(`
+                UPDATE workspace_sync_outbox
+                SET status = 'superseded',
+                    lease_owner = NULL, lease_expires_at = NULL,
+                    superseded_at = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                  AND replay_of_operation_id IS NOT NULL
+                  AND status IN ('pending', 'blocked')
+            `).run(now, now, tenantId, workspaceId, recoveryBatchId);
+            const restarted = this.db.prepare(`
+                UPDATE workspace_sync_outbox_recoveries
+                SET state = 'awaiting_baseline',
+                    baseline_marker = NULL, baseline_applied_at = NULL,
+                    replay_queued_at = NULL, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                  AND state = 'replay_queued'
+            `).run(now, tenantId, workspaceId, recoveryBatchId);
+            if (Number(restarted.changes || 0) !== 1) {
+                throw new Error('Workspace sync recovery phase changed while restarting authoritative repair.');
+            }
+            return true;
+        })();
+    }
+    completeOutboxRecoveryIfSettled(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery completion time');
+        return this.db.transaction(() => {
+            let recovery = this.readOpenOutboxRecovery({ tenantId, workspaceId });
+            let settledBaselineSatisfiedLegacyReplays = 0;
+            if (recovery?.state === 'replay_queued' && recovery.baselineMarker) {
+                const baselineSatisfiedLegacyReplays = this.db.prepare(`
+                    SELECT replay.client_id, replay.operation_id,
+                           source.dispatch_class, source.domain, source.entity_id,
+                           source.mutation_kind, source.payload_json, source.payload_fingerprint
+                    FROM workspace_sync_outbox AS replay
+                    INNER JOIN workspace_sync_outbox AS source
+                      ON source.tenant_id = replay.tenant_id
+                     AND source.workspace_id = replay.workspace_id
+                     AND source.client_id = replay.replay_of_client_id
+                     AND source.operation_id = replay.replay_of_operation_id
+                    WHERE replay.tenant_id = ? AND replay.workspace_id = ?
+                      AND replay.recovery_batch_id = ?
+                      AND replay.status = 'blocked'
+                      AND replay.dispatch_class = 'legacy-adoption'
+                      AND replay.domain = 'entity-event'
+                      AND replay.mutation_kind = 'adopt-legacy-batch'
+                      AND replay.last_error_code IN (
+                          'WORKSPACE_SYNC_REVISION_CONFLICT',
+                          'WORKSPACE_SYNC_IDEMPOTENCY_CONFLICT'
+                      )
+                      AND source.dispatch_class = 'legacy-adoption'
+                      AND source.domain = 'entity-event'
+                      AND source.mutation_kind = 'adopt-legacy-batch'
+                      AND source.recovery_batch_id = replay.recovery_batch_id
+                      AND source.status = 'superseded'
+                      AND source.replay_of_operation_id IS NULL
+                    ${this.db.provider === 'postgres' ? 'FOR UPDATE OF replay' : ''}
+                `).all(tenantId, workspaceId, recovery.recoveryBatchId);
+                for (const replay of baselineSatisfiedLegacyReplays) {
+                    // Older builds replayed immutable legacy adoption after applying
+                    // the authoritative baseline. Validate the frozen source before
+                    // settling that stranded replay; all mutable/user-authored intents
+                    // continue through the ordinary rebase path.
+                    if (!isLegacyEntityEventAdoptionIdentity({
+                        clientId: requireText(replay.client_id, 'Replay client id'),
+                        operationId: requireText(replay.operation_id, 'Replay operation id'),
+                    })) {
+                        throw new Error('Legacy entity-event adoption recovery replay identity is invalid.');
+                    }
+                    this.readEntityEventLegacyAdoptionRecoveryIntent(workspaceId, replay);
+                    const settled = this.db.prepare(`
+                        UPDATE workspace_sync_outbox
+                        SET status = 'superseded', superseded_at = ?, updated_at = ?,
+                            lease_owner = NULL, lease_expires_at = NULL
+                        WHERE tenant_id = ? AND workspace_id = ?
+                          AND client_id = ? AND operation_id = ?
+                          AND recovery_batch_id = ? AND status = 'blocked'
+                    `).run(now, now, tenantId, workspaceId, requireText(replay.client_id, 'Replay client id'), requireText(replay.operation_id, 'Replay operation id'), recovery.recoveryBatchId);
+                    if (Number(settled.changes || 0) !== 1) {
+                        throw new Error('Legacy entity-event adoption recovery replay changed while settling.');
+                    }
+                    settledBaselineSatisfiedLegacyReplays += 1;
+                }
+                if (baselineSatisfiedLegacyReplays.length > 0) {
+                    recovery = this.readOpenOutboxRecovery({ tenantId, workspaceId });
+                }
+            }
+            if (!recovery || recovery.state !== 'replay_queued'
+                || (recovery.replayTotal === 0 && settledBaselineSatisfiedLegacyReplays === 0)
+                || recovery.replayAccepted !== recovery.replayTotal) {
+                return recovery;
+            }
+            const updated = this.db.prepare(`
+                UPDATE workspace_sync_outbox_recoveries
+                SET state = 'completed', completed_at = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                  AND state = 'replay_queued'
+            `).run(now, now, tenantId, workspaceId, recovery.recoveryBatchId);
+            if (Number(updated.changes || 0) !== 1) {
+                throw new Error('Workspace sync recovery phase changed while recording completion.');
+            }
+            return this.readOutboxRecovery({ tenantId, workspaceId, recoveryBatchId: recovery.recoveryBatchId });
+        })();
+    }
+    mapOutboxRecovery(tenantId, workspaceId, row) {
+        const recoveryBatchId = requireText(row.recovery_batch_id, 'Recovery batch id');
+        const counts = this.db.prepare(`
+            SELECT status, COUNT(*) AS count
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+              AND replay_of_operation_id IS NOT NULL
+            GROUP BY status
+        `).all(tenantId, workspaceId, recoveryBatchId);
+        const byStatus = new Map(counts.map((entry) => [String(entry.status || ''), Number(entry.count || 0)]));
+        const replayPending = byStatus.get('pending') || 0;
+        const replayInFlight = byStatus.get('in_flight') || 0;
+        const replayBlocked = byStatus.get('blocked') || 0;
+        const replayAccepted = byStatus.get('accepted') || 0;
+        const replayTotal = replayPending + replayInFlight + replayBlocked + replayAccepted;
+        const state = String(row.state || '');
+        if (!['awaiting_baseline', 'baseline_ready', 'replay_queued', 'completed'].includes(state)) {
+            throw new Error('Workspace sync recovery state is invalid.');
+        }
+        return {
+            recoveryBatchId,
+            rootClientId: requireText(row.root_client_id, 'Recovery root client id'),
+            rootOperationId: requireText(row.root_operation_id, 'Recovery root operation id'),
+            state,
+            baselineMarker: typeof row.baseline_marker === 'string' ? row.baseline_marker : null,
+            replayTotal,
+            replayPending,
+            replayInFlight,
+            replayBlocked,
+            replayAccepted,
+            createdAt: requireIsoTimestamp(row.created_at, 'Recovery creation time'),
+            updatedAt: requireIsoTimestamp(row.updated_at, 'Recovery update time'),
+            completedAt: row.completed_at == null ? null : requireIsoTimestamp(row.completed_at, 'Recovery completion time'),
+        };
+    }
+    readOperationStateForUpdate(identity) {
+        const row = this.db.prepare(`
+            SELECT status, response_json, created_at
+            FROM workspace_sync_operation_results
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+            ${this.db.provider === 'postgres' ? 'FOR UPDATE' : ''}
+        `).get(...operationParams(identity));
+        if (!row)
+            return null;
+        if (row.status !== 'processing' && row.status !== 'committed') {
+            throw new Error(`Unsupported operation status: ${String(row.status || '')}`);
+        }
+        return {
+            status: row.status,
+            responseJson: typeof row.response_json === 'string' ? row.response_json : null,
+            createdAt: requireIsoTimestamp(row.created_at, 'Operation creation time'),
+        };
+    }
+    readCreateDependencyState(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const dependencies = Array.from(new Map(input.dependencies.map((dependency) => {
+            const domain = requireText(dependency.domain, 'Dependency domain');
+            const entityId = requireText(dependency.entityId, 'Dependency entity id');
+            return [`${domain}\0${entityId}`, { domain, entityId }];
+        })).values());
+        if (dependencies.length === 0)
+            return null;
+        const clauses = dependencies.map(() => '(domain = ? AND entity_id = ?)').join(' OR ');
+        const rows = this.db.prepare(`
+            SELECT status
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ?
+              AND contract_version = ? AND mutation_kind = 'create'
+              AND (${clauses})
+              AND status IN ('pending', 'in_flight', 'blocked')
+        `).all(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, ...dependencies.flatMap((dependency) => [dependency.domain, dependency.entityId]));
+        if (rows.some((row) => row.status === 'blocked'))
+            return 'blocked';
+        return rows.length > 0 ? 'pending' : null;
+    }
+    readTaskCreateDependencyState(input) {
+        return this.readCreateDependencyState({
+            tenantId: input.tenantId,
+            workspaceId: input.workspaceId,
+            dependencies: input.taskIds.map((entityId) => ({ domain: 'task', entityId })),
+        });
+    }
+    listActiveTaskRelationshipOperationIds(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const rows = this.db.prepare(`
+            SELECT DISTINCT entity_id
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ? AND contract_version = ?
+              AND domain = 'task-relationship' AND mutation_kind IN ('link', 'unlink')
+              AND status IN ('pending', 'in_flight', 'blocked')
+            ORDER BY entity_id ASC
+        `).all(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION);
+        return rows.map((row) => requireText(row.entity_id, 'Task relationship id'));
+    }
+    listAttachmentAssetIdsAwaitingContentPublication(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const rows = this.db.prepare(`
+            SELECT domain, payload_json
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ? AND contract_version = ?
+              AND (
+                (domain = 'task-attachment-links' AND mutation_kind = 'replace')
+                OR (domain = 'task' AND mutation_kind = 'create')
+              )
+              AND status IN ('pending', 'in_flight')
+              AND last_error_code = 'TASK_ATTACHMENT_ASSET_NOT_READY'
+            ORDER BY enqueue_sequence
+        `).all(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION);
+        const assetIds = new Set();
+        for (const row of rows) {
+            let payload;
+            try {
+                payload = JSON.parse(requireText(row.payload_json, 'Attachment-link payload'));
+            }
+            catch {
+                continue;
+            }
+            if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+                continue;
+            const links = String(row.domain || '') === 'task'
+                ? payload.attachmentLinks
+                : payload.links;
+            if (!Array.isArray(links))
+                continue;
+            for (const link of links) {
+                if (!link || typeof link !== 'object' || Array.isArray(link))
+                    continue;
+                const assetId = String(link.assetId || '').trim();
+                if (assetId)
+                    assetIds.add(assetId);
+            }
+        }
+        return Array.from(assetIds).sort((a, b) => a.localeCompare(b));
+    }
+    runTaskRelationshipCoexistenceTransaction(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Coexistence lock timestamp');
+        return this.db.transaction(() => {
+            this.db.prepare(`
+                INSERT INTO workspace_sync_domain_locks (tenant_id, workspace_id, domain, updated_at)
+                VALUES (?, ?, 'task-relationship', ?)
+                ON CONFLICT (tenant_id, workspace_id, domain) DO UPDATE SET updated_at = excluded.updated_at
+            `).run(tenantId, workspaceId, now);
+            return input.apply(this.listActiveTaskRelationshipOperationIds({ tenantId, workspaceId }));
+        })();
+    }
+    reserveOperation(input) {
+        const ids = operationParams(input.identity);
+        const requestFingerprint = requireText(input.requestFingerprint, 'Request fingerprint');
+        const now = requireIsoTimestamp(input.now, 'Reservation time');
+        const leaseExpiresAt = requireIsoTimestamp(input.leaseExpiresAt, 'Lease expiry');
+        if (leaseExpiresAt <= now)
+            throw new Error('Lease expiry must be after the reservation time.');
+        const leaseOwner = requireText(input.leaseOwner || randomUUID(), 'Lease owner');
+        return this.db.transaction(() => {
+            this.db.prepare(`
+                INSERT INTO workspace_sync_operation_results (
+                    tenant_id, workspace_id, client_id, operation_id, contract_version,
+                    request_fingerprint, status, lease_owner, lease_expires_at,
+                    created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, 'processing', ?, ?, ?, ?)
+                ON CONFLICT (tenant_id, workspace_id, client_id, operation_id) DO NOTHING
+            `).run(...ids, WORKSPACE_SYNC_CONTRACT_VERSION, requestFingerprint, leaseOwner, leaseExpiresAt, now, now);
+            const row = this.readOperationRow(ids);
+            if (!row)
+                throw new Error('Workspace sync operation reservation was not persisted.');
+            this.assertMatchingOperation(row, requestFingerprint);
+            if (row.status === 'committed') {
+                if (typeof row.response_json !== 'string')
+                    throw new Error('Committed operation is missing its response.');
+                return {
+                    state: 'committed',
+                    responseJson: row.response_json,
+                    acceptedSequence: row.accepted_sequence == null ? null : normalizeSequence(row.accepted_sequence),
+                };
+            }
+            if (row.lease_owner === leaseOwner)
+                return { state: 'owned', leaseOwner };
+            const existingExpiry = requireIsoTimestamp(row.lease_expires_at, 'Existing lease expiry');
+            if (existingExpiry > now)
+                return { state: 'in_progress', retryAt: existingExpiry };
+            const takeover = this.db.prepare(`
+                UPDATE workspace_sync_operation_results
+                SET lease_owner = ?, lease_expires_at = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                  AND status = 'processing' AND request_fingerprint = ?
+                  AND lease_expires_at <= ?
+            `).run(leaseOwner, leaseExpiresAt, now, ...ids, requestFingerprint, now);
+            if (Number(takeover.changes || 0) === 1)
+                return { state: 'owned', leaseOwner };
+            const current = this.readOperationRow(ids);
+            this.assertMatchingOperation(current, requestFingerprint);
+            return {
+                state: 'in_progress',
+                retryAt: requireIsoTimestamp(current?.lease_expires_at, 'Existing lease expiry'),
+            };
+        })();
+    }
+    // A retryable failure (dependency not ready, revision conflict, etc.) can
+    // be thrown after reserveOperation succeeds but before the operation
+    // commits. Without this, the abandoned reservation blocks every retry
+    // with WORKSPACE_SYNC_OPERATION_IN_PROGRESS until its lease naturally
+    // expires, even though nothing was committed. This never deletes the row,
+    // forces acceptance, or rewrites the operation identity; it only makes
+    // the exact same identity immediately eligible for reservation takeover.
+    releaseFailedOperationReservation(input) {
+        const ids = operationParams(input.identity);
+        const requestFingerprint = requireText(input.requestFingerprint, 'Request fingerprint');
+        const leaseOwner = requireText(input.leaseOwner, 'Lease owner');
+        const now = requireIsoTimestamp(input.now, 'Release time');
+        this.db.prepare(`
+            UPDATE workspace_sync_operation_results
+            SET lease_expires_at = ?, updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+              AND status = 'processing' AND request_fingerprint = ? AND lease_owner = ?
+        `).run(now, now, ...ids, requestFingerprint, leaseOwner);
+    }
+    commitReservedOperationResponse(input) {
+        const ids = operationParams(input.identity);
+        const requestFingerprint = requireText(input.requestFingerprint, 'Request fingerprint');
+        const leaseOwner = requireText(input.leaseOwner, 'Lease owner');
+        const now = requireIsoTimestamp(input.now, 'Commit time');
+        const responseJson = canonicalWorkspaceSyncJson(input.response);
+        try {
+            return this.db.transaction(() => {
+                const committed = this.db.prepare(`
+                    UPDATE workspace_sync_operation_results
+                    SET status = 'committed', response_json = ?, accepted_sequence = NULL,
+                        lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                      AND contract_version = ? AND status = 'processing'
+                      AND request_fingerprint = ? AND lease_owner = ?
+                `).run(responseJson, now, ...ids, WORKSPACE_SYNC_CONTRACT_VERSION, requestFingerprint, leaseOwner);
+                if (Number(committed.changes || 0) !== 1)
+                    throw new WorkspaceSyncLeaseLostError();
+                return { responseJson };
+            })();
+        }
+        catch (error) {
+            if (!(error instanceof WorkspaceSyncLeaseLostError)) {
+                this.releaseFailedOperationReservation({ identity: input.identity, requestFingerprint, leaseOwner, now });
+            }
+            throw error;
+        }
+    }
+    acceptReservedOperation(input) {
+        return this.acceptReservedOperationBatch({
+            identity: input.identity,
+            requestFingerprint: input.requestFingerprint,
+            leaseOwner: input.leaseOwner,
+            now: input.now,
+            entries: [{
+                    domain: input.domain,
+                    entityId: input.entityId,
+                    mutationKind: input.mutationKind,
+                    revisionKind: input.revisionKind,
+                    contentSha256: input.contentSha256,
+                    sizeBytes: input.sizeBytes,
+                    baseEntityRevision: input.baseEntityRevision,
+                    baseLifecycleRevision: input.baseLifecycleRevision,
+                    buildCanonicalFingerprint: input.buildCanonicalFingerprint,
+                    metadataOwned: input.metadataOwned,
+                    reopenAssigneeOwned: input.reopenAssigneeOwned,
+                    buildAuthoritativePayload: (result, revision) => input.buildAuthoritativePayload(result, {
+                        sequence: revision.sequence,
+                        entityRevision: revision.entityRevision,
+                        lifecycleRevision: revision.lifecycleRevision,
+                    }),
+                }],
+            applyMutation: input.applyMutation,
+            buildResponse: (result, revisions) => input.buildResponse(result, {
+                sequence: revisions[0].sequence,
+                entityRevision: revisions[0].entityRevision,
+                lifecycleRevision: revisions[0].lifecycleRevision,
+            }),
+        });
+    }
+    acceptReservedOperationBatch(input) {
+        const ids = operationParams(input.identity);
+        const requestFingerprint = requireText(input.requestFingerprint, 'Request fingerprint');
+        const leaseOwner = requireText(input.leaseOwner, 'Lease owner');
+        const now = requireIsoTimestamp(input.now, 'Acceptance time');
+        try {
+            if (!Array.isArray(input.entries) || input.entries.length === 0 || input.entries.length > 100) {
+                throw new Error('Workspace sync journal entry count must be between 1 and 100.');
+            }
+            const entries = input.entries.map((entry) => ({
+                ...entry,
+                domain: requireText(entry.domain, 'Domain'),
+                entityId: requireText(entry.entityId, 'Entity id'),
+                mutationKind: requireText(entry.mutationKind, 'Mutation kind'),
+                revisionKind: normalizeRevisionKind(entry.revisionKind),
+                baseEntityRevision: normalizeSequence(entry.baseEntityRevision),
+                baseLifecycleRevision: normalizeSequence(entry.baseLifecycleRevision),
+                baseRevisionPolicy: entry.baseRevisionPolicy || 'exact',
+                sizeBytes: entry.sizeBytes == null ? null : normalizeSequence(entry.sizeBytes),
+            }));
+            const targets = new Set();
+            for (const entry of entries) {
+                if (entry.baseRevisionPolicy !== 'exact' && entry.baseRevisionPolicy !== 'current') {
+                    throw new Error(`Unsupported workspace sync base revision policy: ${entry.baseRevisionPolicy}.`);
+                }
+                const target = `${entry.domain}\u0000${entry.entityId}`;
+                if (targets.has(target))
+                    throw new Error(`Duplicate workspace sync journal target: ${entry.domain}/${entry.entityId}.`);
+                targets.add(target);
+            }
+            return this.db.transaction(() => {
+                const owned = this.db.prepare(`
+                UPDATE workspace_sync_operation_results
+                SET updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                  AND contract_version = ? AND status = 'processing'
+                  AND request_fingerprint = ? AND lease_owner = ?
+            `).run(now, ...ids, WORKSPACE_SYNC_CONTRACT_VERSION, requestFingerprint, leaseOwner);
+                if (Number(owned.changes || 0) !== 1)
+                    throw new WorkspaceSyncLeaseLostError();
+                // A zero-width allocation locks the workspace sequence row without
+                // consuming a sequence. This lets a mutation determine whether its
+                // optional journal entries exist while preserving a gap-free range.
+                this.allocateSequenceRange(ids[0], ids[1], now, 0);
+                const buildPendingRevision = (entry) => {
+                    const current = this.db.prepare(`
+                    SELECT CAST(entity_revision AS TEXT) AS entity_revision,
+                           CAST(lifecycle_revision AS TEXT) AS lifecycle_revision
+                    FROM workspace_sync_entity_revisions
+                    WHERE tenant_id = ? AND workspace_id = ? AND domain = ? AND entity_id = ?
+                `).get(ids[0], ids[1], entry.domain, entry.entityId);
+                    let entityRevision = BigInt(normalizeSequence(current?.entity_revision ?? 0));
+                    let lifecycleRevision = BigInt(normalizeSequence(current?.lifecycle_revision ?? 0));
+                    const baseEntityRevision = BigInt(entry.baseEntityRevision);
+                    const baseLifecycleRevision = BigInt(entry.baseLifecycleRevision);
+                    const invalidExact = entry.baseRevisionPolicy === 'exact'
+                        && (entityRevision !== baseEntityRevision || lifecycleRevision !== baseLifecycleRevision);
+                    const invalidCurrent = entry.baseRevisionPolicy === 'current'
+                        && (baseEntityRevision > entityRevision || baseLifecycleRevision > lifecycleRevision);
+                    if (invalidExact || invalidCurrent) {
+                        throw new WorkspaceSyncRevisionConflictError();
+                    }
+                    if (entry.revisionKind === 'metadata' || entry.revisionKind === 'both')
+                        entityRevision += 1n;
+                    if (entry.revisionKind === 'lifecycle' || entry.revisionKind === 'both')
+                        lifecycleRevision += 1n;
+                    // Earlier lifecycle-only writers could advance lifecycle past
+                    // entity revision. Preserve base-revision validation, then
+                    // repair the accepted coordinates before journaling new state.
+                    if (lifecycleRevision > entityRevision)
+                        entityRevision = lifecycleRevision;
+                    return {
+                        entityRevision: entityRevision.toString(10),
+                        lifecycleRevision: lifecycleRevision.toString(10),
+                    };
+                };
+                const requiredRevisions = new Map(entries
+                    .filter((entry) => !entry.include)
+                    .map((entry) => [`${entry.domain}\u0000${entry.entityId}`, buildPendingRevision(entry)]));
+                const mutationResult = input.applyMutation();
+                const activeEntries = entries.filter((entry) => entry.include?.(mutationResult) !== false);
+                if (activeEntries.length === 0) {
+                    throw new Error('Workspace sync operation must produce at least one journal entry.');
+                }
+                const acceptedSequence = this.allocateSequenceRange(ids[0], ids[1], now, activeEntries.length);
+                const firstSequence = BigInt(acceptedSequence) - BigInt(activeEntries.length) + 1n;
+                const pendingRevisions = activeEntries.map((entry) => (requiredRevisions.get(`${entry.domain}\u0000${entry.entityId}`) || buildPendingRevision(entry)));
+                const revisions = pendingRevisions.map((revision, index) => ({
+                    domain: activeEntries[index].domain,
+                    entityId: activeEntries[index].entityId,
+                    sequence: (firstSequence + BigInt(index)).toString(10),
+                    entityRevision: revision.entityRevision,
+                    lifecycleRevision: revision.lifecycleRevision,
+                }));
+                activeEntries.forEach((entry, index) => {
+                    const revision = revisions[index];
+                    const canonicalFingerprint = requireText(entry.buildCanonicalFingerprint(mutationResult, revision), 'Canonical fingerprint');
+                    const payloadJson = canonicalWorkspaceSyncJson(entry.buildAuthoritativePayload(mutationResult, revision));
+                    this.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 (?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?)
+                    ON CONFLICT (tenant_id, workspace_id, domain, entity_id) DO UPDATE SET
+                        contract_version = excluded.contract_version,
+                        entity_revision = excluded.entity_revision,
+                        lifecycle_revision = excluded.lifecycle_revision,
+                        coexistence_owned = 1,
+                        metadata_owned = CASE
+                            WHEN excluded.metadata_owned = 1 THEN 1
+                            ELSE workspace_sync_entity_revisions.metadata_owned
+                        END,
+                        reopen_assignee_owned = CASE
+                            WHEN excluded.reopen_assignee_owned = 1 THEN 1
+                            ELSE workspace_sync_entity_revisions.reopen_assignee_owned
+                        END,
+                        last_sequence = excluded.last_sequence,
+                        canonical_fingerprint = excluded.canonical_fingerprint,
+                        updated_at = excluded.updated_at
+                `).run(ids[0], ids[1], entry.domain, entry.entityId, WORKSPACE_SYNC_CONTRACT_VERSION, revision.entityRevision, revision.lifecycleRevision, entry.domain === 'task' && (entry.mutationKind === 'metadata-update'
+                        || entry.mutationKind === 'create'
+                        || entry.metadataOwned?.(mutationResult) === true) ? 1 : 0, entry.domain === 'task' && entry.reopenAssigneeOwned?.(mutationResult) === true ? 1 : 0, revision.sequence, canonicalFingerprint, now);
+                    this.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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                `).run(ids[0], ids[1], revision.sequence, WORKSPACE_SYNC_CONTRACT_VERSION, ids[3], ids[2], entry.domain, entry.entityId, entry.mutationKind, revision.entityRevision, revision.lifecycleRevision, entry.contentSha256 ?? null, entry.sizeBytes, payloadJson, now);
+                });
+                const responseJson = canonicalWorkspaceSyncJson(input.buildResponse(mutationResult, revisions));
+                const committed = this.db.prepare(`
+                UPDATE workspace_sync_operation_results
+                SET status = 'committed', response_json = ?, accepted_sequence = ?,
+                    lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                  AND status = 'processing' AND request_fingerprint = ? AND lease_owner = ?
+            `).run(responseJson, acceptedSequence, now, ...ids, requestFingerprint, leaseOwner);
+                if (Number(committed.changes || 0) !== 1)
+                    throw new WorkspaceSyncLeaseLostError();
+                return { responseJson, acceptedSequence };
+            })();
+        }
+        catch (error) {
+            if (!(error instanceof WorkspaceSyncLeaseLostError)) {
+                this.releaseFailedOperationReservation({
+                    identity: input.identity,
+                    requestFingerprint,
+                    leaseOwner,
+                    now,
+                });
+            }
+            throw error;
+        }
+    }
+    enqueueLocalOperation(input) {
+        const ids = operationParams(input.identity);
+        const domain = requireText(input.domain, 'Domain');
+        const entityId = requireText(input.entityId, 'Entity id');
+        const mutationKind = requireText(input.mutationKind, 'Mutation kind');
+        const dispatchClass = requireOutboxDispatchClass(input.dispatchClass ?? 'ordinary');
+        const explicitEntityRevision = normalizeSequence(input.baseEntityRevision ?? 0);
+        const explicitLifecycleRevision = normalizeSequence(input.baseLifecycleRevision ?? 0);
+        let payloadJson = canonicalWorkspaceSyncJson(input.payload);
+        let payloadFingerprint = fingerprintWorkspaceSyncPayload(input.payload);
+        const now = requireIsoTimestamp(input.now, 'Enqueue time');
+        const ownsTaskMetadata = domain === 'task' && (input.ownership?.taskMetadata ?? mutationKind === 'metadata-update');
+        const ownsTaskLifecycle = domain === 'task' && (input.ownership?.taskLifecycle ?? ['archive', 'unarchive', 'complete', 'reopen'].includes(mutationKind));
+        const ownsTaskAssignee = domain === 'task' && (input.ownership?.taskAssignee ?? mutationKind === 'reopen');
+        const additionalTargets = (input.additionalTargets || []).map((target) => {
+            const targetDomain = requireText(target.domain, 'Outbox target domain');
+            return {
+                domain: targetDomain,
+                entityId: requireText(target.entityId, 'Outbox target entity id'),
+                mutationKind: requireText(target.mutationKind, 'Outbox target mutation kind'),
+                baseEntityRevision: normalizeSequence(target.baseEntityRevision),
+                baseLifecycleRevision: normalizeSequence(target.baseLifecycleRevision),
+                ownsTaskMetadata: targetDomain === 'task' && target.ownsTaskMetadata === true,
+                ownsTaskLifecycle: targetDomain === 'task' && target.ownsTaskLifecycle === true,
+                ownsTaskAssignee: targetDomain === 'task' && target.ownsTaskAssignee === true,
+            };
+        }).sort((left, right) => (compareCodeUnits(left.domain, right.domain) || compareCodeUnits(left.entityId, right.entityId)));
+        if (additionalTargets.length > 0 && input.revisionSource !== 'current') {
+            throw new Error('Multi-target local operations must capture current revisions atomically.');
+        }
+        if ((input.requiredCurrentRevision || input.validateLockedState) && input.revisionSource !== 'current') {
+            throw new Error('Locked local enqueue preconditions require current revision capture.');
+        }
+        const queuedMetadataSuccessorDomain = input.queuedMetadataSuccessorDomain;
+        if (queuedMetadataSuccessorDomain && (input.revisionSource !== 'current'
+            || domain !== queuedMetadataSuccessorDomain
+            || mutationKind !== 'metadata-update'
+            || additionalTargets.length > 0
+            || (domain === 'task' && (!ownsTaskMetadata || ownsTaskLifecycle || ownsTaskAssignee)))) {
+            throw new Error('Queued successors are supported only for matching single-target metadata updates.');
+        }
+        const queuedTaskSuccessor = input.queuedTaskSuccessor === true;
+        const queuedWorkflowRuntimeSuccessor = input.queuedWorkflowRuntimeSuccessor === true;
+        const workflowTaskTarget = additionalTargets[0];
+        if (queuedWorkflowRuntimeSuccessor && (input.revisionSource !== 'current'
+            || domain !== 'workflow-execution'
+            || !['transition', 'complete-step'].includes(mutationKind)
+            || additionalTargets.length > 1
+            || (additionalTargets.length === 1 && (workflowTaskTarget.domain !== 'task'
+                || workflowTaskTarget.mutationKind !== 'metadata-update'
+                || !workflowTaskTarget.ownsTaskMetadata
+                || workflowTaskTarget.ownsTaskLifecycle
+                || workflowTaskTarget.ownsTaskAssignee))
+            || ownsTaskMetadata || ownsTaskLifecycle || ownsTaskAssignee)) {
+            throw new Error('Queued workflow runtime successors require a workflow execution root and optional task metadata target.');
+        }
+        const coalesceWorkflowAssignmentExecutionId = String(input.coalesceWorkflowAssignmentExecutionId || '').trim();
+        if (coalesceWorkflowAssignmentExecutionId && (input.revisionSource !== 'current'
+            || domain !== 'task'
+            || mutationKind !== 'set-status'
+            || !queuedTaskSuccessor)) {
+            throw new Error('Workflow assignment dependency coalescing requires a queued task status operation.');
+        }
+        const coalescedWorkflowPayloadFingerprint = coalesceWorkflowAssignmentExecutionId
+            ? (() => {
+                const normalized = JSON.parse(payloadJson);
+                delete normalized.workflowAssignment;
+                return fingerprintWorkspaceSyncPayload(normalized);
+            })()
+            : null;
+        const taskAggregateRootTarget = additionalTargets[0];
+        const queueableTaskRoot = domain === 'task'
+            && TASK_ROOT_SUCCESSOR_MUTATIONS.has(mutationKind)
+            && additionalTargets.length === 0;
+        const queueableTaskAggregate = Boolean(TASK_AGGREGATE_SUCCESSOR_MUTATIONS.get(domain)?.has(mutationKind))
+            && ((domain === 'task-comments' && mutationKind === 'reconcile' && additionalTargets.length === 0)
+                || (additionalTargets.length === 1
+                    && taskAggregateRootTarget.domain === 'task'
+                    && taskAggregateRootTarget.entityId === entityId
+                    && taskAggregateRootTarget.mutationKind === 'metadata-update'
+                    && taskAggregateRootTarget.ownsTaskMetadata
+                    && !taskAggregateRootTarget.ownsTaskLifecycle
+                    && !taskAggregateRootTarget.ownsTaskAssignee))
+            && !ownsTaskMetadata && !ownsTaskLifecycle && !ownsTaskAssignee;
+        if (queuedTaskSuccessor && (input.revisionSource !== 'current' || (!queueableTaskRoot && !queueableTaskAggregate))) {
+            throw new Error('Queued task successors require a recognized task root or aggregate operation.');
+        }
+        const additionalTargetKeys = new Set();
+        for (const target of additionalTargets) {
+            const key = `${target.domain}\u0000${target.entityId}`;
+            if (key === `${domain}\u0000${entityId}` || additionalTargetKeys.has(key)) {
+                throw new Error(`Duplicate workspace sync outbox target: ${target.domain}/${target.entityId}.`);
+            }
+            additionalTargetKeys.add(key);
+        }
+        return this.db.transaction(() => {
+            const lock = this.db.prepare(`
+                INSERT INTO workspace_sync_domain_locks (tenant_id, workspace_id, domain, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT (tenant_id, workspace_id, domain) DO UPDATE SET updated_at = excluded.updated_at
+            `);
+            if (requiresInitiativeProjectionLock([{ domain, entityId }, ...additionalTargets])) {
+                lock.run(ids[0], ids[1], WORKSPACE_SYNC_INITIATIVE_PROJECTION_LOCK, now);
+            }
+            if (input.requireV3PlanningOwnership === 'combined'
+                || requiresCombinedProjectionLock([{ domain, entityId }, ...additionalTargets])) {
+                lock.run(ids[0], ids[1], WORKSPACE_SYNC_COMBINED_PROJECTION_LOCK, now);
+            }
+            if (input.requireV3PlanningOwnership) {
+                const ownership = input.requireV3PlanningOwnership === 'initiative'
+                    ? this.readInitiativeProjectionOwnership({ tenantId: ids[0], workspaceId: ids[1] })
+                    : this.readCombinedProjectionOwnership({ tenantId: ids[0], workspaceId: ids[1] });
+                if (ownership.owner !== 'v3')
+                    throw new WorkspaceSyncPlanningOwnershipChangedError();
+            }
+            if (input.revisionSource === 'current') {
+                const targets = normalizeWorkspaceSyncLockTargets([
+                    { domain, entityId },
+                    ...additionalTargets.map((target) => ({ domain: target.domain, entityId: target.entityId })),
+                ]);
+                for (const target of targets) {
+                    lock.run(ids[0], ids[1], `local-outbox:${target.domain}:${target.entityId}`, now);
+                }
+                if (input.requiredCurrentRevision) {
+                    const revision = this.db.prepare(`
+                        SELECT CAST(entity_revision AS TEXT) AS entity_revision,
+                               CAST(lifecycle_revision AS TEXT) AS lifecycle_revision
+                        FROM workspace_sync_entity_revisions
+                        WHERE tenant_id = ? AND workspace_id = ? AND domain = ? AND entity_id = ?
+                    `).get(ids[0], ids[1], domain, entityId);
+                    if (normalizeSequence(revision?.entity_revision ?? 0)
+                        !== normalizeSequence(input.requiredCurrentRevision.entityRevision)
+                        || normalizeSequence(revision?.lifecycle_revision ?? 0)
+                            !== normalizeSequence(input.requiredCurrentRevision.lifecycleRevision))
+                        throw new WorkspaceSyncRevisionConflictError();
+                }
+                input.validateLockedState?.();
+                const prior = this.db.prepare(`
+                    SELECT contract_version, dispatch_class, domain, entity_id, mutation_kind, payload_fingerprint,
+                           owns_task_metadata, owns_task_lifecycle, owns_task_assignee
+                    FROM workspace_sync_outbox
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                `).get(...ids);
+                if (prior) {
+                    const matches = Number(prior.contract_version) === WORKSPACE_SYNC_CONTRACT_VERSION
+                        && prior.dispatch_class === dispatchClass
+                        && prior.domain === domain
+                        && prior.entity_id === entityId
+                        && prior.mutation_kind === mutationKind
+                        && Number(prior.owns_task_metadata) === (ownsTaskMetadata ? 1 : 0)
+                        && Number(prior.owns_task_lifecycle) === (ownsTaskLifecycle ? 1 : 0)
+                        && Number(prior.owns_task_assignee) === (ownsTaskAssignee ? 1 : 0)
+                        && (prior.payload_fingerprint === payloadFingerprint
+                            || prior.payload_fingerprint === coalescedWorkflowPayloadFingerprint);
+                    const persistedTargets = this.db.prepare(`
+                        SELECT domain, entity_id, mutation_kind,
+                               CAST(base_entity_revision AS TEXT) AS base_entity_revision,
+                               CAST(base_lifecycle_revision AS TEXT) AS base_lifecycle_revision,
+                               owns_task_metadata, owns_task_lifecycle, owns_task_assignee
+                        FROM workspace_sync_outbox_targets
+                        WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                          AND NOT (domain = ? AND entity_id = ?)
+                        ORDER BY domain, entity_id
+                    `).all(...ids, domain, entityId);
+                    const targetsMatch = persistedTargets.length === additionalTargets.length
+                        && persistedTargets.every((persisted, index) => {
+                            const expected = additionalTargets[index];
+                            return persisted.domain === expected.domain
+                                && persisted.entity_id === expected.entityId
+                                && persisted.mutation_kind === expected.mutationKind
+                                && normalizeSequence(persisted.base_entity_revision) === expected.baseEntityRevision
+                                && normalizeSequence(persisted.base_lifecycle_revision) === expected.baseLifecycleRevision
+                                && Number(persisted.owns_task_metadata) === (expected.ownsTaskMetadata ? 1 : 0)
+                                && Number(persisted.owns_task_lifecycle) === (expected.ownsTaskLifecycle ? 1 : 0)
+                                && Number(persisted.owns_task_assignee) === (expected.ownsTaskAssignee ? 1 : 0);
+                        });
+                    if (!matches || !targetsMatch)
+                        throw new WorkspaceSyncIdempotencyConflictError();
+                    return { enqueued: false };
+                }
+            }
+            const current = input.revisionSource === 'current'
+                ? this.db.prepare(`
+                    SELECT CAST(entity_revision AS TEXT) AS entity_revision,
+                           CAST(lifecycle_revision AS TEXT) AS lifecycle_revision
+                    FROM workspace_sync_entity_revisions
+                    WHERE tenant_id = ? AND workspace_id = ? AND domain = ? AND entity_id = ?
+                `).get(ids[0], ids[1], domain, entityId)
+                : undefined;
+            const baseEntityRevision = input.revisionSource === 'current'
+                ? normalizeSequence(current?.entity_revision ?? 0)
+                : explicitEntityRevision;
+            const baseLifecycleRevision = input.revisionSource === 'current'
+                ? normalizeSequence(current?.lifecycle_revision ?? 0)
+                : explicitLifecycleRevision;
+            let queuedBehindActiveOperation = false;
+            if (input.revisionSource === 'current') {
+                const targets = [{ domain, entityId }, ...additionalTargets];
+                for (const target of targets) {
+                    const active = this.db.prepare(`
+                        SELECT outbox.operation_id, outbox.domain, outbox.entity_id, outbox.mutation_kind,
+                               outbox.status, outbox.attempt_count, outbox.next_attempt_at,
+                               outbox.lease_expires_at, outbox.last_error_code,
+                               outbox.created_at, outbox.updated_at,
+                               outbox.payload_json,
+                               outbox.owns_task_metadata, outbox.owns_task_lifecycle,
+                               outbox.owns_task_assignee,
+                               (SELECT COUNT(*) FROM workspace_sync_outbox_targets AS counted_target
+                                WHERE counted_target.tenant_id = outbox.tenant_id
+                                  AND counted_target.workspace_id = outbox.workspace_id
+                                  AND counted_target.client_id = outbox.client_id
+                                  AND counted_target.operation_id = outbox.operation_id) AS target_count,
+                               (SELECT COUNT(*) FROM workspace_sync_outbox_targets AS aggregate_target
+                                 WHERE aggregate_target.tenant_id = outbox.tenant_id
+                                   AND aggregate_target.workspace_id = outbox.workspace_id
+                                   AND aggregate_target.client_id = outbox.client_id
+                                   AND aggregate_target.operation_id = outbox.operation_id
+                                   AND (
+                                     (aggregate_target.domain = outbox.domain
+                                       AND aggregate_target.entity_id = outbox.entity_id
+                                       AND aggregate_target.mutation_kind = outbox.mutation_kind
+                                       AND aggregate_target.owns_task_metadata = 0
+                                       AND aggregate_target.owns_task_lifecycle = 0
+                                       AND aggregate_target.owns_task_assignee = 0)
+                                     OR (aggregate_target.domain = 'task'
+                                       AND aggregate_target.entity_id = outbox.entity_id
+                                       AND aggregate_target.mutation_kind = 'metadata-update'
+                                       AND aggregate_target.owns_task_metadata = 1
+                                       AND aggregate_target.owns_task_lifecycle = 0
+                                       AND aggregate_target.owns_task_assignee = 0)
+                                   )) AS task_aggregate_target_count
+                        FROM workspace_sync_outbox AS outbox
+                        WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+                          AND outbox.status IN ('pending', 'in_flight', 'blocked')
+                          AND NOT (outbox.client_id = ? AND outbox.operation_id = ?)
+                          AND (
+                            (outbox.domain = ? AND outbox.entity_id = ?)
+                            OR EXISTS (
+                                SELECT 1 FROM workspace_sync_outbox_targets AS persisted_target
+                                WHERE persisted_target.tenant_id = outbox.tenant_id
+                                  AND persisted_target.workspace_id = outbox.workspace_id
+                                  AND persisted_target.client_id = outbox.client_id
+                                  AND persisted_target.operation_id = outbox.operation_id
+                                  AND persisted_target.domain = ? AND persisted_target.entity_id = ?
+                            )
+                          )
+                        ORDER BY CASE outbox.status
+                                   WHEN 'blocked' THEN 0
+                                   WHEN 'in_flight' THEN 1
+                                   ELSE 2
+                                 END,
+                                 outbox.enqueue_sequence
+                    `).all(ids[0], ids[1], ids[2], ids[3], target.domain, target.entityId, target.domain, target.entityId);
+                    if (active.length > 0) {
+                        const isCompatibleTaskAggregate = (row) => {
+                            const activeDomain = String(row.domain || '');
+                            const activeMutationKind = String(row.mutation_kind || '');
+                            const isReconciliation = activeDomain === 'task-comments'
+                                && activeMutationKind === 'reconcile'
+                                && Number(row.target_count) === 1;
+                            return row.entity_id === entityId
+                                && Boolean(TASK_AGGREGATE_SUCCESSOR_MUTATIONS.get(activeDomain)
+                                    ?.has(activeMutationKind))
+                                && Number(row.owns_task_metadata) === 0
+                                && Number(row.owns_task_lifecycle) === 0
+                                && Number(row.owns_task_assignee) === 0
+                                && (isReconciliation || (Number(row.target_count) === 2
+                                    && Number(row.task_aggregate_target_count) === 2));
+                        };
+                        const isCompatibleWorkflowRuntimeAggregate = (row) => (row.domain === 'workflow-execution'
+                            && row.mutation_kind === 'complete-step'
+                            && Number(row.owns_task_metadata) === 0
+                            && Number(row.owns_task_lifecycle) === 0
+                            && Number(row.owns_task_assignee) === 0
+                            && Number(row.target_count) === 2);
+                        const compatibleMetadataSuccessor = Boolean(queuedMetadataSuccessorDomain)
+                            && target.domain === domain
+                            && target.entityId === entityId
+                            && active.every((row) => ((row.domain === queuedMetadataSuccessorDomain
+                                && row.entity_id === entityId
+                                && row.mutation_kind === 'metadata-update'
+                                && (row.domain !== 'task' || (Number(row.owns_task_metadata) === 1
+                                    && Number(row.owns_task_lifecycle) === 0
+                                    && Number(row.owns_task_assignee) === 0))
+                                && Number(row.target_count) === 1)
+                                || (queuedMetadataSuccessorDomain === 'task'
+                                    && (isCompatibleTaskAggregate(row)
+                                        || isCompatibleWorkflowRuntimeAggregate(row)))));
+                        const compatibleTaskSuccessor = queuedTaskSuccessor
+                            && target.entityId === entityId
+                            && active.every((row) => {
+                                const activeDomain = String(row.domain || '');
+                                const activeMutationKind = String(row.mutation_kind || '');
+                                const isTaskRoot = activeDomain === 'task'
+                                    && row.entity_id === entityId
+                                    && (TASK_ROOT_SUCCESSOR_MUTATIONS.has(activeMutationKind)
+                                        || (queueableTaskAggregate && activeMutationKind === 'create'))
+                                    && Number(row.target_count) === 1;
+                                return isTaskRoot
+                                    || isCompatibleTaskAggregate(row)
+                                    || isCompatibleWorkflowRuntimeAggregate(row);
+                            });
+                        const compatibleWorkflowRuntimeSuccessor = queuedWorkflowRuntimeSuccessor
+                            && active.every((row) => (row.domain === 'workflow-execution'
+                                && row.entity_id === entityId
+                                && ['transition', 'complete-step'].includes(String(row.mutation_kind || ''))
+                                && Number(row.owns_task_metadata) === 0
+                                && Number(row.owns_task_lifecycle) === 0
+                                && Number(row.owns_task_assignee) === 0
+                                && [1, 2].includes(Number(row.target_count))));
+                        if (!compatibleMetadataSuccessor
+                            && !compatibleTaskSuccessor
+                            && !compatibleWorkflowRuntimeSuccessor) {
+                            throw workspaceSyncEntityBusyError({ target, active, now });
+                        }
+                        queuedBehindActiveOperation = true;
+                        if (coalesceWorkflowAssignmentExecutionId
+                            && target.domain === 'task' && target.entityId === entityId) {
+                            const dependencyAlreadyQueued = active.some((row) => {
+                                try {
+                                    const activePayload = JSON.parse(String(row.payload_json || ''));
+                                    return String(activePayload.workflowAssignment?.execution?.id || '')
+                                        === coalesceWorkflowAssignmentExecutionId;
+                                }
+                                catch {
+                                    return false;
+                                }
+                            });
+                            if (dependencyAlreadyQueued) {
+                                const normalizedPayload = JSON.parse(payloadJson);
+                                delete normalizedPayload.workflowAssignment;
+                                payloadJson = canonicalWorkspaceSyncJson(normalizedPayload);
+                                payloadFingerprint = fingerprintWorkspaceSyncPayload(normalizedPayload);
+                            }
+                        }
+                    }
+                }
+                for (const target of additionalTargets) {
+                    const revision = this.db.prepare(`
+                        SELECT CAST(entity_revision AS TEXT) AS entity_revision,
+                               CAST(lifecycle_revision AS TEXT) AS lifecycle_revision
+                        FROM workspace_sync_entity_revisions
+                        WHERE tenant_id = ? AND workspace_id = ? AND domain = ? AND entity_id = ?
+                    `).get(ids[0], ids[1], target.domain, target.entityId);
+                    if (normalizeSequence(revision?.entity_revision ?? 0) !== target.baseEntityRevision
+                        || normalizeSequence(revision?.lifecycle_revision ?? 0) !== target.baseLifecycleRevision)
+                        throw new WorkspaceSyncRevisionConflictError();
+                }
+            }
+            const enqueueSequence = this.allocateOutboxEnqueueSequence(ids[0], ids[1], now);
+            const inserted = this.db.prepare(`
+                INSERT INTO workspace_sync_outbox (
+                    tenant_id, workspace_id, operation_id, contract_version, client_id,
+                    dispatch_class, domain, entity_id, mutation_kind, owns_task_metadata,
+                    owns_task_lifecycle, owns_task_assignee, base_entity_revision,
+                    base_lifecycle_revision, payload_json, payload_fingerprint,
+                    status, attempt_count, enqueue_sequence, rebase_before_first_attempt,
+                    next_attempt_at, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0, ?, ?, ?, ?, ?)
+                ON CONFLICT (tenant_id, workspace_id, client_id, operation_id) DO NOTHING
+            `).run(ids[0], ids[1], ids[3], WORKSPACE_SYNC_CONTRACT_VERSION, ids[2], dispatchClass, domain, entityId, mutationKind, ownsTaskMetadata ? 1 : 0, ownsTaskLifecycle ? 1 : 0, ownsTaskAssignee ? 1 : 0, baseEntityRevision, baseLifecycleRevision, payloadJson, payloadFingerprint, enqueueSequence, queuedBehindActiveOperation ? 1 : 0, now, now, now);
+            if (Number(inserted.changes || 0) === 1) {
+                const insertTarget = this.db.prepare(`
+                    INSERT INTO workspace_sync_outbox_targets (
+                        tenant_id, workspace_id, client_id, operation_id, domain, entity_id,
+                        mutation_kind, base_entity_revision, base_lifecycle_revision,
+                        owns_task_metadata, owns_task_lifecycle, owns_task_assignee, created_at
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                `);
+                const targets = [{
+                        domain, entityId, mutationKind, baseEntityRevision, baseLifecycleRevision,
+                        ownsTaskMetadata, ownsTaskLifecycle, ownsTaskAssignee,
+                    }, ...additionalTargets];
+                for (const target of targets) {
+                    insertTarget.run(ids[0], ids[1], ids[2], ids[3], target.domain, target.entityId, target.mutationKind, target.baseEntityRevision, target.baseLifecycleRevision, target.ownsTaskMetadata ? 1 : 0, target.ownsTaskLifecycle ? 1 : 0, target.ownsTaskAssignee ? 1 : 0, now);
+                }
+                return { enqueued: true, mutationResult: input.applyLocalMutation() };
+            }
+            const existing = this.db.prepare(`
+                SELECT contract_version, dispatch_class, domain, entity_id, mutation_kind,
+                       owns_task_metadata, owns_task_lifecycle, owns_task_assignee,
+                       CAST(base_entity_revision AS TEXT) AS base_entity_revision,
+                       CAST(base_lifecycle_revision AS TEXT) AS base_lifecycle_revision,
+                       payload_fingerprint
+                FROM workspace_sync_outbox
+                WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+            `).get(...ids);
+            const matches = existing
+                && Number(existing.contract_version) === WORKSPACE_SYNC_CONTRACT_VERSION
+                && existing.dispatch_class === dispatchClass
+                && existing.domain === domain
+                && existing.entity_id === entityId
+                && existing.mutation_kind === mutationKind
+                && Number(existing.owns_task_metadata) === (ownsTaskMetadata ? 1 : 0)
+                && Number(existing.owns_task_lifecycle) === (ownsTaskLifecycle ? 1 : 0)
+                && Number(existing.owns_task_assignee) === (ownsTaskAssignee ? 1 : 0)
+                && normalizeSequence(existing.base_entity_revision) === baseEntityRevision
+                && normalizeSequence(existing.base_lifecycle_revision) === baseLifecycleRevision
+                && (existing.payload_fingerprint === payloadFingerprint
+                    || existing.payload_fingerprint === coalescedWorkflowPayloadFingerprint);
+            if (!matches)
+                throw new WorkspaceSyncIdempotencyConflictError();
+            return { enqueued: false };
+        })();
+    }
+    listTaskMetadataOwnership(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const rows = this.db.prepare(`
+            WITH ownership_sources AS (
+                SELECT entity_id,
+                       0 AS active_operation,
+                       0 AS active_create_operation,
+                       0 AS active_delete_operation,
+                       CASE WHEN EXISTS (
+                           SELECT 1 FROM workspace_sync_journal AS delete_journal
+                           WHERE delete_journal.tenant_id = workspace_sync_entity_revisions.tenant_id
+                             AND delete_journal.workspace_id = workspace_sync_entity_revisions.workspace_id
+                             AND delete_journal.domain = 'task'
+                             AND delete_journal.entity_id = workspace_sync_entity_revisions.entity_id
+                             AND delete_journal.mutation_kind = 'delete'
+                             AND delete_journal.sequence = workspace_sync_entity_revisions.last_sequence
+                       ) THEN 1 ELSE 0 END AS delete_owned,
+                       metadata_owned,
+                       0 AS active_lifecycle_operation,
+                       0 AS active_reopen_operation,
+                       reopen_assignee_owned,
+                       CAST(entity_revision AS TEXT) AS entity_revision,
+                       CAST(lifecycle_revision AS TEXT) AS lifecycle_revision,
+                       CAST(last_sequence AS TEXT) AS last_sequence
+                FROM workspace_sync_entity_revisions
+                WHERE tenant_id = ? AND workspace_id = ?
+                  AND contract_version = ? AND domain = 'task'
+                  AND coexistence_owned = 1
+                  AND (metadata_owned = 1 OR lifecycle_revision > 0)
+                UNION ALL
+                SELECT target.entity_id,
+                       CASE WHEN target.owns_task_metadata = 1 OR target.mutation_kind = 'metadata-update' THEN 1 ELSE 0 END AS active_operation,
+                       CASE WHEN target.mutation_kind = 'create' THEN 1 ELSE 0 END AS active_create_operation,
+                       CASE WHEN target.mutation_kind = 'delete' THEN 1 ELSE 0 END AS active_delete_operation,
+                       CASE WHEN target.mutation_kind = 'delete' THEN 1 ELSE 0 END AS delete_owned,
+                       COALESCE(revisions.metadata_owned, 0) AS metadata_owned,
+                       CASE WHEN target.owns_task_lifecycle = 1 OR target.mutation_kind IN ('archive', 'unarchive', 'complete', 'reopen') THEN 1 ELSE 0 END AS active_lifecycle_operation,
+                       CASE WHEN target.owns_task_assignee = 1 OR target.mutation_kind = 'reopen' THEN 1 ELSE 0 END AS active_reopen_operation,
+                       0 AS reopen_assignee_owned,
+                       CAST(revisions.entity_revision AS TEXT) AS entity_revision,
+                       CAST(revisions.lifecycle_revision AS TEXT) AS lifecycle_revision,
+                       CAST(revisions.last_sequence AS TEXT) AS last_sequence
+                FROM workspace_sync_outbox_targets AS target
+                INNER JOIN workspace_sync_outbox AS outbox
+                  ON outbox.tenant_id = target.tenant_id
+                 AND outbox.workspace_id = target.workspace_id
+                 AND outbox.client_id = target.client_id
+                 AND outbox.operation_id = target.operation_id
+                LEFT JOIN workspace_sync_entity_revisions AS revisions
+                  ON revisions.tenant_id = target.tenant_id
+                 AND revisions.workspace_id = target.workspace_id
+                 AND revisions.contract_version = outbox.contract_version
+                 AND revisions.domain = target.domain
+                 AND revisions.entity_id = target.entity_id
+                WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+                  AND outbox.contract_version = ? AND target.domain = 'task'
+                  AND (target.mutation_kind = 'create'
+                    OR target.owns_task_metadata = 1
+                    OR target.owns_task_lifecycle = 1
+                    OR target.owns_task_assignee = 1
+                    OR target.mutation_kind IN ('metadata-update', 'delete', 'archive', 'unarchive', 'complete', 'reopen'))
+                  AND (
+                    outbox.status IN ('pending', 'in_flight', 'blocked')
+                    OR (target.mutation_kind = 'delete' AND outbox.status = 'accepted')
+                  )
+                UNION ALL
+                SELECT outbox.entity_id,
+                       CASE WHEN outbox.owns_task_metadata = 1 OR outbox.mutation_kind = 'metadata-update' THEN 1 ELSE 0 END AS active_operation,
+                       CASE WHEN outbox.mutation_kind = 'create' THEN 1 ELSE 0 END AS active_create_operation,
+                       CASE WHEN outbox.mutation_kind = 'delete' THEN 1 ELSE 0 END AS active_delete_operation,
+                       CASE WHEN outbox.mutation_kind = 'delete' THEN 1 ELSE 0 END AS delete_owned,
+                       COALESCE(revisions.metadata_owned, 0) AS metadata_owned,
+                       CASE WHEN outbox.owns_task_lifecycle = 1 OR outbox.mutation_kind IN ('archive', 'unarchive', 'complete', 'reopen') THEN 1 ELSE 0 END AS active_lifecycle_operation,
+                       CASE WHEN outbox.owns_task_assignee = 1 OR outbox.mutation_kind = 'reopen' THEN 1 ELSE 0 END AS active_reopen_operation,
+                       0 AS reopen_assignee_owned,
+                       CAST(revisions.entity_revision AS TEXT) AS entity_revision,
+                       CAST(revisions.lifecycle_revision AS TEXT) AS lifecycle_revision,
+                       CAST(revisions.last_sequence AS TEXT) AS last_sequence
+                FROM workspace_sync_outbox AS outbox
+                LEFT JOIN workspace_sync_entity_revisions AS revisions
+                  ON revisions.tenant_id = outbox.tenant_id
+                 AND revisions.workspace_id = outbox.workspace_id
+                 AND revisions.contract_version = outbox.contract_version
+                 AND revisions.domain = outbox.domain
+                 AND revisions.entity_id = outbox.entity_id
+                WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+                  AND outbox.contract_version = ? AND outbox.domain = 'task'
+                  AND (outbox.mutation_kind = 'create'
+                    OR outbox.owns_task_metadata = 1
+                    OR outbox.owns_task_lifecycle = 1
+                    OR outbox.owns_task_assignee = 1
+                    OR outbox.mutation_kind IN ('metadata-update', 'delete', 'archive', 'unarchive', 'complete', 'reopen'))
+                  AND (
+                    outbox.status IN ('pending', 'in_flight', 'blocked')
+                    OR (outbox.mutation_kind = 'delete' AND outbox.status = 'accepted')
+                  )
+            )
+            SELECT entity_id,
+                   MAX(active_operation) AS active_operation,
+                   MAX(active_create_operation) AS active_create_operation,
+                   MAX(active_delete_operation) AS active_delete_operation,
+                   MAX(delete_owned) AS delete_owned,
+                   MAX(metadata_owned) AS metadata_owned,
+                   MAX(active_lifecycle_operation) AS active_lifecycle_operation,
+                   MAX(active_reopen_operation) AS active_reopen_operation,
+                   MAX(reopen_assignee_owned) AS reopen_assignee_owned,
+                   MAX(entity_revision) AS entity_revision,
+                   MAX(lifecycle_revision) AS lifecycle_revision,
+                   MAX(last_sequence) AS last_sequence
+            FROM ownership_sources
+            GROUP BY entity_id
+            ORDER BY entity_id ASC
+        `).all(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION);
+        return rows.map((row) => ({
+            taskId: requireText(row.entity_id, 'Task id'),
+            activeOperation: Number(row.active_operation) === 1,
+            activeCreateOperation: Number(row.active_create_operation) === 1,
+            ...(Number(row.active_delete_operation) === 1 ? { activeDeleteOperation: true } : {}),
+            ...(Number(row.delete_owned) === 1 ? { deleteOwned: true } : {}),
+            metadataOwned: Number(row.metadata_owned) === 1,
+            activeLifecycleOperation: Number(row.active_lifecycle_operation) === 1,
+            activeReopenOperation: Number(row.active_reopen_operation) === 1,
+            reopenAssigneeOwned: Number(row.reopen_assignee_owned) === 1,
+            entityRevision: row.entity_revision === null || row.entity_revision === undefined
+                ? null : normalizeSequence(row.entity_revision),
+            lifecycleRevision: row.lifecycle_revision === null || row.lifecycle_revision === undefined
+                ? null : normalizeSequence(row.lifecycle_revision),
+            lastSequence: row.last_sequence === null || row.last_sequence === undefined
+                ? null : normalizeSequence(row.last_sequence),
+        }));
+    }
+    listTaskRevisionProjections(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const taskIds = Array.from(new Set(input.taskIds.map((taskId) => requireText(taskId, 'Task id')))).sort();
+        if (taskIds.length === 0)
+            return [];
+        const placeholders = taskIds.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+            SELECT entity_id,
+                   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,
+                   CASE WHEN EXISTS (
+                       SELECT 1 FROM workspace_sync_task_taxonomy_ownership AS taxonomy_ownership
+                       WHERE taxonomy_ownership.tenant_id = workspace_sync_entity_revisions.tenant_id
+                         AND taxonomy_ownership.workspace_id = workspace_sync_entity_revisions.workspace_id
+                         AND taxonomy_ownership.task_id = workspace_sync_entity_revisions.entity_id
+                   ) THEN 1 ELSE 0 END AS taxonomy_owned
+            FROM workspace_sync_entity_revisions
+            WHERE tenant_id = ? AND workspace_id = ?
+              AND contract_version = ? AND domain = 'task'
+              AND entity_id IN (${placeholders})
+              AND entity_revision > 0 AND last_sequence IS NOT NULL
+              AND canonical_fingerprint IS NOT NULL
+            ORDER BY entity_id ASC
+        `).all(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, ...taskIds);
+        return rows.map((row) => ({
+            taskId: requireText(row.entity_id, 'Task id'),
+            entityRevision: normalizeSequence(row.entity_revision),
+            lifecycleRevision: normalizeSequence(row.lifecycle_revision),
+            lastSequence: normalizeSequence(row.last_sequence),
+            canonicalFingerprint: requireText(row.canonical_fingerprint, 'Canonical fingerprint'),
+            taxonomyOwned: Number(row.taxonomy_owned) === 1,
+        }));
+    }
+    listPlanningRevisionProjections(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const domain = input.domain;
+        const entityIds = Array.from(new Set(input.entityIds.map((entityId) => requireText(entityId, 'Planning entity id')))).sort();
+        if (entityIds.length === 0)
+            return [];
+        if (entityIds.length > 100)
+            throw new Error('Planning revision projection supports at most 100 entity ids.');
+        const placeholders = entityIds.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+            SELECT revision.entity_id,
+                   revision.coexistence_owned,
+                   journal.mutation_kind,
+                   CAST(revision.entity_revision AS TEXT) AS entity_revision,
+                   CAST(revision.lifecycle_revision AS TEXT) AS lifecycle_revision,
+                   CAST(revision.last_sequence AS TEXT) AS last_sequence,
+                   revision.canonical_fingerprint,
+                   journal.occurred_at
+            FROM workspace_sync_entity_revisions AS revision
+            LEFT JOIN workspace_sync_journal AS journal
+              ON journal.tenant_id = revision.tenant_id
+             AND journal.workspace_id = revision.workspace_id
+             AND journal.contract_version = revision.contract_version
+             AND journal.domain = revision.domain
+             AND journal.entity_id = revision.entity_id
+             AND journal.sequence = revision.last_sequence
+            WHERE revision.tenant_id = ? AND revision.workspace_id = ?
+              AND revision.contract_version = ? AND revision.domain = ?
+              AND revision.entity_id IN (${placeholders})
+              AND revision.entity_revision > 0
+              AND revision.last_sequence IS NOT NULL
+              AND revision.canonical_fingerprint IS NOT NULL
+            ORDER BY revision.entity_id ASC
+        `).all(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, domain, ...entityIds);
+        const allowedKinds = new Set(['create', 'metadata-update', 'append-comment', 'archive', 'unarchive']);
+        return rows.map((row) => {
+            const mutationKind = requireText(row.mutation_kind, 'Planning mutation kind');
+            if (!allowedKinds.has(mutationKind)) {
+                throw new Error(`Unsupported ${domain} journal mutation kind: ${mutationKind}`);
+            }
+            return {
+                entityId: requireText(row.entity_id, 'Planning entity id'),
+                coexistenceOwned: Number(row.coexistence_owned) === 1,
+                mutationKind: mutationKind,
+                entityRevision: normalizeSequence(row.entity_revision),
+                lifecycleRevision: normalizeSequence(row.lifecycle_revision),
+                lastSequence: normalizeSequence(row.last_sequence),
+                canonicalFingerprint: requireText(row.canonical_fingerprint, 'Canonical fingerprint'),
+                occurredAt: requireIsoTimestamp(row.occurred_at, 'Journal occurrence time'),
+            };
+        });
+    }
+    ensureInitiativeRevisionBaselines(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Initiative baseline time');
+        const initiatives = [...input.initiatives].map((initiative) => ({
+            ...initiative,
+            entityId: requireText(initiative.entityId, 'Initiative id'),
+            currentFingerprint: requireText(initiative.currentFingerprint, 'Initiative fingerprint'),
+            occurredAt: requireIsoTimestamp(initiative.occurredAt, 'Initiative occurrence time'),
+        })).sort((left, right) => compareCodeUnits(left.entityId, right.entityId));
+        if (new Set(initiatives.map((initiative) => initiative.entityId)).size !== initiatives.length) {
+            throw new Error('Initiative baseline contains duplicate entity ids.');
+        }
+        for (const initiative of initiatives) {
+            if (!/^[a-f0-9]{64}$/.test(initiative.currentFingerprint)) {
+                throw new Error(`Initiative baseline fingerprint is invalid: ${initiative.entityId}.`);
+            }
+        }
+        return this.db.transaction(() => {
+            this.allocateSequenceRange(tenantId, workspaceId, now, 0);
+            const revisionRows = this.db.prepare(`
+                SELECT entity_id, contract_version, canonical_fingerprint,
+                       CAST(entity_revision AS TEXT) AS entity_revision,
+                       CAST(lifecycle_revision AS TEXT) AS lifecycle_revision,
+                       CAST(last_sequence AS TEXT) AS last_sequence
+                FROM workspace_sync_entity_revisions
+                WHERE tenant_id = ? AND workspace_id = ? AND domain = 'initiative'
+            `).all(tenantId, workspaceId);
+            const revisions = new Map(revisionRows.map((row) => [requireText(row.entity_id, 'Initiative id'), row]));
+            const missing = [];
+            for (const initiative of initiatives) {
+                const current = revisions.get(initiative.entityId);
+                if (!current) {
+                    missing.push(initiative);
+                    continue;
+                }
+                if (Number(current.contract_version) !== WORKSPACE_SYNC_CONTRACT_VERSION
+                    || current.canonical_fingerprint !== initiative.currentFingerprint
+                    || BigInt(normalizeSequence(current.entity_revision)) < 1n
+                    || (initiative.archived && BigInt(normalizeSequence(current.lifecycle_revision)) < 1n)
+                    || BigInt(normalizeSequence(current.last_sequence)) < 1n) {
+                    throw new WorkspaceSyncRevisionConflictError();
+                }
+            }
+            const rowCount = missing.reduce((count, initiative) => count + (initiative.archived ? 2 : 1), 0);
+            const highWatermark = this.allocateSequenceRange(tenantId, workspaceId, now, rowCount);
+            let sequence = BigInt(highWatermark) - BigInt(rowCount) + 1n;
+            for (const initiative of missing) {
+                const operationId = `initiative-baseline-${randomUUID()}`;
+                const insertJournal = (mutationKind, entityRevision, lifecycleRevision, payload) => {
+                    this.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 (?, ?, ?, ?, ?, 'sync-v3-repair', 'initiative', ?, ?, ?, ?, NULL, NULL, ?, ?)
+                    `).run(tenantId, workspaceId, sequence.toString(10), WORKSPACE_SYNC_CONTRACT_VERSION, operationId, initiative.entityId, mutationKind, entityRevision, lifecycleRevision, canonicalWorkspaceSyncJson(payload), initiative.occurredAt);
+                    sequence += 1n;
+                };
+                insertJournal('create', 1, 0, initiative.activePayload);
+                if (initiative.archived)
+                    insertJournal('archive', 2, 1, initiative.currentPayload);
+                const entityRevision = initiative.archived ? 2 : 1;
+                const lifecycleRevision = initiative.archived ? 1 : 0;
+                const lastSequence = sequence - 1n;
+                this.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 (?, ?, 'initiative', ?, ?, ?, ?, 0, 0, 0, ?, ?, ?)
+                `).run(tenantId, workspaceId, initiative.entityId, WORKSPACE_SYNC_CONTRACT_VERSION, entityRevision, lifecycleRevision, lastSequence.toString(10), initiative.currentFingerprint, now);
+            }
+            return { highWatermark, insertedEntities: missing.length, insertedJournalRows: rowCount };
+        })();
+    }
+    markTaskTaxonomyProjectionOwned(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Taxonomy ownership time');
+        const taskIds = Array.from(new Set(input.taskIds.map((taskId) => requireText(taskId, 'Task id')))).sort();
+        const insert = this.db.prepare(`
+            INSERT INTO workspace_sync_task_taxonomy_ownership (
+                tenant_id, workspace_id, task_id, created_at
+            ) VALUES (?, ?, ?, ?)
+            ON CONFLICT (tenant_id, workspace_id, task_id) DO NOTHING
+        `);
+        for (const taskId of taskIds)
+            insert.run(tenantId, workspaceId, taskId, now);
+    }
+    listTaskTaxonomyProjectionOwnership(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const taskIds = Array.from(new Set(input.taskIds.map((taskId) => requireText(taskId, 'Task id')))).sort();
+        if (taskIds.length === 0)
+            return [];
+        const placeholders = taskIds.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+            WITH ownership AS (
+                SELECT task_id, 0 AS active_operation, 1 AS owned
+                FROM workspace_sync_task_taxonomy_ownership
+                WHERE tenant_id = ? AND workspace_id = ?
+                  AND task_id IN (${placeholders})
+                UNION ALL
+                SELECT target.entity_id AS task_id, 1 AS active_operation, 0 AS owned
+                FROM workspace_sync_outbox_targets AS target
+                INNER JOIN workspace_sync_outbox AS outbox
+                  ON outbox.tenant_id = target.tenant_id
+                 AND outbox.workspace_id = target.workspace_id
+                 AND outbox.client_id = target.client_id
+                 AND outbox.operation_id = target.operation_id
+                WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+                  AND outbox.contract_version = ?
+                  AND outbox.status IN ('pending', 'in_flight', 'blocked')
+                  AND target.domain = 'task' AND target.mutation_kind = 'taxonomy-remap'
+                  AND target.entity_id IN (${placeholders})
+            )
+            SELECT task_id, MAX(active_operation) AS active_operation, MAX(owned) AS owned
+            FROM ownership
+            GROUP BY task_id
+            ORDER BY task_id
+        `).all(tenantId, workspaceId, ...taskIds, tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, ...taskIds);
+        return rows.map((row) => ({
+            taskId: requireText(row.task_id, 'Task id'),
+            activeOperation: Number(row.active_operation) === 1,
+            owned: Number(row.owned) === 1,
+        }));
+    }
+    listOutboxTargets(identity) {
+        const ids = operationParams(identity);
+        const rows = this.db.prepare(`
+            SELECT domain, entity_id, mutation_kind,
+                   CAST(base_entity_revision AS TEXT) AS base_entity_revision,
+                   CAST(base_lifecycle_revision AS TEXT) AS base_lifecycle_revision,
+                   owns_task_metadata, owns_task_lifecycle, owns_task_assignee
+            FROM workspace_sync_outbox_targets
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+            ORDER BY domain, entity_id
+        `).all(...ids);
+        return rows.map((row) => ({
+            domain: requireText(row.domain, 'Outbox target domain'),
+            entityId: requireText(row.entity_id, 'Outbox target entity id'),
+            mutationKind: requireText(row.mutation_kind, 'Outbox target mutation kind'),
+            baseEntityRevision: normalizeSequence(row.base_entity_revision),
+            baseLifecycleRevision: normalizeSequence(row.base_lifecycle_revision),
+            ownsTaskMetadata: Number(row.owns_task_metadata) === 1,
+            ownsTaskLifecycle: Number(row.owns_task_lifecycle) === 1,
+            ownsTaskAssignee: Number(row.owns_task_assignee) === 1,
+        }));
+    }
+    runTaskMetadataCoexistenceTransaction(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const taskIds = Array.from(new Set(input.taskIds.map((taskId) => requireText(taskId, 'Task id')))).sort();
+        return this.runWorkspaceDomainCoexistenceTransaction({
+            tenantId,
+            workspaceId,
+            direction: input.direction,
+            targets: taskIds.map((entityId) => ({ domain: 'task', entityId })),
+            now: input.now,
+            apply: () => input.apply(this.listTaskMetadataOwnership({ tenantId, workspaceId })),
+        });
+    }
+    runWorkspaceDomainCoexistenceTransaction(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Coexistence lock timestamp');
+        const targets = normalizeWorkspaceSyncLockTargets(input.targets);
+        const localTargets = normalizeWorkspaceSyncLockTargets([
+            ...targets,
+            ...(targets.some((target) => target.domain === 'initiative') ? [
+                { domain: 'initiative-assets', entityId: '__workspace__' },
+                { domain: 'initiative-owners', entityId: '__workspace__' },
+            ] : []),
+            ...(targets.some((target) => target.domain === 'workstream') ? [
+                { domain: 'workstream-assets', entityId: '__workspace__' },
+                { domain: 'workstream-owners', entityId: '__workspace__' },
+            ] : []),
+        ]);
+        return this.db.transaction(() => {
+            if (input.direction === 'cloud-push') {
+                // Cloud acceptance uses this row as the workspace-wide journal
+                // serialization lock. A zero-width allocation acquires the same
+                // lock without consuming a sequence.
+                this.allocateSequenceRange(tenantId, workspaceId, now, 0);
+            }
+            else {
+                // Local capture locks the same per-entity rows. Stable ordering
+                // avoids deadlocks when one legacy page contains several domains.
+                const lock = this.db.prepare(`
+                    INSERT INTO workspace_sync_domain_locks (tenant_id, workspace_id, domain, updated_at)
+                    VALUES (?, ?, ?, ?)
+                    ON CONFLICT (tenant_id, workspace_id, domain) DO UPDATE SET updated_at = excluded.updated_at
+                `);
+                if (requiresInitiativeProjectionLock(targets)) {
+                    lock.run(tenantId, workspaceId, WORKSPACE_SYNC_INITIATIVE_PROJECTION_LOCK, now);
+                }
+                if (requiresCombinedProjectionLock(targets)) {
+                    lock.run(tenantId, workspaceId, WORKSPACE_SYNC_COMBINED_PROJECTION_LOCK, now);
+                }
+                for (const target of localTargets) {
+                    lock.run(tenantId, workspaceId, `local-outbox:${target.domain}:${target.entityId}`, now);
+                }
+            }
+            return input.apply();
+        })();
+    }
+    requeueLegacyPlanningAttachmentAcknowledgements(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                last_error_code = 'WORKSPACE_SYNC_PLANNING_ATTACHMENT_ACK_RECOVERY',
+                last_error_message = 'Requeued after the compact planning attachment activity contract was repaired.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND mutation_kind = 'metadata-update'
+              AND last_error_code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID'
+              AND (
+                (domain = 'initiative' AND last_error_message = 'Initiative attachment link semantics are invalid.')
+                OR (domain = 'workstream' AND last_error_message = 'Workstream attachment link semantics are invalid.')
+              )
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    requeueSupersededTaskAttachmentReferenceMetadataConflicts(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', attempt_count = 0, rebase_before_first_attempt = 1,
+                next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                task_attachment_reference_metadata_recovery_count =
+                    task_attachment_reference_metadata_recovery_count + 1,
+                last_error_code = 'WORKSPACE_SYNC_TASK_ATTACHMENT_REFERENCE_METADATA_RECOVERY',
+                last_error_message = 'Requeued against the current attachment-link revision after cloud writers began canonicalizing reference metadata by stable asset identity.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND domain = 'task-attachment-links' AND mutation_kind = 'replace'
+              AND (
+                (
+                  task_attachment_reference_metadata_recovery_count = 0
+                  AND last_error_code = 'TASK_ATTACHMENT_LINKS_INVALID'
+                  AND last_error_message LIKE 'Task attachment reference metadata does not match asset %.%'
+                )
+                OR (
+                  task_attachment_reference_metadata_recovery_count = 1
+                  AND rebase_before_first_attempt = 0
+                  AND last_error_code = 'WORKSPACE_SYNC_REVISION_CONFLICT'
+                )
+              )
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    requeueSupersededOriginDispatchAuthorizationFailures(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?,
+                lease_owner = NULL, lease_expires_at = NULL,
+                origin_assertion_recovery_count = origin_assertion_recovery_count + 1,
+                last_error_code = 'WORKSPACE_SYNC_ORIGIN_ASSERTION_UPGRADE_RECOVERY',
+                last_error_message = 'Requeued after signed origin assertions replaced the legacy local-dispatch trust header.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ?
+              AND status = 'blocked'
+              AND origin_assertion_recovery_count = 0
+              AND last_error_code = 'WORKSPACE_SYNC_V3_REQUEST_INVALID'
+              AND last_error_message = 'originActor is only accepted from trusted local durable dispatch.'
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    requeueSupersededTaskCreateChecklistAcknowledgements(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                last_error_code = 'WORKSPACE_SYNC_TASK_CREATE_CHECKLIST_ACK_RECOVERY',
+                last_error_message = 'Requeued after task create acknowledgement began checking the captured checklist.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND domain = 'task' AND mutation_kind = 'create'
+              AND last_error_code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID'
+              AND last_error_message = 'Authoritative task create response omitted the captured checklist projection.'
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    requeueInitialTaskCreateRouteMisses(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                last_error_code = 'WORKSPACE_SYNC_TASK_CREATE_ROUTE_RECOVERY',
+                last_error_message = 'Requeued once after the initial task create route was unavailable.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND domain = 'task' AND mutation_kind = 'create'
+              AND attempt_count = 1
+              AND last_error_code = 'WORKSPACE_SYNC_TRANSPORT_404'
+              AND last_error_message = 'Not Found'
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    requeueSupersededTaskCommentReconciliationConflicts(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                last_error_code = 'WORKSPACE_SYNC_TASK_COMMENT_RECONCILIATION_RECOVERY',
+                last_error_message = 'Requeued once after task-comment reconciliation became revision-independent.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND domain = 'task-comments' AND mutation_kind = 'reconcile'
+              AND attempt_count = 1
+              AND last_error_code = 'WORKSPACE_SYNC_REVISION_CONFLICT'
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    requeueTaskCommentRootAcknowledgementConflicts(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?,
+                lease_owner = NULL, lease_expires_at = NULL,
+                accepted_replay_recovery_count = accepted_replay_recovery_count + 1,
+                last_error_code = 'WORKSPACE_SYNC_TASK_COMMENT_ROOT_ACK_RECOVERY',
+                last_error_message = 'Requeued once after task-comment acknowledgement stopped reinstalling unrelated task-root metadata.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ?
+              AND contract_version = ?
+              AND status = 'blocked'
+              AND domain = 'task-comments' AND mutation_kind = 'append'
+              AND last_error_code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID'
+              AND last_error_message = 'Authoritative task root differs outside the comment mutation.'
+              AND accepted_replay_recovery_count = 1
+              AND recovery_batch_id IS NULL
+        `).run(now, now, tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION);
+        return Number(result.changes || 0);
+    }
+    requeueBoundedTaskStatusRevisionConflicts(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', attempt_count = 0, rebase_before_first_attempt = 1,
+                next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                task_status_revision_rebase_count = task_status_revision_rebase_count + 1,
+                last_error_code = 'WORKSPACE_SYNC_TASK_STATUS_REVISION_REBASE',
+                last_error_message = 'Requeued once against the current task revision after an initial conflict.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND domain = 'task' AND mutation_kind = 'set-status'
+              AND attempt_count = 1
+              AND task_status_revision_rebase_count < 1
+              AND last_error_code = 'WORKSPACE_SYNC_REVISION_CONFLICT'
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    // Workstream/initiative attachment-only metadata patches are Partial<>
+    // merges, not full snapshots. The cloud accepts those patches against its
+    // current revision, so this bounded retry can preserve unrelated concurrent
+    // metadata. Other metadata patches remain exact-revision operations: this
+    // selector may retry one once, but the cloud will reject it again rather
+    // than allowing a stale title or structural edit to overwrite newer state.
+    requeueBoundedWorkstreamMetadataRevisionConflicts(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', attempt_count = 0, rebase_before_first_attempt = 1,
+                next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                workstream_metadata_revision_rebase_count = workstream_metadata_revision_rebase_count + 1,
+                last_error_code = 'WORKSPACE_SYNC_WORKSTREAM_METADATA_REVISION_REBASE',
+                last_error_message = 'Requeued once against the current workstream revision after an initial conflict.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND domain = 'workstream' AND mutation_kind = 'metadata-update'
+              AND attempt_count = 1
+              AND workstream_metadata_revision_rebase_count < 1
+              AND last_error_code = 'WORKSPACE_SYNC_REVISION_CONFLICT'
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    requeueBoundedInitiativeMetadataRevisionConflicts(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', attempt_count = 0, rebase_before_first_attempt = 1,
+                next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                initiative_metadata_revision_rebase_count = initiative_metadata_revision_rebase_count + 1,
+                last_error_code = 'WORKSPACE_SYNC_INITIATIVE_METADATA_REVISION_REBASE',
+                last_error_message = 'Requeued once against the current initiative revision after an initial conflict.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND domain = 'initiative' AND mutation_kind = 'metadata-update'
+              AND attempt_count = 1
+              AND initiative_metadata_revision_rebase_count < 1
+              AND last_error_code = 'WORKSPACE_SYNC_REVISION_CONFLICT'
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    requeueTaskCommentProvenanceReconciliationConflicts(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                last_error_code = 'WORKSPACE_SYNC_TASK_COMMENT_PROVENANCE_RECOVERY',
+                last_error_message = 'Requeued once after reconciliation began adopting authoritative comment provenance.',
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+              AND domain = 'task-comments' AND mutation_kind = 'reconcile'
+              AND attempt_count = 1
+              AND (
+                  (
+                      last_error_code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID'
+                      AND last_error_message LIKE 'Task comment identity conflict:%'
+                  )
+                  OR (
+                      last_error_code = 'TASK_COMMENT_IDENTITY_CONFLICT'
+                      AND last_error_message = 'Task comment identity conflict: reconciliation cannot change an authoritative comment.'
+                  )
+              )
+        `).run(now, now, tenantId, workspaceId);
+        return Number(result.changes || 0);
+    }
+    supersedeArchivedReadOnlyTaskRecoveryIntents(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        return this.db.transaction(() => {
+            const rows = this.db.prepare(`
+                SELECT client_id, operation_id, entity_id, mutation_kind,
+                       payload_json, recovery_batch_id
+                FROM workspace_sync_outbox
+                WHERE tenant_id = ? AND workspace_id = ?
+                  AND status = 'blocked'
+                  AND recovery_batch_id IS NOT NULL
+                  AND replay_of_operation_id IS NOT NULL
+                  AND domain = 'task'
+                  AND last_error_code = 'TASK_ARCHIVED_READ_ONLY'
+                ORDER BY enqueue_sequence, created_at, operation_id
+                ${this.db.provider === 'postgres' ? 'FOR UPDATE' : ''}
+            `).all(tenantId, workspaceId);
+            let superseded = 0;
+            const affectedRecoveryBatchIds = new Set();
+            const supersededEntities = new Set();
+            for (const row of rows) {
+                const taskId = requireText(row.entity_id, 'Task id');
+                if (!input.isTaskArchived(taskId))
+                    continue;
+                const recoveryBatchId = requireText(row.recovery_batch_id, 'Recovery batch id');
+                const recoveryEntityKey = `${recoveryBatchId}\u0000${taskId}`;
+                if (!supersededEntities.has(recoveryEntityKey)) {
+                    const lifecyclePrecedence = this.db.prepare(`
+                        SELECT current.lifecycle_revision,
+                               COUNT(*) AS unsettled_count,
+                               SUM(CASE WHEN replay.status = 'in_flight' THEN 1 ELSE 0 END)
+                                   AS in_flight_count,
+                               SUM(CASE
+                                   WHEN source.base_lifecycle_revision < current.lifecycle_revision
+                                   THEN 0 ELSE 1
+                               END) AS not_predating_count
+                        FROM workspace_sync_outbox AS replay
+                        INNER JOIN workspace_sync_outbox AS source
+                          ON source.tenant_id = replay.tenant_id
+                         AND source.workspace_id = replay.workspace_id
+                         AND source.client_id = replay.replay_of_client_id
+                         AND source.operation_id = replay.replay_of_operation_id
+                        INNER JOIN workspace_sync_entity_revisions AS current
+                          ON current.tenant_id = replay.tenant_id
+                         AND current.workspace_id = replay.workspace_id
+                         AND current.domain = replay.domain
+                         AND current.entity_id = replay.entity_id
+                        WHERE replay.tenant_id = ? AND replay.workspace_id = ?
+                          AND replay.recovery_batch_id = ?
+                          AND replay.domain = 'task' AND replay.entity_id = ?
+                          AND replay.replay_of_operation_id IS NOT NULL
+                          AND replay.status IN ('pending', 'blocked', 'in_flight')
+                        GROUP BY current.lifecycle_revision
+                    `).get(tenantId, workspaceId, recoveryBatchId, taskId);
+                    if (Number(lifecyclePrecedence?.lifecycle_revision || 0) > 0
+                        && Number(lifecyclePrecedence?.unsettled_count || 0) > 0
+                        && Number(lifecyclePrecedence?.in_flight_count || 0) === 0
+                        && Number(lifecyclePrecedence?.not_predating_count || 0) === 0) {
+                        const updated = this.db.prepare(`
+                            UPDATE workspace_sync_outbox
+                            SET status = 'superseded',
+                                lease_owner = NULL, lease_expires_at = NULL,
+                                superseded_at = ?,
+                                last_error_code = 'WORKSPACE_SYNC_RECOVERY_INTENT_SUPERSEDED_BY_ARCHIVE',
+                                last_error_message = 'Recovered task intent was superseded because a newer authoritative archive lifecycle revision exists.',
+                                updated_at = ?
+                            WHERE tenant_id = ? AND workspace_id = ?
+                              AND recovery_batch_id = ?
+                              AND domain = 'task' AND entity_id = ?
+                              AND replay_of_operation_id IS NOT NULL
+                              AND status IN ('pending', 'blocked')
+                        `).run(now, now, tenantId, workspaceId, recoveryBatchId, taskId);
+                        const updatedCount = Number(updated.changes || 0);
+                        if (updatedCount > 0) {
+                            superseded += updatedCount;
+                            supersededEntities.add(recoveryEntityKey);
+                            affectedRecoveryBatchIds.add(recoveryBatchId);
+                            continue;
+                        }
+                    }
+                }
+                if (row.mutation_kind !== 'metadata-update')
+                    continue;
+                let payload;
+                try {
+                    payload = JSON.parse(String(row.payload_json || ''));
+                }
+                catch {
+                    continue;
+                }
+                const patch = payload.patch;
+                if (!patch || typeof patch !== 'object' || Array.isArray(patch))
+                    continue;
+                const patchEntries = Object.entries(patch);
+                const assignee = patchEntries[0]?.[1];
+                if (patchEntries.length !== 1
+                    || patchEntries[0][0] !== 'assignee'
+                    || typeof assignee !== 'string'
+                    || !assignee.trim()) {
+                    continue;
+                }
+                const updated = this.db.prepare(`
+                    UPDATE workspace_sync_outbox
+                    SET status = 'superseded',
+                        lease_owner = NULL, lease_expires_at = NULL,
+                        superseded_at = ?,
+                        last_error_code = 'WORKSPACE_SYNC_RECOVERY_INTENT_SUPERSEDED_BY_ARCHIVE',
+                        last_error_message = 'Assignee-only recovery intent was superseded because the task is authoritatively archived.',
+                        updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ?
+                      AND client_id = ? AND operation_id = ?
+                      AND status = 'blocked'
+                      AND last_error_code = 'TASK_ARCHIVED_READ_ONLY'
+                `).run(now, now, tenantId, workspaceId, requireText(row.client_id, 'Client id'), requireText(row.operation_id, 'Operation id'));
+                if (Number(updated.changes || 0) === 1) {
+                    superseded += 1;
+                    affectedRecoveryBatchIds.add(recoveryBatchId);
+                }
+            }
+            for (const recoveryBatchId of affectedRecoveryBatchIds) {
+                const unsettled = this.db.prepare(`
+                    SELECT COUNT(*) AS count
+                    FROM workspace_sync_outbox
+                    WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                      AND replay_of_operation_id IS NOT NULL
+                      AND status NOT IN ('accepted', 'superseded')
+                `).get(tenantId, workspaceId, recoveryBatchId);
+                if (Number(unsettled.count || 0) !== 0)
+                    continue;
+                this.db.prepare(`
+                    UPDATE workspace_sync_outbox_recoveries
+                    SET state = 'completed', completed_at = ?, updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                      AND state = 'replay_queued'
+                      AND EXISTS (
+                          SELECT 1
+                          FROM workspace_sync_outbox
+                          WHERE tenant_id = ? AND workspace_id = ? AND recovery_batch_id = ?
+                            AND replay_of_operation_id IS NOT NULL
+                            AND status = 'superseded'
+                            AND last_error_code = 'WORKSPACE_SYNC_RECOVERY_INTENT_SUPERSEDED_BY_ARCHIVE'
+                      )
+                `).run(now, now, tenantId, workspaceId, recoveryBatchId, tenantId, workspaceId, recoveryBatchId);
+            }
+            return superseded;
+        })();
+    }
+    requeueSupersededTaskStatusWorkflowAcknowledgements(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        return this.db.transaction(() => {
+            const candidates = this.db.prepare(`
+                SELECT client_id, operation_id, payload_json
+                FROM workspace_sync_outbox
+                WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+                  AND domain = 'task' AND mutation_kind = 'set-status'
+                  AND task_status_workflow_ack_recovery_count < 2
+                  AND last_error_code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID'
+                  AND last_error_message = 'Authoritative workflow assignment does not match the persisted request.'
+            `).all(tenantId, workspaceId);
+            let recovered = 0;
+            for (const candidate of candidates) {
+                let payload;
+                try {
+                    payload = JSON.parse(String(candidate.payload_json || ''));
+                }
+                catch {
+                    continue;
+                }
+                if (!['task', 'review', 'done', 'cancelled'].includes(String(payload.status || '')))
+                    continue;
+                const result = this.db.prepare(`
+                    UPDATE workspace_sync_outbox
+                    SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                        task_status_workflow_ack_recovery_count = task_status_workflow_ack_recovery_count + 1,
+                        last_error_code = 'WORKSPACE_SYNC_TASK_STATUS_WORKFLOW_ACK_RECOVERY',
+                        last_error_message = 'Requeued after existing workflow assignment acknowledgement was repaired.',
+                        updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                      AND status = 'blocked'
+                      AND task_status_workflow_ack_recovery_count < 2
+                `).run(now, now, tenantId, workspaceId, requireText(candidate.client_id, 'Client id'), requireText(candidate.operation_id, 'Operation id'));
+                recovered += Number(result.changes || 0);
+            }
+            return recovered;
+        })();
+    }
+    requeueTaskStatusAssigneeAcknowledgements(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        return this.db.transaction(() => {
+            const candidates = this.db.prepare(`
+                SELECT client_id, operation_id, payload_json
+                FROM workspace_sync_outbox
+                WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+                  AND domain = 'task' AND mutation_kind = 'set-status'
+                  AND last_error_code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID'
+                  AND last_error_message = 'Authoritative task assignee does not match the persisted request.'
+            `).all(tenantId, workspaceId);
+            let recovered = 0;
+            for (const candidate of candidates) {
+                let payload;
+                try {
+                    payload = JSON.parse(String(candidate.payload_json || ''));
+                }
+                catch {
+                    continue;
+                }
+                const assigneeIntent = payload.assigneeIntent;
+                if (assigneeIntent?.kind !== 'set' || !String(assigneeIntent.value || '').trim())
+                    continue;
+                const result = this.db.prepare(`
+                    UPDATE workspace_sync_outbox
+                    SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                        last_error_code = 'WORKSPACE_SYNC_TASK_STATUS_ASSIGNEE_ACK_RECOVERY',
+                        last_error_message = 'Requeued after task status acknowledgement began validating the durable assignee intent.',
+                        updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                      AND status = 'blocked'
+                `).run(now, now, tenantId, workspaceId, requireText(candidate.client_id, 'Client id'), requireText(candidate.operation_id, 'Operation id'));
+                recovered += Number(result.changes || 0);
+            }
+            return recovered;
+        })();
+    }
+    requeueTaskStatusWorkflowHistoryAcknowledgements(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const now = requireIsoTimestamp(input.now, 'Recovery time');
+        return this.db.transaction(() => {
+            const candidates = this.db.prepare(`
+                SELECT client_id, operation_id, payload_json
+                FROM workspace_sync_outbox
+                WHERE tenant_id = ? AND workspace_id = ? AND status = 'blocked'
+                  AND domain = 'task' AND mutation_kind = 'set-status'
+                  AND recovery_batch_id IS NOT NULL
+                  AND replay_of_operation_id IS NOT NULL
+                  AND attempt_count = 1
+                  AND last_error_code = 'WORKFLOW_ASSIGNMENT_SYNC_CONFLICT'
+                  AND last_error_message = 'Workflow assignment history conflicts with canonical storage.'
+            `).all(tenantId, workspaceId);
+            let recovered = 0;
+            for (const candidate of candidates) {
+                let payload;
+                try {
+                    payload = JSON.parse(String(candidate.payload_json || ''));
+                }
+                catch {
+                    continue;
+                }
+                if (payload.workflowAssignment != null)
+                    continue;
+                const result = this.db.prepare(`
+                    UPDATE workspace_sync_outbox
+                    SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                        last_error_code = 'WORKSPACE_SYNC_TASK_STATUS_WORKFLOW_HISTORY_ACK_RECOVERY',
+                        last_error_message = 'Requeued after exact-prefix cloud workflow history preservation was enabled.',
+                        updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                      AND status = 'blocked'
+                      AND recovery_batch_id IS NOT NULL
+                      AND replay_of_operation_id IS NOT NULL
+                      AND attempt_count = 1
+                      AND last_error_code = 'WORKFLOW_ASSIGNMENT_SYNC_CONFLICT'
+                      AND last_error_message = 'Workflow assignment history conflicts with canonical storage.'
+                `).run(now, now, tenantId, workspaceId, requireText(candidate.client_id, 'Client id'), requireText(candidate.operation_id, 'Operation id'));
+                recovered += Number(result.changes || 0);
+            }
+            return recovered;
+        })();
+    }
+    claimOutbox(input) {
+        const tenantId = requireText(input.tenantId, 'Tenant id');
+        const workspaceId = requireText(input.workspaceId, 'Workspace id');
+        const leaseOwner = requireText(input.leaseOwner || randomUUID(), 'Lease owner');
+        const now = requireIsoTimestamp(input.now, 'Claim time');
+        const leaseExpiresAt = requireIsoTimestamp(input.leaseExpiresAt, 'Lease expiry');
+        if (leaseExpiresAt <= now)
+            throw new Error('Lease expiry must be after the claim time.');
+        const limit = Math.max(1, Math.min(100, Math.floor(Number(input.limit) || 0)));
+        const dispatchClasses = (input.dispatchClasses || []).map(requireOutboxDispatchClass);
+        const dispatchClassFilter = dispatchClasses.length > 0
+            ? `AND outbox.dispatch_class IN (${dispatchClasses.map(() => '?').join(', ')})`
+            : '';
+        const records = this.db.transaction(() => {
+            const futureDeadline = new Date(Date.parse(now) + MAX_OUTBOX_FUTURE_DEADLINE_MS).toISOString();
+            // A corrected fast local clock must not strand an operation for years.
+            // Legitimate dispatcher and server retry deadlines are capped at 24h.
+            this.db.prepare(`
+                UPDATE workspace_sync_outbox
+                SET next_attempt_at = ?, updated_at = ?,
+                    last_error_code = 'WORKSPACE_SYNC_CLOCK_RECOVERY',
+                    last_error_message = 'Recovered an implausible future retry deadline after a local clock correction.'
+                WHERE tenant_id = ? AND workspace_id = ? AND status = 'pending'
+                  AND next_attempt_at > ?
+            `).run(now, now, tenantId, workspaceId, futureDeadline);
+            this.db.prepare(`
+                UPDATE workspace_sync_outbox
+                SET status = 'pending', next_attempt_at = ?, lease_owner = NULL, lease_expires_at = NULL,
+                    updated_at = ?, last_error_code = 'WORKSPACE_SYNC_CLOCK_RECOVERY',
+                    last_error_message = 'Recovered an implausible future lease after a local clock correction.'
+                WHERE tenant_id = ? AND workspace_id = ? AND status = 'in_flight'
+                  AND lease_expires_at > ?
+            `).run(now, now, tenantId, workspaceId, futureDeadline);
+            const candidates = this.db.prepare(`
+                SELECT outbox.client_id, outbox.operation_id
+                FROM workspace_sync_outbox AS outbox
+                WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+                  AND ((outbox.status = 'pending' AND outbox.next_attempt_at <= ?)
+                    OR (outbox.status = 'in_flight' AND outbox.lease_expires_at <= ?))
+                  ${dispatchClassFilter}
+                  AND NOT EXISTS (
+                    SELECT 1 FROM workspace_sync_outbox AS earlier
+                    WHERE earlier.tenant_id = outbox.tenant_id
+                      AND earlier.workspace_id = outbox.workspace_id
+                      AND earlier.status IN ('pending', 'in_flight', 'blocked')
+                      AND EXISTS (
+                        SELECT 1
+                        FROM workspace_sync_outbox_targets AS earlier_target
+                        INNER JOIN workspace_sync_outbox_targets AS candidate_target
+                          ON candidate_target.tenant_id = earlier_target.tenant_id
+                         AND candidate_target.workspace_id = earlier_target.workspace_id
+                         AND candidate_target.domain = earlier_target.domain
+                         AND candidate_target.entity_id = earlier_target.entity_id
+                        WHERE earlier_target.tenant_id = earlier.tenant_id
+                          AND earlier_target.workspace_id = earlier.workspace_id
+                          AND earlier_target.client_id = earlier.client_id
+                          AND earlier_target.operation_id = earlier.operation_id
+                          AND candidate_target.client_id = outbox.client_id
+                          AND candidate_target.operation_id = outbox.operation_id
+                      )
+                      AND (
+                        earlier.enqueue_sequence < outbox.enqueue_sequence
+                        OR (earlier.enqueue_sequence = outbox.enqueue_sequence
+                          AND (earlier.created_at < outbox.created_at
+                            OR (earlier.created_at = outbox.created_at
+                              AND earlier.operation_id < outbox.operation_id)))
+                      )
+                  )
+                ORDER BY outbox.next_attempt_at ASC, outbox.enqueue_sequence ASC,
+                         outbox.created_at ASC, outbox.operation_id ASC
+                LIMIT ?
+            `).all(tenantId, workspaceId, now, now, ...dispatchClasses, limit);
+            const claimed = [];
+            for (const candidate of candidates) {
+                const clientId = requireText(candidate.client_id, 'Client id');
+                const operationId = requireText(candidate.operation_id, 'Operation id');
+                const queued = this.db.prepare(`
+                    SELECT domain, entity_id, attempt_count, rebase_before_first_attempt
+                    FROM workspace_sync_outbox
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                `).get(tenantId, workspaceId, clientId, operationId);
+                if (!queued)
+                    continue;
+                if (Number(queued.rebase_before_first_attempt) === 1 && Number(queued.attempt_count) === 0) {
+                    const queuedDomain = requireText(queued.domain, 'Queued domain');
+                    const queuedEntityId = requireText(queued.entity_id, 'Queued entity id');
+                    const targets = this.db.prepare(`
+                        SELECT domain, entity_id
+                        FROM workspace_sync_outbox_targets
+                        WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                        ORDER BY domain, entity_id
+                    `).all(tenantId, workspaceId, clientId, operationId);
+                    let rebasedEntityRevision = '0';
+                    let rebasedLifecycleRevision = '0';
+                    for (const target of targets) {
+                        const targetDomain = requireText(target.domain, 'Queued target domain');
+                        const targetEntityId = requireText(target.entity_id, 'Queued target entity id');
+                        const revision = this.db.prepare(`
+                            SELECT CAST(entity_revision AS TEXT) AS entity_revision,
+                                   CAST(lifecycle_revision AS TEXT) AS lifecycle_revision
+                            FROM workspace_sync_entity_revisions
+                            WHERE tenant_id = ? AND workspace_id = ? AND contract_version = ?
+                              AND domain = ? AND entity_id = ?
+                        `).get(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION, targetDomain, targetEntityId);
+                        const targetEntityRevision = normalizeSequence(revision?.entity_revision ?? 0);
+                        const targetLifecycleRevision = normalizeSequence(revision?.lifecycle_revision ?? 0);
+                        this.db.prepare(`
+                            UPDATE workspace_sync_outbox_targets
+                            SET base_entity_revision = ?, base_lifecycle_revision = ?
+                            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                              AND domain = ? AND entity_id = ?
+                        `).run(targetEntityRevision, targetLifecycleRevision, tenantId, workspaceId, clientId, operationId, targetDomain, targetEntityId);
+                        if (targetDomain === queuedDomain && targetEntityId === queuedEntityId) {
+                            rebasedEntityRevision = targetEntityRevision;
+                            rebasedLifecycleRevision = targetLifecycleRevision;
+                        }
+                    }
+                    this.db.prepare(`
+                        UPDATE workspace_sync_outbox
+                        SET base_entity_revision = ?, base_lifecycle_revision = ?,
+                            rebase_before_first_attempt = 0, updated_at = ?
+                        WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                          AND status = 'pending' AND attempt_count = 0
+                    `).run(rebasedEntityRevision, rebasedLifecycleRevision, now, tenantId, workspaceId, clientId, operationId);
+                }
+                const updated = this.db.prepare(`
+                    UPDATE workspace_sync_outbox
+                    SET status = 'in_flight', attempt_count = attempt_count + 1,
+                        lease_owner = ?, lease_expires_at = ?, updated_at = ?
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                      AND ((status = 'pending' AND next_attempt_at <= ?)
+                        OR (status = 'in_flight' AND lease_expires_at <= ?))
+                `).run(leaseOwner, leaseExpiresAt, now, tenantId, workspaceId, clientId, operationId, now, now);
+                if (Number(updated.changes || 0) === 1)
+                    claimed.push({ clientId, operationId });
+            }
+            return claimed.map(({ clientId, operationId }) => {
+                const row = this.db.prepare(`
+                    SELECT tenant_id, workspace_id, client_id, operation_id, dispatch_class, domain, entity_id,
+                           mutation_kind, owns_task_metadata, owns_task_lifecycle, owns_task_assignee,
+                           CAST(base_entity_revision AS TEXT) AS base_entity_revision,
+                           CAST(base_lifecycle_revision AS TEXT) AS base_lifecycle_revision,
+                           payload_json, payload_fingerprint, status, attempt_count,
+                           initial_not_found_attempt_count,
+                           CAST(enqueue_sequence AS TEXT) AS enqueue_sequence,
+                           rebase_before_first_attempt,
+                           workstream_metadata_revision_rebase_count,
+                           initiative_metadata_revision_rebase_count,
+                           lease_owner, lease_expires_at
+                    FROM workspace_sync_outbox
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                      AND status = 'in_flight' AND lease_owner = ?
+                `).get(tenantId, workspaceId, clientId, operationId, leaseOwner);
+                if (!row)
+                    throw new WorkspaceSyncLeaseLostError();
+                return this.mapOutboxRow(row);
+            });
+        })();
+        return { leaseOwner, records };
+    }
+    releaseOutboxClaim(input) {
+        const ids = operationParams(input.identity);
+        const leaseOwner = requireText(input.leaseOwner, 'Lease owner');
+        const now = requireIsoTimestamp(input.now, 'Release time');
+        const nextAttemptAt = requireIsoTimestamp(input.nextAttemptAt, 'Next attempt time');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'pending', next_attempt_at = ?, lease_owner = NULL,
+                lease_expires_at = NULL, last_error_code = ?, last_error_message = ?,
+                initial_not_found_attempt_count = initial_not_found_attempt_count + ?, updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+              AND status = 'in_flight' AND lease_owner = ? AND lease_expires_at > ?
+        `).run(nextAttemptAt, input.errorCode ?? null, input.errorMessage ?? null, input.incrementInitialNotFoundAttemptCount === true ? 1 : 0, now, ...ids, leaseOwner, now);
+        if (Number(result.changes || 0) !== 1)
+            throw new WorkspaceSyncLeaseLostError();
+    }
+    blockOutboxClaim(input) {
+        const ids = operationParams(input.identity);
+        const leaseOwner = requireText(input.leaseOwner, 'Lease owner');
+        const now = requireIsoTimestamp(input.now, 'Block time');
+        const errorCode = requireText(input.errorCode, 'Error code');
+        const errorMessage = requireText(input.errorMessage, 'Error message');
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_outbox
+            SET status = 'blocked', lease_owner = NULL, lease_expires_at = NULL,
+                last_error_code = ?, last_error_message = ?, updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+              AND status = 'in_flight' AND lease_owner = ? AND lease_expires_at > ?
+        `).run(errorCode, errorMessage, now, ...ids, leaseOwner, now);
+        if (Number(result.changes || 0) !== 1)
+            throw new WorkspaceSyncLeaseLostError();
+    }
+    applyAuthoritativeAndAck(input) {
+        const ids = operationParams(input.identity);
+        const leaseOwner = requireText(input.leaseOwner, 'Lease owner');
+        const now = requireIsoTimestamp(input.now, 'Acknowledgement time');
+        const responseJson = canonicalWorkspaceSyncJson(input.response);
+        const acceptedSequence = normalizeSequence(input.acceptedSequence);
+        const rawAuthoritative = input.authoritative
+            ? (Array.isArray(input.authoritative) ? input.authoritative : [input.authoritative])
+            : [];
+        const authoritative = rawAuthoritative.map((entry) => ({
+            domain: requireText(entry.domain, 'Authoritative domain'),
+            entityId: requireText(entry.entityId, 'Authoritative entity id'),
+            mutationKind: requireText(entry.mutationKind, 'Authoritative mutation kind'),
+            entityRevision: normalizeSequence(entry.entityRevision),
+            lifecycleRevision: normalizeSequence(entry.lifecycleRevision),
+            sequence: normalizeSequence(entry.sequence),
+            canonicalFingerprint: requireText(entry.canonicalFingerprint, 'Authoritative canonical fingerprint'),
+            metadataOwned: entry.metadataOwned === true,
+            reopenAssigneeOwned: entry.reopenAssigneeOwned === true,
+            allowAuthoritativeRevisionReset: entry.allowAuthoritativeRevisionReset === true,
+        }));
+        for (const entry of authoritative) {
+            if (entry.allowAuthoritativeRevisionReset
+                && (entry.domain !== 'task-comments' || entry.mutationKind !== 'reconcile')) {
+                throw new Error('Authoritative revision reset is reserved for task-comment reconciliation.');
+            }
+        }
+        const authoritativeKeys = new Set(authoritative.map((entry) => `${entry.domain}\u0000${entry.entityId}`));
+        const authoritativeSequences = new Set(authoritative.map((entry) => entry.sequence));
+        const expectedFirstSequence = BigInt(acceptedSequence) - BigInt(Math.max(0, authoritative.length - 1));
+        const sortedSequences = authoritative
+            .map((entry) => BigInt(entry.sequence))
+            .sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+        const hasContiguousSequenceRange = sortedSequences.every((sequence, index) => sequence === expectedFirstSequence + BigInt(index));
+        if (authoritativeKeys.size !== authoritative.length
+            || authoritativeSequences.size !== authoritative.length
+            || (authoritative.length > 0 && (!hasContiguousSequenceRange || expectedFirstSequence < 0n))) {
+            throw new Error('Authoritative revisions must be distinct and cover the accepted contiguous sequence range.');
+        }
+        return this.db.transaction(() => {
+            if (authoritative.length > 0) {
+                const lock = this.db.prepare(`
+                    INSERT INTO workspace_sync_domain_locks (tenant_id, workspace_id, domain, updated_at)
+                    VALUES (?, ?, ?, ?)
+                    ON CONFLICT (tenant_id, workspace_id, domain) DO UPDATE SET updated_at = excluded.updated_at
+                `);
+                if (requiresInitiativeProjectionLock(authoritative)) {
+                    lock.run(ids[0], ids[1], WORKSPACE_SYNC_INITIATIVE_PROJECTION_LOCK, now);
+                }
+                if (requiresCombinedProjectionLock(authoritative)) {
+                    lock.run(ids[0], ids[1], WORKSPACE_SYNC_COMBINED_PROJECTION_LOCK, now);
+                }
+                for (const entry of normalizeWorkspaceSyncLockTargets(authoritative)) {
+                    lock.run(ids[0], ids[1], `local-outbox:${entry.domain}:${entry.entityId}`, now);
+                }
+            }
+            const owned = this.db.prepare(`
+                UPDATE workspace_sync_outbox SET updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                  AND status = 'in_flight' AND lease_owner = ? AND lease_expires_at > ?
+            `).run(now, ...ids, leaseOwner, now);
+            if (Number(owned.changes || 0) !== 1)
+                throw new WorkspaceSyncLeaseLostError();
+            if (authoritative.length > 0) {
+                const outbox = this.db.prepare(`
+                    SELECT domain, entity_id, mutation_kind FROM workspace_sync_outbox
+                    WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                      AND status = 'in_flight' AND lease_owner = ?
+                `).get(...ids, leaseOwner);
+                const root = authoritative.find((entry) => (entry.domain === outbox?.domain
+                    && entry.entityId === outbox?.entity_id
+                    && entry.mutationKind === outbox?.mutation_kind));
+                if (!root) {
+                    throw new WorkspaceSyncIdempotencyConflictError();
+                }
+                const readCurrentRevision = this.db.prepare(`
+                    SELECT CAST(entity_revision AS TEXT) AS entity_revision,
+                           CAST(lifecycle_revision AS TEXT) AS lifecycle_revision,
+                           CAST(last_sequence AS TEXT) AS last_sequence
+                    FROM workspace_sync_entity_revisions
+                    WHERE tenant_id = ? AND workspace_id = ? AND domain = ? AND entity_id = ?
+                `);
+                for (const entry of authoritative) {
+                    const currentRevision = readCurrentRevision.get(ids[0], ids[1], entry.domain, entry.entityId);
+                    if ((!entry.allowAuthoritativeRevisionReset && (BigInt(entry.entityRevision) < BigInt(normalizeSequence(currentRevision?.entity_revision ?? 0))
+                        || BigInt(entry.lifecycleRevision)
+                            < BigInt(normalizeSequence(currentRevision?.lifecycle_revision ?? 0))))
+                        || BigInt(entry.sequence) < BigInt(normalizeSequence(currentRevision?.last_sequence ?? 0))) {
+                        throw new WorkspaceSyncRevisionConflictError();
+                    }
+                }
+            }
+            const result = input.applyAuthoritative();
+            if (authoritative.length > 0) {
+                const upsertRevision = this.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 (?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?)
+                    ON CONFLICT (tenant_id, workspace_id, domain, entity_id) DO UPDATE SET
+                        contract_version = excluded.contract_version,
+                        entity_revision = excluded.entity_revision,
+                        lifecycle_revision = excluded.lifecycle_revision,
+                        coexistence_owned = 1,
+                        metadata_owned = CASE
+                            WHEN excluded.metadata_owned = 1 THEN 1
+                            ELSE workspace_sync_entity_revisions.metadata_owned
+                        END,
+                        reopen_assignee_owned = CASE
+                            WHEN excluded.reopen_assignee_owned = 1 THEN 1
+                            ELSE workspace_sync_entity_revisions.reopen_assignee_owned
+                        END,
+                        last_sequence = excluded.last_sequence,
+                        canonical_fingerprint = excluded.canonical_fingerprint,
+                        updated_at = excluded.updated_at
+                `);
+                for (const entry of authoritative) {
+                    upsertRevision.run(ids[0], ids[1], entry.domain, entry.entityId, WORKSPACE_SYNC_CONTRACT_VERSION, entry.entityRevision, entry.lifecycleRevision, entry.domain === 'task' && (entry.mutationKind === 'metadata-update'
+                        || entry.mutationKind === 'create'
+                        || entry.metadataOwned === true) ? 1 : 0, entry.domain === 'task' && entry.reopenAssigneeOwned === true ? 1 : 0, entry.sequence, entry.canonicalFingerprint, now);
+                }
+            }
+            const acked = this.db.prepare(`
+                UPDATE workspace_sync_outbox
+                SET status = 'accepted', authoritative_response_json = ?, accepted_sequence = ?,
+                    lease_owner = NULL, lease_expires_at = NULL,
+                    last_error_code = NULL, last_error_message = NULL, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+                  AND status = 'in_flight' AND lease_owner = ? AND lease_expires_at > ?
+            `).run(responseJson, acceptedSequence, now, ...ids, leaseOwner, now);
+            if (Number(acked.changes || 0) !== 1)
+                throw new WorkspaceSyncLeaseLostError();
+            return result;
+        })();
+    }
+    isTargetStateLifecycleConflict(source) {
+        const mutationKind = String(source.mutation_kind || '');
+        const errorCode = String(source.last_error_code || '');
+        if (mutationKind === 'archive' && errorCode === 'TASK_LIFECYCLE_ALREADY_ARCHIVED')
+            return true;
+        if (mutationKind === 'unarchive' && errorCode === 'TASK_LIFECYCLE_NOT_ARCHIVED')
+            return true;
+        if (errorCode !== 'TASK_LIFECYCLE_STATE_CONFLICT')
+            return false;
+        const legacyMessage = String(source.last_error_message || '');
+        // Persisted pre-0.3.327 rows used one overloaded code. Exact legacy
+        // messages are recognized only to drain already-blocked recoveries;
+        // new writes use the typed codes above.
+        return (mutationKind === 'archive' && legacyMessage === 'Task is already archived.')
+            || (mutationKind === 'unarchive' && legacyMessage === 'Task is not archived.');
+    }
+    isTaskLifecycleRecoveryIntentSatisfied(tenantId, workspaceId, source) {
+        const mutationKind = String(source.mutation_kind || '');
+        if (mutationKind !== 'archive' && mutationKind !== 'unarchive')
+            return false;
+        let payload;
+        try {
+            payload = JSON.parse(String(source.payload_json || ''));
+        }
+        catch {
+            return false;
+        }
+        if (mutationKind === 'archive'
+            && (payload.cancellation !== false || payload.reason !== null)) {
+            return false;
+        }
+        const task = this.db.prepare(`
+            SELECT status, is_archived, completed_at, canceled_reason
+            FROM tasks
+            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+        `).get(tenantId, workspaceId, requireText(source.entity_id, 'Recovery task id'));
+        if (!task)
+            return false;
+        const isArchived = task.is_archived === true || Number(task.is_archived || 0) === 1;
+        const status = String(task.status || '').trim().toLowerCase();
+        const completedAt = typeof task.completed_at === 'string' && task.completed_at.trim()
+            ? task.completed_at.trim()
+            : null;
+        const canceledReason = typeof task.canceled_reason === 'string' && task.canceled_reason.trim()
+            ? task.canceled_reason.trim()
+            : null;
+        if (mutationKind === 'archive') {
+            return isArchived && status === 'done' && completedAt !== null && canceledReason === null;
+        }
+        return !isArchived && status === 'task' && completedAt === null && canceledReason === null;
+    }
+    normalizeRecoveredWorkflowStepEvidence(tenantId, workspaceId, assignment) {
+        const version = assignment.version;
+        const requestedSteps = Array.isArray(assignment.steps) ? assignment.steps : null;
+        const workflowVersionId = String(version?.id || '');
+        if (!workflowVersionId || !requestedSteps)
+            return null;
+        const workflowStepsTable = this.db.provider === 'postgres'
+            ? this.db.prepare(`
+                SELECT 1 AS present
+                FROM information_schema.tables
+                WHERE table_schema = current_schema() AND table_name = 'workflow_steps'
+            `).get()
+            : this.db.prepare(`
+                SELECT 1 AS present
+                FROM sqlite_master
+                WHERE type = 'table' AND name = 'workflow_steps'
+            `).get();
+        if (!workflowStepsTable)
+            return null;
+        const rows = this.db.prepare(`
+            SELECT id, tenant_id, workspace_id, workflow_version_id, position,
+                   name, instructions, owner_type, owner_id, expected_artifact,
+                   requires_comment_evidence, is_required, created_at, updated_at
+            FROM workflow_steps
+            WHERE tenant_id = ? AND workspace_id = ? AND workflow_version_id = ?
+            ORDER BY position, id
+        `).all(tenantId, workspaceId, workflowVersionId);
+        if (rows.length !== requestedSteps.length)
+            return null;
+        const canonicalById = new Map(rows.map((row) => {
+            const step = {
+                id: requireText(row.id, 'Workflow step id'),
+                tenantId: requireText(row.tenant_id, 'Workflow step tenant id'),
+                workspaceId: requireText(row.workspace_id, 'Workflow step workspace id'),
+                workflowVersionId: requireText(row.workflow_version_id, 'Workflow step version id'),
+                position: Number(row.position),
+                name: requireText(row.name, 'Workflow step name'),
+                instructions: String(row.instructions || ''),
+                ownerType: row.owner_type === 'user' || row.owner_type === 'agent'
+                    ? row.owner_type
+                    : null,
+                ownerId: row.owner_id == null ? null : String(row.owner_id),
+                expectedArtifact: row.expected_artifact == null ? null : String(row.expected_artifact),
+                requiresCommentEvidence: Number(row.requires_comment_evidence) === 1,
+                isRequired: Number(row.is_required) !== 0,
+                createdAt: requireText(row.created_at, 'Workflow step created time'),
+                updatedAt: requireText(row.updated_at, 'Workflow step updated time'),
+            };
+            return [step.id, step];
+        }));
+        let changed = false;
+        const normalizedSteps = requestedSteps.map((rawStep) => {
+            if (!rawStep || typeof rawStep !== 'object' || Array.isArray(rawStep))
+                return null;
+            const requested = rawStep;
+            const canonical = canonicalById.get(String(requested.id || ''));
+            if (!canonical)
+                return null;
+            const { requiresCommentEvidence: _requestedEvidence, ...requestedDefinition } = requested;
+            const { requiresCommentEvidence: canonicalEvidence, ...canonicalDefinition } = canonical;
+            if (canonicalWorkspaceSyncJson(requestedDefinition)
+                !== canonicalWorkspaceSyncJson(canonicalDefinition)) {
+                return null;
+            }
+            if (requested.requiresCommentEvidence !== canonicalEvidence) {
+                if (requested.requiresCommentEvidence !== true || canonicalEvidence !== false) {
+                    return null;
+                }
+                changed = true;
+            }
+            return {
+                ...requested,
+                requiresCommentEvidence: canonicalEvidence,
+            };
+        });
+        if (normalizedSteps.some((step) => step === null))
+            return null;
+        return {
+            assignment: {
+                ...assignment,
+                steps: normalizedSteps,
+            },
+            changed,
+        };
+    }
+    prepareRecoveryPayload(tenantId, workspaceId, source) {
+        if (source.domain === 'task-comments' && source.mutation_kind === 'append') {
+            return this.prepareTaskCommentAppendRecoveryPayload(tenantId, workspaceId, source);
+        }
+        if (source.dispatch_class === 'legacy-adoption'
+            && source.domain === 'entity-event'
+            && source.mutation_kind === 'adopt-legacy-batch') {
+            const payload = this.readEntityEventLegacyAdoptionRecoveryIntent(workspaceId, source);
+            const payloadJson = canonicalWorkspaceSyncJson(payload);
+            return {
+                payloadJson,
+                payloadFingerprint: fingerprintWorkspaceSyncPayload(payload),
+                replayMutationKind: 'adopt-legacy-batch',
+                workflowDependencyCoalesced: false,
+            };
+        }
+        return {
+            ...this.prepareTaskRecoveryPayload(tenantId, workspaceId, source),
+            replayMutationKind: requireText(source.mutation_kind, 'Source mutation kind'),
+        };
+    }
+    parseFrozenRecoveryPayload(source) {
+        let payload;
+        try {
+            const parsed = JSON.parse(String(source.payload_json || ''));
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                throw new Error('invalid');
+            }
+            payload = parsed;
+        }
+        catch {
+            throw new Error('Workspace sync recovery payload is not valid JSON.');
+        }
+        if (fingerprintWorkspaceSyncPayload(payload) !== source.payload_fingerprint) {
+            throw new Error('Workspace sync recovery payload fingerprint does not match.');
+        }
+        return payload;
+    }
+    readEntityEventLegacyAdoptionRecoveryIntent(workspaceId, source) {
+        const payload = this.parseFrozenRecoveryPayload(source);
+        if (Object.keys(payload).length !== 1 || !Array.isArray(payload.events)
+            || payload.events.length < 1 || payload.events.length > 100) {
+            throw new Error('Legacy entity-event adoption recovery payload is invalid.');
+        }
+        if (Buffer.byteLength(canonicalWorkspaceSyncJson(payload), 'utf8')
+            > LEGACY_ENTITY_EVENT_ADOPTION_MAX_PAYLOAD_BYTES) {
+            throw new Error('Legacy entity-event adoption recovery payload exceeds the transport-safe byte limit.');
+        }
+        const events = payload.events.map((value) => validateWorkspaceSyncV3EntityEventPayload(value));
+        if (events.some((event) => event.workspaceId !== workspaceId)) {
+            throw new Error('Legacy entity-event adoption recovery event identity is invalid.');
+        }
+        if (events[0].id !== source.entity_id
+            || new Set(events.map((event) => event.id)).size !== events.length) {
+            throw new Error('Legacy entity-event adoption recovery batch identity is invalid.');
+        }
+        return { events };
+    }
+    readTaskCreateRecoveryIntent(source) {
+        const payload = this.parseFrozenRecoveryPayload(source);
+        const allowedPayloadKeys = new Set(['task', 'localCarriers', 'originActor']);
+        if (Object.keys(payload).some((key) => !allowedPayloadKeys.has(key))) {
+            throw new Error('Task create recovery payload contains unsupported fields.');
+        }
+        if (payload.originActor !== undefined)
+            parseWorkspaceSyncV3OriginActor(payload.originActor);
+        if (!payload.task || typeof payload.task !== 'object' || Array.isArray(payload.task)) {
+            throw new Error('Task create recovery payload is invalid.');
+        }
+        const task = payload.task;
+        if (Object.keys(task).some((key) => !TASK_CREATE_FIELDS.has(key))) {
+            throw new Error('Task create recovery payload contains unsupported task fields.');
+        }
+        if (typeof task.title !== 'string' || !task.title.trim() || task.title !== task.title.trim()) {
+            throw new Error('Task create recovery payload title is not canonical.');
+        }
+        const carriers = payload.localCarriers;
+        if (!carriers || typeof carriers !== 'object' || Array.isArray(carriers)
+            || canonicalWorkspaceSyncJson(Object.keys(carriers).sort())
+                !== canonicalWorkspaceSyncJson(['attachments', 'checklistItems', 'comments'])
+            || !Array.isArray(carriers.attachments)
+            || !Array.isArray(carriers.checklistItems)
+            || !Array.isArray(carriers.comments)
+            || carriers.attachments.length > 0
+            || carriers.checklistItems.length > 0
+            || carriers.comments.length > 0) {
+            throw new Error('Task create recovery requires empty local carriers; nested content needs explicit recovery.');
+        }
+        return { task };
+    }
+    assertTaskCreateRecoveryIntentSatisfied(tenantId, workspaceId, source) {
+        if (!TASK_CREATE_RECOVERY_ERROR_CODES.has(String(source.last_error_code || ''))) {
+            throw new Error('Task create recovery requires an authoritative identity or revision conflict.');
+        }
+        const { task } = this.readTaskCreateRecoveryIntent(source);
+        const installed = this.db.prepare(`
+            SELECT title, description, priority, complexity, type, category, assignee, status,
+                   scheduled_date, due_date, order_in_day, workstream_id, taxonomies,
+                   reference_number, local_reference_number, is_archived
+            FROM tasks
+            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+        `).get(tenantId, workspaceId, requireText(source.entity_id, 'Source entity id'));
+        if (!installed || Number(installed.is_archived || 0) === 1
+            || !Number.isSafeInteger(Number(installed.reference_number))
+            || Number(installed.reference_number) < 1
+            || installed.local_reference_number !== null) {
+            throw new Error('Task create recovery requires a non-tombstoned authoritative task baseline.');
+        }
+        const installedByField = {
+            title: installed.title,
+            description: installed.description,
+            priority: installed.priority == null ? null : Number(installed.priority),
+            complexity: installed.complexity == null ? null : Number(installed.complexity),
+            type: installed.type,
+            category: installed.category,
+            assignee: installed.assignee,
+            status: installed.status,
+            scheduledDate: installed.scheduled_date ?? null,
+            dueDate: installed.due_date ?? null,
+            orderInDay: installed.order_in_day == null ? null : Number(installed.order_in_day),
+            workstreamId: installed.workstream_id ?? null,
+            taxonomies: (() => {
+                try {
+                    return JSON.parse(String(installed.taxonomies || '{}'));
+                }
+                catch {
+                    throw new Error('Authoritative task taxonomy baseline is invalid.');
+                }
+            })(),
+        };
+        for (const [field, value] of Object.entries(task)) {
+            if (canonicalWorkspaceSyncJson(installedByField[field])
+                !== canonicalWorkspaceSyncJson(value)) {
+                throw new WorkspaceSyncIdempotencyConflictError();
+            }
+        }
+        const ownership = this.readWorkspaceDomainOwnership({
+            tenantId,
+            workspaceId,
+            domain: 'task',
+            entityId: requireText(source.entity_id, 'Source entity id'),
+        });
+        if (!ownership.owned || ownership.activeOperation) {
+            throw new Error('Task create recovery requires its authoritative task baseline to settle first.');
+        }
+    }
+    readTaskAttachmentLinksRecoveryIntent(source) {
+        const payload = this.parseFrozenRecoveryPayload(source);
+        const allowedPayloadKeys = new Set(['links', 'originActor']);
+        if (Object.keys(payload).some((key) => !allowedPayloadKeys.has(key))
+            || !Array.isArray(payload.links)) {
+            throw new Error('Task attachment-link recovery payload is invalid.');
+        }
+        if (payload.originActor !== undefined)
+            parseWorkspaceSyncV3OriginActor(payload.originActor);
+        const identities = new Set();
+        const links = payload.links.map((raw, index) => {
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+                throw new Error('Task attachment-link recovery payload is invalid.');
+            }
+            const link = raw;
+            if (Object.keys(link).some((key) => !TASK_ATTACHMENT_LINK_FIELDS.has(key))) {
+                throw new Error('Task attachment-link recovery payload contains unsupported fields.');
+            }
+            const assetId = requireText(link.assetId, 'Task attachment-link asset id');
+            if (link.assetId !== assetId) {
+                throw new Error('Task attachment-link recovery payload is not canonical.');
+            }
+            const role = String(link.role || '');
+            if (!['attachment', 'image', 'reference'].includes(role)
+                || !Number.isSafeInteger(link.order)
+                || Number(link.order) !== index) {
+                throw new Error('Task attachment-link recovery payload is not canonical.');
+            }
+            const identity = `${assetId}\0${role}`;
+            if (identities.has(identity)) {
+                throw new Error('Task attachment-link recovery payload contains a duplicate identity.');
+            }
+            identities.add(identity);
+            for (const field of ['caption', 'displayName', 'originalFilename']) {
+                if (link[field] !== undefined && typeof link[field] !== 'string') {
+                    throw new Error('Task attachment-link recovery metadata is invalid.');
+                }
+                if (typeof link[field] === 'string'
+                    && TASK_ATTACHMENT_FORBIDDEN_METADATA_VALUE.test(link[field])) {
+                    throw new Error('Task attachment-link recovery metadata contains a forbidden local, inline, or remote URL value.');
+                }
+            }
+            if (link.referenceNumber !== undefined && link.referenceNumber !== null
+                && (!Number.isSafeInteger(link.referenceNumber) || Number(link.referenceNumber) < 1)) {
+                throw new Error('Task attachment-link recovery reference number is invalid.');
+            }
+            if (link.referenceLabel !== undefined && link.referenceLabel !== null
+                && typeof link.referenceLabel !== 'string') {
+                throw new Error('Task attachment-link recovery reference label is invalid.');
+            }
+            return {
+                assetId,
+                role,
+                order: Number(link.order),
+                displayName: typeof link.displayName === 'string' ? link.displayName : null,
+            };
+        });
+        return { links };
+    }
+    isTaskAttachmentLinksRecoveryIntentSatisfied(tenantId, workspaceId, source) {
+        const intent = this.readTaskAttachmentLinksRecoveryIntent(source);
+        const installed = this.db.prepare(`
+            SELECT asset_id, role, sort_order, display_name
+            FROM workspace_asset_links
+            WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?
+              AND target_type = 'task' AND deleted_at IS NULL
+            ORDER BY sort_order, asset_id, role
+        `).all(tenantId, workspaceId, requireText(source.entity_id, 'Source entity id')).map((link, index) => ({
+            assetId: String(link.asset_id || ''),
+            role: String(link.role || ''),
+            order: Number.isSafeInteger(link.sort_order) && Number(link.sort_order) >= 0
+                ? Number(link.sort_order)
+                : index,
+            displayName: typeof link.display_name === 'string' ? link.display_name : null,
+        }));
+        return canonicalWorkspaceSyncJson(installed) === canonicalWorkspaceSyncJson(intent.links);
+    }
+    readTaskCommentAppendRecoveryIntent(workspaceId, source) {
+        let payload;
+        try {
+            payload = JSON.parse(String(source.payload_json || ''));
+        }
+        catch {
+            throw new Error('Workspace sync recovery payload is not valid JSON.');
+        }
+        if (fingerprintWorkspaceSyncPayload(payload) !== source.payload_fingerprint) {
+            throw new Error('Workspace sync recovery payload fingerprint does not match.');
+        }
+        const keys = Object.keys(payload).sort();
+        const hasOriginActor = payload.originActor !== undefined;
+        const expectedKeys = hasOriginActor ? ['comment', 'originActor'] : ['comment'];
+        if (canonicalWorkspaceSyncJson(keys) !== canonicalWorkspaceSyncJson(expectedKeys)) {
+            throw new Error('Task comment recovery payload contains unsupported fields.');
+        }
+        if (hasOriginActor)
+            parseWorkspaceSyncV3OriginActor(payload.originActor);
+        if (!payload.comment || typeof payload.comment !== 'object' || Array.isArray(payload.comment)) {
+            throw new Error('Task comment recovery payload is invalid.');
+        }
+        const commentKeys = Object.keys(payload.comment).sort();
+        if (canonicalWorkspaceSyncJson(commentKeys)
+            !== canonicalWorkspaceSyncJson(['author', 'id', 'submittedAuthor', 'text', 'timestamp'])) {
+            throw new Error('Task comment recovery payload is not canonical.');
+        }
+        const comments = normalizePlanningComments([payload.comment]);
+        if (!comments || comments.length !== 1
+            || canonicalWorkspaceSyncJson(comments[0]) !== canonicalWorkspaceSyncJson(payload.comment)) {
+            throw new Error('Task comment recovery payload is not canonical.');
+        }
+        return {
+            comment: comments[0],
+            activityEventId: buildTaskCommentActivityEventId({
+                workspaceId: requireText(workspaceId, 'Source workspace id'),
+                clientId: requireText(source.client_id, 'Source client id'),
+                operationId: requireText(source.operation_id, 'Source operation id'),
+                taskId: requireText(source.entity_id, 'Source entity id'),
+                commentId: comments[0].id,
+            }),
+        };
+    }
+    prepareTaskCommentAppendRecoveryPayload(tenantId, workspaceId, source) {
+        const intent = this.readTaskCommentAppendRecoveryIntent(workspaceId, source);
+        this.assertTaskCommentAppendRecoveryEventOwned(tenantId, workspaceId, source, intent);
+        const replayPayload = {
+            comments: [intent.comment],
+            provenance: [{
+                    commentId: intent.comment.id,
+                    actor: {
+                        kind: 'authoritative-entity-event',
+                        eventId: intent.activityEventId,
+                    },
+                }],
+        };
+        const payloadJson = canonicalWorkspaceSyncJson(replayPayload);
+        return {
+            payloadJson,
+            payloadFingerprint: fingerprintWorkspaceSyncPayload(replayPayload),
+            replayMutationKind: 'reconcile',
+            workflowDependencyCoalesced: false,
+        };
+    }
+    assertTaskCommentAppendRecoveryEventOwned(tenantId, workspaceId, source, intent = this.readTaskCommentAppendRecoveryIntent(workspaceId, source)) {
+        const taskId = requireText(source.entity_id, 'Source entity id');
+        const event = this.db.prepare(`
+            SELECT entity_type, entity_id, action, actor, details_json
+            FROM entity_events
+            WHERE id = ? AND tenant_id = ? AND workspace_id = ?
+        `).get(intent.activityEventId, tenantId, workspaceId);
+        let details = null;
+        try {
+            const parsed = JSON.parse(String(event?.details_json || ''));
+            details = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+                ? parsed
+                : null;
+        }
+        catch {
+            details = null;
+        }
+        const expectedDetails = {
+            commentId: intent.comment.id,
+            preview: intent.comment.text.slice(0, 160),
+            submittedAuthor: String(intent.comment.submittedAuthor || intent.comment.author || '').trim(),
+        };
+        const ownership = this.readWorkspaceDomainOwnership({
+            tenantId,
+            workspaceId,
+            domain: 'entity-event',
+            entityId: intent.activityEventId,
+        });
+        if (!event
+            || event.entity_type !== 'task'
+            || event.entity_id !== taskId
+            || event.action !== 'task-comment-added'
+            || event.actor !== intent.comment.author
+            || canonicalWorkspaceSyncJson(details) !== canonicalWorkspaceSyncJson(expectedDetails)
+            || !ownership.owned
+            || ownership.activeOperation) {
+            throw new Error('Task comment recovery requires its authoritative entity-event adoption to settle first.');
+        }
+    }
+    isTaskCommentAppendRecoveryIntentSatisfied(tenantId, workspaceId, source) {
+        const intent = this.readTaskCommentAppendRecoveryIntent(workspaceId, source);
+        const installed = this.db.prepare(`
+            SELECT id, text, author, timestamp, submitted_author
+            FROM comments
+            WHERE tenant_id = ? AND workspace_id = ? AND task_id = ? AND id = ?
+        `).get(tenantId, workspaceId, requireText(source.entity_id, 'Source entity id'), intent.comment.id);
+        if (!installed)
+            return false;
+        const installedComments = normalizePlanningComments([{
+                id: installed.id,
+                text: installed.text,
+                author: installed.author,
+                timestamp: installed.timestamp,
+                ...(installed.submitted_author == null
+                    ? {}
+                    : { submittedAuthor: installed.submitted_author }),
+            }]);
+        if (!installedComments || installedComments.length !== 1
+            || canonicalWorkspaceSyncJson(installedComments[0])
+                !== canonicalWorkspaceSyncJson(intent.comment)) {
+            throw new WorkspaceSyncIdempotencyConflictError();
+        }
+        return true;
+    }
+    prepareTaskRecoveryPayload(tenantId, workspaceId, source) {
+        let payload;
+        try {
+            payload = JSON.parse(String(source.payload_json || ''));
+        }
+        catch {
+            throw new Error('Workspace sync recovery payload is not valid JSON.');
+        }
+        if (fingerprintWorkspaceSyncPayload(payload) !== source.payload_fingerprint) {
+            throw new Error('Workspace sync recovery payload fingerprint does not match.');
+        }
+        if (source.mutation_kind !== 'set-status' || !payload.workflowAssignment) {
+            return {
+                payloadJson: canonicalWorkspaceSyncJson(payload),
+                payloadFingerprint: fingerprintWorkspaceSyncPayload(payload),
+                workflowDependencyCoalesced: false,
+            };
+        }
+        const repairableCommentEvidenceConflict = (source.last_error_code === 'WORKFLOW_ASSIGNMENT_SYNC_CONFLICT'
+            && source.last_error_message === 'Workflow assignment published steps conflict with canonical storage.');
+        const normalizedAssignment = repairableCommentEvidenceConflict
+            ? this.normalizeRecoveredWorkflowStepEvidence(tenantId, workspaceId, payload.workflowAssignment)
+            : null;
+        const workflowDefinitionNormalized = normalizedAssignment?.changed === true;
+        if (workflowDefinitionNormalized) {
+            payload.workflowAssignment = normalizedAssignment.assignment;
+        }
+        const requested = payload.workflowAssignment;
+        const requestedExecution = requested.execution;
+        const requestedEvents = Array.isArray(requested.events) ? requested.events : [];
+        const executionId = String(requestedExecution?.id || '');
+        if (!executionId
+            || !requested.template || typeof requested.template !== 'object'
+            || !requested.version || typeof requested.version !== 'object'
+            || !Array.isArray(requested.steps)
+            || !requestedExecution?.taskId
+            || !requestedExecution.workflowTemplateId
+            || !requestedExecution.workflowVersionId
+            || requestedEvents.length === 0) {
+            throw new Error('Workflow assignment recovery requires semantic history reconciliation.');
+        }
+        const accepted = this.db.prepare(`
+            SELECT payload_json, authoritative_response_json
+            FROM workspace_sync_outbox
+            WHERE tenant_id = ? AND workspace_id = ?
+              AND domain = 'task' AND entity_id = ?
+              AND mutation_kind = 'set-status' AND status = 'accepted'
+              AND enqueue_sequence < ?
+            ORDER BY enqueue_sequence DESC
+        `).all(tenantId, workspaceId, requireText(source.entity_id, 'Source entity id'), normalizeSequence(source.enqueue_sequence ?? 0));
+        const immutableExecution = (execution) => ({
+            id: execution?.id,
+            taskId: execution?.taskId,
+            workflowTemplateId: execution?.workflowTemplateId,
+            workflowVersionId: execution?.workflowVersionId,
+        });
+        const dependencySatisfied = accepted.some((candidate) => {
+            try {
+                const acceptedPayload = JSON.parse(String(candidate.payload_json || ''));
+                const acceptedResponse = JSON.parse(String(candidate.authoritative_response_json || ''));
+                const acceptedRequest = acceptedPayload.workflowAssignment;
+                const authoritative = acceptedResponse.workflowAssignment;
+                const authoritativeExecution = authoritative?.execution;
+                const authoritativeEvents = Array.isArray(authoritative?.events) ? authoritative.events : [];
+                return String(acceptedRequest?.execution?.id || '')
+                    === executionId
+                    && canonicalWorkspaceSyncJson(requested.template)
+                        === canonicalWorkspaceSyncJson(authoritative?.template)
+                    && canonicalWorkspaceSyncJson(requested.version)
+                        === canonicalWorkspaceSyncJson(authoritative?.version)
+                    && canonicalWorkspaceSyncJson(requested.steps)
+                        === canonicalWorkspaceSyncJson(authoritative?.steps)
+                    && canonicalWorkspaceSyncJson(immutableExecution(requestedExecution))
+                        === canonicalWorkspaceSyncJson(immutableExecution(authoritativeExecution))
+                    && authoritativeExecution?.status !== 'pending'
+                    && authoritativeEvents.length >= requestedEvents.length
+                    && canonicalWorkspaceSyncJson(authoritativeEvents.slice(0, requestedEvents.length))
+                        === canonicalWorkspaceSyncJson(requestedEvents);
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!dependencySatisfied) {
+            if (workflowDefinitionNormalized) {
+                return {
+                    payloadJson: canonicalWorkspaceSyncJson(payload),
+                    payloadFingerprint: fingerprintWorkspaceSyncPayload(payload),
+                    workflowDependencyCoalesced: false,
+                };
+            }
+            throw new Error('Workflow assignment recovery requires semantic history reconciliation.');
+        }
+        delete payload.workflowAssignment;
+        return {
+            payloadJson: canonicalWorkspaceSyncJson(payload),
+            payloadFingerprint: fingerprintWorkspaceSyncPayload(payload),
+            workflowDependencyCoalesced: true,
+        };
+    }
+    allocateSequenceRange(tenantId, workspaceId, now, count) {
+        const row = this.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, count, now);
+        return normalizeSequence(row?.last_sequence);
+    }
+    allocateOutboxEnqueueSequence(tenantId, workspaceId, now) {
+        const row = this.db.prepare(`
+            INSERT INTO workspace_sync_outbox_sequences (tenant_id, workspace_id, last_sequence, updated_at)
+            VALUES (?, ?, 1, ?)
+            ON CONFLICT (tenant_id, workspace_id) DO UPDATE SET
+                last_sequence = workspace_sync_outbox_sequences.last_sequence + 1,
+                updated_at = excluded.updated_at
+            RETURNING CAST(last_sequence AS TEXT) AS last_sequence
+        `).get(tenantId, workspaceId, now);
+        return normalizeSequence(row?.last_sequence);
+    }
+    readOperationRow(ids) {
+        return this.db.prepare(`
+            SELECT contract_version, request_fingerprint, status, response_json,
+                   CAST(accepted_sequence AS TEXT) AS accepted_sequence,
+                   lease_owner, lease_expires_at
+            FROM workspace_sync_operation_results
+            WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
+        `).get(...ids);
+    }
+    assertMatchingOperation(row, requestFingerprint) {
+        if (!row)
+            throw new Error('Workspace sync operation does not exist.');
+        if (Number(row.contract_version) !== WORKSPACE_SYNC_CONTRACT_VERSION || row.request_fingerprint !== requestFingerprint) {
+            throw new WorkspaceSyncIdempotencyConflictError();
+        }
+    }
+    mapOutboxRow(row) {
+        return {
+            tenantId: requireText(row.tenant_id, 'Tenant id'),
+            workspaceId: requireText(row.workspace_id, 'Workspace id'),
+            clientId: requireText(row.client_id, 'Client id'),
+            operationId: requireText(row.operation_id, 'Operation id'),
+            dispatchClass: requireOutboxDispatchClass(row.dispatch_class),
+            domain: requireText(row.domain, 'Domain'),
+            entityId: requireText(row.entity_id, 'Entity id'),
+            mutationKind: requireText(row.mutation_kind, 'Mutation kind'),
+            ownsTaskMetadata: Number(row.owns_task_metadata) === 1,
+            ownsTaskLifecycle: Number(row.owns_task_lifecycle) === 1,
+            ownsTaskAssignee: Number(row.owns_task_assignee) === 1,
+            baseEntityRevision: normalizeSequence(row.base_entity_revision),
+            baseLifecycleRevision: normalizeSequence(row.base_lifecycle_revision),
+            payloadJson: requireText(row.payload_json, 'Payload'),
+            payloadFingerprint: requireText(row.payload_fingerprint, 'Payload fingerprint'),
+            status: requireText(row.status, 'Outbox status'),
+            attemptCount: Number(row.attempt_count || 0),
+            initialNotFoundAttemptCount: Number(row.initial_not_found_attempt_count || 0),
+            enqueueSequence: normalizeSequence(row.enqueue_sequence ?? 0),
+            rebaseBeforeFirstAttempt: Number(row.rebase_before_first_attempt) === 1,
+            workstreamMetadataRevisionRebaseCount: Number(row.workstream_metadata_revision_rebase_count || 0),
+            initiativeMetadataRevisionRebaseCount: Number(row.initiative_metadata_revision_rebase_count || 0),
+            leaseOwner: row.lease_owner == null ? null : String(row.lease_owner),
+            leaseExpiresAt: row.lease_expires_at == null ? null : String(row.lease_expires_at),
+        };
+    }
+}
+// Consistent reservation lifecycle for a V3 mutation service: reserve, run
+// arbitrary caller work (readiness/identity checks, then an accept/commit
+// call), and release the reservation immediately if that work throws before
+// committing. Without this, a business-logic failure between reserveOperation
+// and acceptReservedOperationBatch/commitReservedOperationResponse leaves the
+// reservation row orphaned in status='processing' until its lease naturally
+// expires, so every retry sees WORKSPACE_SYNC_OPERATION_IN_PROGRESS instead of
+// re-attempting. acceptReservedOperationBatch and commitReservedOperationResponse
+// already self-release on a throw from inside their own transaction (the most
+// common case, ordinary business validation inside applyMutation); this helper
+// additionally covers a service's own pre-accept work, exactly like the
+// TASK_ATTACHMENT_ASSET_NOT_READY readiness check for task-attachment-links.
+// Never deletes, rewrites, or force-accepts the operation: on release, the
+// exact same operation identity is immediately eligible for reservation
+// takeover on the next call with the same request fingerprint.
+export function runReservedWorkspaceSyncV3Operation(input) {
+    const reservation = input.store.reserveOperation({
+        identity: input.identity,
+        requestFingerprint: input.requestFingerprint,
+        now: input.now,
+        leaseExpiresAt: input.leaseExpiresAt,
+        leaseOwner: input.leaseOwner,
+    });
+    if (reservation.state !== 'owned')
+        return reservation;
+    try {
+        return input.attempt(reservation);
+    }
+    catch (error) {
+        if (!(error instanceof WorkspaceSyncLeaseLostError)) {
+            input.store.releaseFailedOperationReservation({
+                identity: input.identity,
+                requestFingerprint: input.requestFingerprint,
+                leaseOwner: reservation.leaseOwner,
+                now: input.now,
+            });
+        }
+        throw error;
+    }
+}