@taskforcehq/taskforce 0.3.327 → 0.3.328

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

@@ -26,6 +26,7 @@ export declare function enqueueLocalTaskAttachmentLinksMutation(input: {
     identity: WorkspaceSyncOperationIdentity;
     taskId: string;
     links: readonly WorkspaceSyncV3TaskAttachmentLink[];
+    cardCoverAssetId?: string | null;
     now: string;
     actorRef: string;
     requireV3CombinedOwnership?: boolean;

package/dist/sync/v3/localTaskAttachmentLinksOutboxService.js

@@ -1,4 +1,4 @@
-import { projectResolvedTaskAttachmentLinksForDurableSync } from '../../core/TaskAttachmentLinksDurableMutationService.js';
+import { projectResolvedTaskAttachmentLinksForDurableSync, resolveTaskCardCoverAssetIdForLinks, } from '../../core/TaskAttachmentLinksDurableMutationService.js';
 import { selectDurableTaskMetadataPatch } from '../../core/TaskDurableSyncMutationService.js';
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 import { buildTaskAttachmentLinksActivityEventId } from './taskAttachmentLinksActivityIdentity.js';
@@ -111,7 +111,12 @@ export function enqueueLocalTaskAttachmentLinksMutation(input) {
     const result = input.store.enqueueLocalOperation({
         identity: input.identity,
         domain: 'task-attachment-links', entityId: input.taskId, mutationKind: 'replace',
-        revisionSource: 'current', payload: withOriginActorPayload({ links }, input.actorRef),
+        revisionSource: 'current', payload: withOriginActorPayload({
+            links,
+            ...(Object.prototype.hasOwnProperty.call(input, 'cardCoverAssetId')
+                ? { cardCoverAssetId: input.cardCoverAssetId ?? null }
+                : {}),
+        }, input.actorRef),
         additionalTargets: [{
                 domain: 'task', entityId: input.taskId, mutationKind: 'metadata-update',
                 baseEntityRevision: rootRevision.entityRevision, baseLifecycleRevision: rootRevision.lifecycleRevision,
@@ -127,11 +132,18 @@ export function enqueueLocalTaskAttachmentLinksMutation(input) {
             if (existing.isArchived)
                 throw new LocalAuthoritativeTaskAttachmentLinksError('Archived tasks are read-only.');
             const previousLinks = input.core.listTaskAttachmentLinksForDurableSync(input.taskId, input.identity.workspaceId);
+            const cardCoverAssetId = resolveTaskCardCoverAssetIdForLinks({
+                currentCardCoverAssetId: existing.cardCoverAssetId,
+                ...(Object.prototype.hasOwnProperty.call(input, 'cardCoverAssetId')
+                    ? { requestedCardCoverAssetId: input.cardCoverAssetId }
+                    : {}),
+                links,
+            });
             const currentMs = Date.parse(String(existing.updatedAt || existing.createdAt));
             const requestedMs = Date.parse(input.now);
             const updatedAt = Number.isFinite(currentMs) && currentMs >= requestedMs
                 ? new Date(currentMs + 1).toISOString() : input.now;
-            const task = input.core.updateTask(input.taskId, { attachments }, input.identity.workspaceId, {
+            const task = input.core.updateTask(input.taskId, { attachments, cardCoverAssetId }, input.identity.workspaceId, {
                 persistBackup: false, emitRealtime: false, syncUpdatedAt: updatedAt,
                 actorRef: input.actorRef, taskEventId: activityEventId, taskEventAction: 'task-attachments-changed',
                 taskEventDetails: canonicalizeEntityActivityDetailsForSync({

package/dist/sync/v3/localWorkstreamOutboxService.js

@@ -300,8 +300,9 @@ function validateActivitySemantics(input) {
     const authoritativeAttachmentLinks = validateCanonicalPlanningAttachmentLinks(input.authoritative.attachments);
     const comparableExpectedDetails = normalizePlanningActivityDetailsForComparison(expectedDetails, input.record.mutationKind, authoritativeAttachmentLinks);
     const comparableAuthoritativeDetails = normalizePlanningActivityDetailsForComparison((input.activity.details || {}), input.record.mutationKind, authoritativeAttachmentLinks);
-    if (fingerprintWorkspaceSyncPayload(comparableExpectedDetails)
-        !== fingerprintWorkspaceSyncPayload(comparableAuthoritativeDetails)) {
+    if (!input.boundedAttachmentRebase
+        && fingerprintWorkspaceSyncPayload(comparableExpectedDetails)
+            !== fingerprintWorkspaceSyncPayload(comparableAuthoritativeDetails)) {
         throw new LocalAuthoritativeWorkstreamError('Authoritative workstream activity details differ from the captured mutation.');
     }
 }
@@ -500,6 +501,7 @@ export function applyAuthoritativeWorkstreamAndAck(input) {
         payload: payload,
         authoritative: workstream,
         activity,
+        boundedAttachmentRebase,
     });
     const revision = validateWorkstreamActivityAuthoritativeRevision({
         response: response,

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

@@ -152,6 +152,9 @@ export type WorkspaceSyncDomainCoexistenceTarget = {
     domain: string;
     entityId: string;
 };
+export type WorkspaceSyncRecoveryBaselineTarget = WorkspaceSyncDomainCoexistenceTarget & {
+    required: boolean;
+};
 export type WorkspaceSyncPlanningRevisionProjection = {
     entityId: string;
     coexistenceOwned: boolean;
@@ -374,6 +377,11 @@ export declare class WorkspaceSyncDurabilityStore {
         workspaceId: string;
         recoveryBatchId: string;
     }): WorkspaceSyncDomainCoexistenceTarget[];
+    listOutboxRecoveryBaselineTargets(input: {
+        tenantId: string;
+        workspaceId: string;
+        recoveryBatchId: string;
+    }): WorkspaceSyncRecoveryBaselineTarget[];
     prepareTaskRootOutboxRecoveryReplay(input: {
         tenantId: string;
         workspaceId: string;

package/dist/sync/v3/syncDurabilityStore.js

@@ -1,8 +1,9 @@
 import { createHash, randomUUID } from 'crypto';
 import { normalizePlanningComments, } from '../planningCanonicalFields.js';
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
-import { buildTaskCreateActivityEventId } from './taskCreateActivityIdentity.js';
+import { buildTaskAttachmentLinksActivityEventId } from './taskAttachmentLinksActivityIdentity.js';
 import { buildTaskCommentActivityEventId } from './taskCommentActivityIdentity.js';
+import { buildTaskCreateActivityEventId } from './taskCreateActivityIdentity.js';
 import { buildTaskLifecycleActivityEventId, } from './taskLifecycleActivityIdentity.js';
 import { buildTaskMetadataActivityEventId } from './taskMetadataActivityIdentity.js';
 import { parseWorkspaceSyncV3OriginActor } from './workspaceSyncV3OriginActor.js';
@@ -251,7 +252,8 @@ export function hasCompletedRecoveryForSupersededEntityEvent(db, input) {
     if (entityType !== 'task')
         return false;
     const sources = db.prepare(`
-        SELECT source.client_id, source.operation_id, source.mutation_kind
+        SELECT source.client_id, source.operation_id, source.domain, source.mutation_kind,
+               source.last_error_code
         FROM workspace_sync_outbox AS source
         INNER JOIN workspace_sync_outbox_recoveries AS recovery
           ON recovery.tenant_id = source.tenant_id
@@ -259,7 +261,7 @@ export function hasCompletedRecoveryForSupersededEntityEvent(db, input) {
          AND recovery.recovery_batch_id = source.recovery_batch_id
         WHERE source.tenant_id = ?
           AND source.workspace_id = ?
-          AND source.domain = 'task'
+          AND source.domain IN ('task', 'task-attachment-links')
           AND source.entity_id = ?
           AND source.status = 'superseded'
           AND recovery.state = 'completed'
@@ -268,9 +270,19 @@ export function hasCompletedRecoveryForSupersededEntityEvent(db, input) {
     return sources.some((source) => {
         const clientId = String(source.client_id || '').trim();
         const operationId = String(source.operation_id || '').trim();
+        const domain = String(source.domain || '').trim();
         const mutationKind = String(source.mutation_kind || '').trim();
         if (!clientId || !operationId)
             return false;
+        if (domain === 'task-attachment-links'
+            && mutationKind === 'replace'
+            && String(source.last_error_code || '') === 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID') {
+            return buildTaskAttachmentLinksActivityEventId({
+                workspaceId, clientId, operationId, taskId: entityId,
+            }) === eventId;
+        }
+        if (domain !== 'task')
+            return false;
         if (mutationKind === 'create') {
             return buildTaskCreateActivityEventId({
                 workspaceId, clientId, operationId, taskId: entityId,
@@ -1283,11 +1295,16 @@ export class WorkspaceSyncDurabilityStore {
         })();
     }
     listOutboxRecoveryTargets(input) {
+        return this.listOutboxRecoveryBaselineTargets(input).map(({ domain, entityId }) => ({ domain, entityId }));
+    }
+    listOutboxRecoveryBaselineTargets(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
+            SELECT target.domain, target.entity_id,
+                   source.dispatch_class, source.domain AS source_domain,
+                   source.mutation_kind AS source_mutation_kind
             FROM workspace_sync_outbox AS source
             INNER JOIN workspace_sync_outbox_targets AS target
               ON target.tenant_id = source.tenant_id
@@ -1298,14 +1315,52 @@ export class WorkspaceSyncDurabilityStore {
               AND source.recovery_batch_id = ?
               AND source.status = 'superseded'
               AND source.replay_of_operation_id IS NULL
-            ORDER BY target.domain, target.entity_id
+            ORDER BY target.domain, target.entity_id, source.enqueue_sequence, source.operation_id
         `).all(tenantId, workspaceId, recoveryBatchId);
-        if (rows.length === 0)
+        const targets = new Map();
+        for (const row of rows) {
+            const domain = requireText(row.domain, 'Recovery target domain');
+            const entityId = requireText(row.entity_id, 'Recovery target entity id');
+            const key = `${domain}\0${entityId}`;
+            const legacyAdoptionEvent = domain === 'entity-event'
+                && row.dispatch_class === 'legacy-adoption'
+                && row.source_domain === 'entity-event'
+                && row.source_mutation_kind === 'adopt-legacy-batch';
+            const existing = targets.get(key);
+            targets.set(key, {
+                domain,
+                entityId,
+                required: Boolean(existing?.required || !legacyAdoptionEvent),
+            });
+        }
+        const attachmentSources = this.db.prepare(`
+            SELECT source.client_id, source.operation_id, source.entity_id
+            FROM workspace_sync_outbox AS source
+            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
+              AND source.domain = 'task-attachment-links'
+              AND source.mutation_kind = 'replace'
+              AND source.last_error_code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID'
+        `).all(tenantId, workspaceId, recoveryBatchId);
+        for (const source of attachmentSources) {
+            const target = {
+                domain: 'entity-event',
+                entityId: buildTaskAttachmentLinksActivityEventId({
+                    workspaceId,
+                    clientId: requireText(source.client_id, 'Recovery client id'),
+                    operationId: requireText(source.operation_id, 'Recovery operation id'),
+                    taskId: requireText(source.entity_id, 'Recovery task id'),
+                }),
+                required: true,
+            };
+            targets.set(`${target.domain}\0${target.entityId}`, target);
+        }
+        const deduplicated = [...targets.values()].sort((left, right) => (compareCodeUnits(left.domain, right.domain) || compareCodeUnits(left.entityId, right.entityId)));
+        if (deduplicated.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'),
-        }));
+        return deduplicated;
     }
     prepareTaskRootOutboxRecoveryReplay(input) {
         const tenantId = requireText(input.tenantId, 'Tenant id');
@@ -1395,6 +1450,34 @@ export class WorkspaceSyncDurabilityStore {
                     this.readEntityEventLegacyAdoptionRecoveryIntent(workspaceId, source);
                 }
             }
+            const recoverySourceKey = (source) => (`${requireText(source.client_id, 'Source client id')}\0${requireText(source.operation_id, 'Source operation id')}`);
+            const legacyAdoptionEventsBySource = new Map();
+            const latestLegacyAdoptionSourceByEvent = new Map();
+            for (const source of recoverySources) {
+                if (source.dispatch_class !== 'legacy-adoption'
+                    || source.domain !== 'entity-event'
+                    || source.mutation_kind !== 'adopt-legacy-batch')
+                    continue;
+                const sourceKey = recoverySourceKey(source);
+                const events = this.readEntityEventLegacyAdoptionRecoveryIntent(workspaceId, source).events;
+                legacyAdoptionEventsBySource.set(sourceKey, events);
+                for (const event of events)
+                    latestLegacyAdoptionSourceByEvent.set(event.id, sourceKey);
+            }
+            const legacyAdoptionReplayEventsBySource = new Map();
+            for (const [sourceKey, events] of legacyAdoptionEventsBySource) {
+                legacyAdoptionReplayEventsBySource.set(sourceKey, events.filter((event) => {
+                    if (latestLegacyAdoptionSourceByEvent.get(event.id) !== sourceKey)
+                        return false;
+                    const revision = this.readEntityRevisionCoordinates({
+                        tenantId,
+                        workspaceId,
+                        domain: 'entity-event',
+                        entityId: event.id,
+                    });
+                    return revision.entityRevision === '0';
+                }));
+            }
             const latestAttachmentSourceByEntity = new Map();
             for (const source of recoverySources) {
                 if (source.domain === 'task-attachment-links' && source.mutation_kind === 'replace') {
@@ -1419,14 +1502,11 @@ export class WorkspaceSyncDurabilityStore {
                 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;
+                    // The authoritative baseline satisfies events already present in
+                    // cloud. A mixed legacy batch may also contain new immutable
+                    // events; replay only those still lacking authoritative ownership,
+                    // and let the latest overlapping batch own each event once.
+                    return (legacyAdoptionReplayEventsBySource.get(recoverySourceKey(source)) || []).length > 0;
                 }
                 if (Number(source.baseline_satisfaction_candidate || 0) !== 1) {
                     return true;
@@ -1492,7 +1572,22 @@ export class WorkspaceSyncDurabilityStore {
                     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));
+                const sourceKey = recoverySourceKey(source);
+                if (supportedEntityEventAdoption) {
+                    const events = legacyAdoptionReplayEventsBySource.get(sourceKey) || [];
+                    if (events.length === 0)
+                        throw new Error('Legacy entity-event adoption recovery replay is empty.');
+                    const payloadJson = canonicalWorkspaceSyncJson({ events });
+                    replayPayloads.set(sourceKey, {
+                        payloadJson,
+                        payloadFingerprint: fingerprintWorkspaceSyncPayload({ events }),
+                        replayMutationKind: 'adopt-legacy-batch',
+                        workflowDependencyCoalesced: false,
+                    });
+                }
+                else {
+                    replayPayloads.set(sourceKey, this.prepareRecoveryPayload(tenantId, workspaceId, source));
+                }
             }
             for (const source of sources) {
                 const sourceClientId = requireText(source.client_id, 'Source client id');
@@ -1512,11 +1607,22 @@ export class WorkspaceSyncDurabilityStore {
                     WHERE tenant_id = ? AND workspace_id = ? AND client_id = ? AND operation_id = ?
                     ORDER BY domain, entity_id
                 `).all(tenantId, workspaceId, sourceClientId, sourceOperationId);
+                const legacyReplayEvents = source.dispatch_class === 'legacy-adoption'
+                    && source.domain === 'entity-event'
+                    && source.mutation_kind === 'adopt-legacy-batch'
+                    ? legacyAdoptionReplayEventsBySource.get(recoverySourceKey(source)) || []
+                    : null;
+                const replayEventIds = legacyReplayEvents
+                    ? new Set(legacyReplayEvents.map((event) => event.id))
+                    : null;
                 const replayTargets = source.domain === 'task-comments'
                     && source.mutation_kind === 'append'
                     ? sourceTargets.filter((target) => (target.domain === 'task-comments'
                         && target.entity_id === source.entity_id))
-                    : sourceTargets;
+                    : replayEventIds
+                        ? sourceTargets.filter((target) => (target.domain === 'entity-event'
+                            && replayEventIds.has(String(target.entity_id || ''))))
+                        : sourceTargets;
                 if (replayTargets.length === 0)
                     throw new Error('Workspace sync recovery source has no targets.');
                 const targetRevisions = replayTargets.map((target) => ({
@@ -1528,7 +1634,9 @@ export class WorkspaceSyncDurabilityStore {
                         entityId: requireText(target.entity_id, 'Target entity id'),
                     }),
                 }));
-                const primary = targetRevisions.find(({ target }) => (target.domain === source.domain && target.entity_id === source.entity_id));
+                const replayEntityId = legacyReplayEvents?.[0]?.id
+                    || requireText(source.entity_id, 'Source entity id');
+                const primary = targetRevisions.find(({ target }) => (target.domain === source.domain && target.entity_id === replayEntityId));
                 if (!primary)
                     throw new Error('Workspace sync recovery source primary target is missing.');
                 const enqueueSequence = this.allocateOutboxEnqueueSequence(tenantId, workspaceId, now);
@@ -1545,7 +1653,7 @@ export class WorkspaceSyncDurabilityStore {
                     ) 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);
+                `).run(tenantId, workspaceId, operationId, WORKSPACE_SYNC_CONTRACT_VERSION, sourceClientId, requireOutboxDispatchClass(source.dispatch_class), requireText(source.domain, 'Source domain'), replayEntityId, 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 = ?,
@@ -1577,7 +1685,7 @@ export class WorkspaceSyncDurabilityStore {
                 `).get(tenantId, workspaceId, sourceClientId, operationId);
                 if (!replayRow
                     || replayRow.domain !== source.domain
-                    || replayRow.entity_id !== source.entity_id
+                    || replayRow.entity_id !== replayEntityId
                     || replayRow.mutation_kind !== replayPayload.replayMutationKind
                     || replayRow.payload_fingerprint !== replayPayload.payloadFingerprint
                     || replayRow.recovery_batch_id !== recoveryBatchId
@@ -1936,9 +2044,15 @@ export class WorkspaceSyncDurabilityStore {
               AND (
                 (domain = 'task-attachment-links' AND mutation_kind = 'replace')
                 OR (domain = 'task' AND mutation_kind = 'create')
+                OR (domain = 'workstream' AND mutation_kind IN ('create', 'metadata-update'))
+                OR (domain = 'initiative' AND mutation_kind IN ('create', 'metadata-update'))
               )
               AND status IN ('pending', 'in_flight')
-              AND last_error_code = 'TASK_ATTACHMENT_ASSET_NOT_READY'
+              AND last_error_code IN (
+                'TASK_ATTACHMENT_ASSET_NOT_READY',
+                'WORKSTREAM_ATTACHMENT_NOT_READY',
+                'INITIATIVE_ATTACHMENT_NOT_READY'
+              )
             ORDER BY enqueue_sequence
         `).all(tenantId, workspaceId, WORKSPACE_SYNC_CONTRACT_VERSION);
         const assetIds = new Set();
@@ -1952,9 +2066,13 @@ export class WorkspaceSyncDurabilityStore {
             }
             if (!payload || typeof payload !== 'object' || Array.isArray(payload))
                 continue;
-            const links = String(row.domain || '') === 'task'
+            const domain = String(row.domain || '');
+            const links = domain === 'task'
                 ? payload.attachmentLinks
-                : payload.links;
+                : domain === 'task-attachment-links'
+                    ? payload.links
+                    : payload.attachments
+                        ?? payload.patch?.attachments;
             if (!Array.isArray(links))
                 continue;
             for (const link of links) {
@@ -3268,9 +3386,9 @@ export class WorkspaceSyncDurabilityStore {
     // 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.
+    // metadata. It also covers an idempotent acknowledgement whose revision was
+    // advanced by the prerequisite V2 content push before local installation.
+    // Other metadata patches remain exact-revision operations and are excluded.
     requeueBoundedWorkstreamMetadataRevisionConflicts(input) {
         const tenantId = requireText(input.tenantId, 'Tenant id');
         const workspaceId = requireText(input.workspaceId, 'Workspace id');
@@ -3285,9 +3403,19 @@ export class WorkspaceSyncDurabilityStore {
                 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'
+              AND (
+                  (attempt_count = 1 AND last_error_code = 'WORKSPACE_SYNC_REVISION_CONFLICT')
+                  OR (
+                      last_error_code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID'
+                      AND last_error_message = 'Authoritative workstream revisions do not advance the captured bases exactly once.'
+                      AND json_type(payload_json, '$.patch.attachments') = 'array'
+                      AND NOT EXISTS (
+                          SELECT 1 FROM json_each(payload_json, '$.patch')
+                          WHERE key <> 'attachments'
+                      )
+                  )
+              )
         `).run(now, now, tenantId, workspaceId);
         return Number(result.changes || 0);
     }
@@ -3305,9 +3433,19 @@ export class WorkspaceSyncDurabilityStore {
                 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'
+              AND (
+                  (attempt_count = 1 AND last_error_code = 'WORKSPACE_SYNC_REVISION_CONFLICT')
+                  OR (
+                      last_error_code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID'
+                      AND last_error_message = 'Authoritative initiative revisions do not advance the captured bases exactly once.'
+                      AND json_type(payload_json, '$.patch.attachments') = 'array'
+                      AND NOT EXISTS (
+                          SELECT 1 FROM json_each(payload_json, '$.patch')
+                          WHERE key <> 'attachments'
+                      )
+                  )
+              )
         `).run(now, now, tenantId, workspaceId);
         return Number(result.changes || 0);
     }

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

@@ -99,6 +99,7 @@ export declare function runDurableTaskAttachmentLinksReplace(input: {
     operationId: string;
     taskId: string;
     links: readonly WorkspaceSyncV3TaskAttachmentLink[];
+    cardCoverAssetId?: string | null;
     baseEntityRevision: string | number;
     baseLifecycleRevision: string | number;
     now: string;

package/dist/sync/v3/taskAttachmentLinksMutationService.js

@@ -1,4 +1,4 @@
-import { projectResolvedTaskAttachmentLinksForDurableSync } from '../../core/TaskAttachmentLinksDurableMutationService.js';
+import { projectResolvedTaskAttachmentLinksForDurableSync, resolveTaskCardCoverAssetIdForLinks, } from '../../core/TaskAttachmentLinksDurableMutationService.js';
 import { serializeTaskRootForSync } from './workspaceSyncV3TaskRootProjection.js';
 import { buildTaskAttachmentLinksActivityEventId } from './taskAttachmentLinksActivityIdentity.js';
 import { asWorkspaceSyncActivityRevision, buildTaskActivityJournalEntry, canonicalizeEntityActivityDetailsForSync, serializeTaskActivityForSync, } from './taskActivityJournal.js';
@@ -57,6 +57,9 @@ export function runDurableTaskAttachmentLinksReplace(input) {
             domain: 'task-attachment-links', entityId: input.taskId, mutationKind: 'replace',
             baseEntityRevision: String(input.baseEntityRevision),
             baseLifecycleRevision: String(input.baseLifecycleRevision), links: requestedLinks,
+            ...(Object.prototype.hasOwnProperty.call(input, 'cardCoverAssetId')
+                ? { cardCoverAssetId: input.cardCoverAssetId }
+                : {}),
             ...(input.originActorRef ? { originActorRef: input.originActorRef } : {}),
         },
     });
@@ -113,6 +116,19 @@ export function runDurableTaskAttachmentLinksReplace(input) {
                         throw new DurableTaskAttachmentLinksMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
                     if (existing.isArchived)
                         throw new DurableTaskAttachmentLinksMutationError('Archived tasks are read-only. Unarchive first to make changes.', 'TASK_ARCHIVED_READ_ONLY', 409);
+                    let cardCoverAssetId;
+                    try {
+                        cardCoverAssetId = resolveTaskCardCoverAssetIdForLinks({
+                            currentCardCoverAssetId: existing.cardCoverAssetId,
+                            ...(Object.prototype.hasOwnProperty.call(input, 'cardCoverAssetId')
+                                ? { requestedCardCoverAssetId: input.cardCoverAssetId }
+                                : {}),
+                            links,
+                        });
+                    }
+                    catch (error) {
+                        throw new DurableTaskAttachmentLinksMutationError(error instanceof Error ? error.message : 'Task card cover is invalid.', 'TASK_ATTACHMENT_LINKS_INVALID', Number(error?.statusCode) || 400);
+                    }
                     const previousLinks = input.core.listTaskAttachmentLinksForDurableSync(input.taskId, input.workspaceId);
                     let attachments;
                     try {
@@ -126,7 +142,7 @@ export function runDurableTaskAttachmentLinksReplace(input) {
                     }
                     const updatedAt = nextUpdatedAt(String(existing.updatedAt || existing.createdAt), input.now);
                     const actorRef = resolveDeferredMutationActorRef(input);
-                    const task = input.core.updateTask(existing.id, { attachments }, input.workspaceId, {
+                    const task = input.core.updateTask(existing.id, { attachments, cardCoverAssetId }, input.workspaceId, {
                         persistBackup: false, emitRealtime: false, syncUpdatedAt: updatedAt,
                         actorRef, skipTaskEvents: true,
                         preferExplicitAttachmentRole: true,

package/dist/sync/v3/taskMetadataCoexistence.js

@@ -57,8 +57,12 @@ export function preserveV3OwnedTaskMetadata(incoming, existing) {
     return merged;
 }
 export function preserveV3OwnedTaskRoot(incoming, existing) {
+    const hasCardCoverAssetId = Object.prototype.hasOwnProperty.call(incoming, 'cardCoverAssetId');
     return {
         ...serializeTaskRootForSync(existing),
+        cardCoverAssetId: hasCardCoverAssetId
+            ? incoming.cardCoverAssetId ?? null
+            : existing.cardCoverAssetId ?? null,
         comments: incoming.comments ?? existing.comments,
         attachments: incoming.attachments ?? existing.attachments,
         checklistItems: incoming.checklistItems ?? existing.checklistItems,

package/dist/sync/v3/workspaceSyncV2ProjectionExclusions.js

@@ -50,9 +50,6 @@ export function prepareWorkspaceSyncV2TaskCarriers(taskMutations, excludedProjec
     const commentsOwned = excludedProjections.has('task-comments/full-v1');
     const checklistOwned = excludedProjections.has('task-checklist/full-v1');
     const attachmentsOwned = excludedProjections.has('task-attachment-links/full-v1');
-    if (commentsOwned && checklistOwned && attachmentsOwned) {
-        return { upserts: [], deletes: taskMutations.deletes };
-    }
     return {
         upserts: taskMutations.upserts.map(({ archived, task }) => {
             const existing = readExistingTask?.(String(task.id || '').trim());
@@ -104,13 +101,8 @@ export function partitionWorkspaceSyncV2LegacyChanges(changes, excludedProjectio
             const commentsOwned = excludedProjections.has('task-comments/full-v1');
             const checklistOwned = excludedProjections.has('task-checklist/full-v1');
             const attachmentsOwned = excludedProjections.has('task-attachment-links/full-v1');
-            if (excludedProjections.has('task/root-v1') && commentsOwned && checklistOwned && attachmentsOwned) {
+            if (excludedProjections.has('task/root-v1'))
                 suppress('task/root-v1');
-                suppress('task-comments/full-v1');
-                suppress('task-checklist/full-v1');
-                suppress('task-attachment-links/full-v1');
-                continue;
-            }
             if (commentsOwned || checklistOwned || attachmentsOwned) {
                 const task = { ...change.task };
                 if (commentsOwned) {

package/dist/sync/v3/workspaceSyncV3CloudOperationHandler.js

@@ -261,6 +261,7 @@ export function createWorkspaceSyncV3CloudOperationHandlers() {
                     ...withDeferredOriginActor(context, operation.payload.originActor),
                     taskId: operation.entityId,
                     links: operation.payload.links,
+                    cardCoverAssetId: operation.payload.cardCoverAssetId,
                     baseEntityRevision: operation.baseEntityRevision,
                     baseLifecycleRevision: operation.baseLifecycleRevision,
                 });

package/dist/sync/v3/workspaceSyncV3CombinedFeedOrchestrator.js

@@ -221,6 +221,12 @@ function peerReadinessError(response) {
         ? `Cloud combined workspace sync prerequisite is not ready (${firstMissing}).`
         : 'Cloud combined workspace sync capability attestation is missing or incompatible.';
 }
+function repairResponseError(response, workspaceId, expected) {
+    const code = String(response.data?.code || '').trim();
+    return code && !['CURSOR_EXPIRED', 'COVERAGE_CHANGED', 'EXPLICIT_REPAIR'].includes(code)
+        ? invalidRepairResponseError(response, workspaceId, expected)
+        : peerReadinessError(response);
+}
 function isUnavailablePersistedRepairCursor(response) {
     if (response.data?.success !== false)
         return false;
@@ -431,7 +437,7 @@ async function runWorkspaceSyncV3CombinedProjectionCycleInternal(input, staleRep
         }
         const repair = repairFromFeed(feed, input.workspaceId, coverage);
         if (!repair)
-            return localFailure(projection, peerReadinessError(feed));
+            return localFailure(projection, repairResponseError(feed, input.workspaceId, coverage));
         const applied = await applySelectedProjection(dependencies, input.workspaceId, {
             kind: 'repair', epoch: projection.epoch, previousCursor, page: repair,
             ...(input.recoveryBatchId ? { recoveryBatchId: input.recoveryBatchId } : {}),

package/dist/sync/v3/workspaceSyncV3CombinedLocalApply.js

@@ -172,6 +172,15 @@ function isExactNestedProjectionReplay(input) {
         && input.current.lastSequence === input.entry.sequence
         && input.current.canonicalFingerprint === (input.entry.canonicalFingerprint || input.entry.payloadFingerprint);
 }
+function isExactPlanningRootProjectionReplay(input) {
+    return (input.entry.projection === 'initiative/full-v1'
+        || input.entry.projection === 'workstream/full-v1')
+        && input.current.owned
+        && input.current.entityRevision === input.entry.entityRevision
+        && input.current.lifecycleRevision === input.entry.lifecycleRevision
+        && input.current.lastSequence === input.entry.sequence
+        && input.current.canonicalFingerprint === (input.entry.canonicalFingerprint || input.entry.payloadFingerprint);
+}
 function applyEntries(input) {
     const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
     const workflowApply = prepareWorkspaceSyncV3WorkflowRuntimeApply({
@@ -198,6 +207,7 @@ function applyEntries(input) {
                     workspaceId: input.workspaceId, domain: entry.domain, entityId: entry.entityId });
                 const exactTaskRootReplay = isExactTaskRootProjectionReplay({ entry, current });
                 const exactNestedReplay = isExactNestedProjectionReplay({ entry, current });
+                const exactPlanningRootReplay = isExactPlanningRootProjectionReplay({ entry, current });
                 const applyEntry = () => {
                     if (entry.projection === 'task/root-v1') {
                         taskChange = applyTaskEntry({ core: input.core, workspaceId: input.workspaceId, entry });
@@ -259,7 +269,7 @@ function applyEntries(input) {
                     }
                 };
                 let applied;
-                if (exactTaskRootReplay || exactNestedReplay) {
+                if (exactTaskRootReplay || exactNestedReplay || exactPlanningRootReplay) {
                     const result = applyEntry();
                     applied = result?.state === 'deferred'
                         ? { state: 'deferred' }
@@ -957,13 +967,15 @@ export function applyWorkspaceSyncV3CombinedRepairPage(input) {
         })();
     }
     const recoveryTargets = recoveryBatchId
-        ? recoveryStore.listOutboxRecoveryTargets({ tenantId, workspaceId, recoveryBatchId })
+        ? recoveryStore.listOutboxRecoveryBaselineTargets({ tenantId, workspaceId, recoveryBatchId })
         : [];
     const selectRecoveryEntries = (entries) => {
         const byTarget = new Map(entries.map((entry) => [`${entry.domain}\0${entry.entityId}`, entry]));
         return recoveryTargets.map((target) => {
             const entry = byTarget.get(`${target.domain}\0${target.entityId}`);
             if (!entry) {
+                if (!target.required)
+                    return null;
                 throw staleRepairSnapshotError(target.domain, target.entityId);
             }
             const supportedTarget = ((target.domain === 'task' && entry.projection === 'task/root-v1')
@@ -975,7 +987,7 @@ export function applyWorkspaceSyncV3CombinedRepairPage(input) {
                 throw new Error('Targeted workspace sync recovery does not support this projection.');
             }
             return entry;
-        });
+        }).filter((entry) => entry !== null);
     };
     const projections = coveredProjections(input.page);
     let notices = notifications();