@taskforcehq/taskforce 0.3.328 → 0.3.329

package/dist/sync/engine/workspaceSyncEngineServerRunnerOperations.js

@@ -6,6 +6,7 @@ import { runWorkspaceSyncV3CombinedProjectionCycle } from '../v3/workspaceSyncV3
 import { runWorkspaceSyncV3InitiativeProjectionCycle } from '../v3/workspaceSyncV3FeedOrchestrator.js';
 import { normalizeWorkspaceSyncV2ProjectionExclusions } from '../v3/workspaceSyncV2ProjectionExclusions.js';
 import { canonicalWorkspaceSyncJson } from '../v3/canonicalWorkspaceSyncJson.js';
+import { authoritativeV2ApplyFailureMessage, } from './workspaceSyncEngineLocalServices.js';
 import { combinedAttachmentAssetHydrationId, createWorkspaceSyncV3TransferBindings, } from './workspaceSyncEngineTransfers.js';
 import { createWorkspaceSyncTransferEvidence, } from './workspaceSyncTransferEvidence.js';
 const NOOP_CLOUD_RESOLVER = (path) => path;
@@ -13,6 +14,7 @@ const RETRY_BASE_DELAY_MS = 1_000;
 const RETRY_MAX_DELAY_MS = 5 * 60_000;
 const COMBINED_FEED_COVERED_OUTBOX_BLOCK = 'WORKSPACE_SYNC_V3_COVERED_LOCAL_OPERATIONS';
 const REPAIR_OWNERSHIP_FINGERPRINT_VERSION = 2;
+const NON_APPLYING_ACKNOWLEDGEMENT_CHECKPOINT_INTERVAL = 64;
 class WorkspaceSyncEngineServerRunnerOperationError extends Error {
     code;
     retryAfterMs;
@@ -513,7 +515,9 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                     ? 'repair'
                     : 'push';
             activeRetryKind = pushRetryKind;
-            persist({ ...checkpoint, controlState: 'pushing' });
+            if (checkpoint.controlState !== 'pushing') {
+                persist({ ...checkpoint, controlState: 'pushing' });
+            }
             let payload;
             let signature;
             if (checkpoint.pendingV2Push) {
@@ -551,11 +555,13 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 persist({ ...checkpoint, pendingV2Push });
             }
             if (checkpoint.remoteHintObservedAt) {
-                persist({
+                checkpoint = {
                     ...checkpoint,
                     consecutivePushesWhilePullDue: Math.min(Number.MAX_SAFE_INTEGER, checkpoint.consecutivePushesWhilePullDue + 1),
-                });
+                };
             }
+            let persistedAcknowledgementCount = checkpoint.pendingV2Push
+                ?.acknowledgedNonApplyingBatchOperationIdentities.length || 0;
             const result = await runWorkspacePushSyncService({
                 resolveCloudAuthUrl: NOOP_CLOUD_RESOLVER,
                 workspaceId,
@@ -583,13 +589,14 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                             ],
                         },
                     });
+                    persistedAcknowledgementCount = acknowledgedOperationIdentities.length;
                 },
                 onNonApplyingBatchAcknowledged: ({ acknowledgedOperationIdentities }) => {
                     const pendingV2Push = checkpoint.pendingV2Push;
                     if (!pendingV2Push) {
                         throw new WorkspaceSyncEngineServerRunnerOperationError('The frozen V2 push disappeared while recording batch progress.', 'SYNC_RUNNER_PUSH_CHECKPOINT_INVALID');
                     }
-                    persist({
+                    checkpoint = {
                         ...checkpoint,
                         pendingV2Push: {
                             ...pendingV2Push,
@@ -597,19 +604,25 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                                 ...acknowledgedOperationIdentities,
                             ],
                         },
-                    });
+                    };
+                    if (acknowledgedOperationIdentities.length
+                        - persistedAcknowledgementCount
+                        >= NON_APPLYING_ACKNOWLEDGEMENT_CHECKPOINT_INTERVAL) {
+                        persist(checkpoint);
+                        persistedAcknowledgementCount = acknowledgedOperationIdentities.length;
+                    }
                 },
             });
             onResult?.(result);
             if (!result.success) {
                 if (result.batchProgress && checkpoint.pendingV2Push) {
-                    persist({
+                    checkpoint = {
                         ...checkpoint,
                         pendingV2Push: {
                             ...checkpoint.pendingV2Push,
                             lastBatchProgress: structuredClone(result.batchProgress),
                         },
-                    });
+                    };
                 }
                 const message = pushFailureMessage(result);
                 if (isAuthFailure(result)) {
@@ -692,6 +705,8 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                             ? { durableRevision: entry.durableRevision }
                             : {}),
                     })), {
+                        repairMode: attemptOptions.repairMode,
+                        excludedProjections: result.effectiveV2ExcludedProjections,
                         ...(completionGroup ? { completionGroup } : {}),
                         commitServerCheckpoint: () => {
                             const persisted = input.persistCheckpoint(nextCheckpoint, {
@@ -711,7 +726,9 @@ export function createWorkspaceSyncEngineServerRunnerOperations(options) {
                 }
                 if (!applyResult.ok || !commitState.checkpoint) {
                     await abandonPushReceipts('WORKSPACE_SYNC_V2_PUSH_AUTHORITATIVE_APPLY_FAILED');
-                    throw new WorkspaceSyncEngineServerRunnerOperationError(`Authoritative V2 push echo apply failed (${applyResult.status || 0}).`, 'SYNC_RUNNER_PUSH_AUTHORITATIVE_APPLY_FAILED');
+                    throw new WorkspaceSyncEngineServerRunnerOperationError(!applyResult.ok
+                        ? authoritativeV2ApplyFailureMessage(applyResult)
+                        : 'Authoritative V2 push echo did not commit the server checkpoint.', 'SYNC_RUNNER_PUSH_AUTHORITATIVE_APPLY_FAILED');
                 }
                 const committedCheckpoint = commitState.checkpoint;
                 if (!committedCheckpoint) {

package/dist/sync/engine/workspaceSyncEngineTransfers.d.ts

@@ -3,7 +3,7 @@ import type { WorkspaceSyncPayload } from '../workspaceSyncModel.js';
 import type { WorkspaceSyncPhase } from '../workspaceSyncState.js';
 import type { WorkspaceSyncV3CombinedCoverageSelector } from '../v3/workspaceSyncV3CombinedWireContract.js';
 import type { WorkspaceSyncEngineRuntime } from './workspaceSyncEngineRuntime.js';
-import type { WorkspaceSyncEngineLocalServices } from './workspaceSyncEngineLocalServices.js';
+import { type WorkspaceSyncEngineLocalServices } from './workspaceSyncEngineLocalServices.js';
 import type { WorkspaceSyncEngineRemoteServices, WorkspaceSyncEngineRemoteTransferReceipt } from './workspaceSyncEngineRemoteServices.js';
 export type { PendingWorkspacePushReplay } from './workspaceSyncEngineTransferTypes.js';
 type StateSetter<T> = (value: T | ((current: T) => T)) => void;

package/dist/sync/engine/workspaceSyncEngineTransfers.js

@@ -4,6 +4,7 @@ import { resolveWorkspacePullRequestPlan, resolveWorkspacePullSuccessPlan } from
 import { runWorkspaceSyncV3InitiativeProjectionCycle } from '../v3/workspaceSyncV3FeedOrchestrator.js';
 import { runWorkspaceSyncV3CombinedProjectionCycle } from '../v3/workspaceSyncV3CombinedFeedOrchestrator.js';
 import { hydrateWorkspaceSyncV3AttachmentAsset } from '../v3/workspaceSyncV3AttachmentAssetHydration.js';
+import { authoritativeV2ApplyFailureMessage, } from './workspaceSyncEngineLocalServices.js';
 import { WORKSPACE_SYNC_V3_APPLY_NOT_COMMITTED } from './workspaceSyncEngineRemoteServices.js';
 export function combinedAttachmentAssetHydrationId(input) {
     if (input.causeCode === 'TASK_ATTACHMENT_ASSET_NOT_READY' && input.causeAssetId) {
@@ -391,6 +392,10 @@ export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtim
                 }
                 let applyResult;
                 try {
+                    const applyOptions = {
+                        repairMode: replayPayload?.repairMode ?? repairMode,
+                        excludedProjections: pushResult.effectiveV2ExcludedProjections,
+                    };
                     const authoritativeChanges = appliedTaskUpserts.map((entry) => ({
                         op: 'upsert',
                         archived: entry.archived === true,
@@ -398,8 +403,8 @@ export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtim
                         ...(entry.durableRevision ? { durableRevision: entry.durableRevision } : {}),
                     }));
                     applyResult = completionGroup
-                        ? await localServices.applyV2Batch(currentWorkspaceId, authoritativeChanges, { completionGroup })
-                        : await localServices.applyV2Batch(currentWorkspaceId, authoritativeChanges);
+                        ? await localServices.applyV2Batch(currentWorkspaceId, authoritativeChanges, { ...applyOptions, completionGroup })
+                        : await localServices.applyV2Batch(currentWorkspaceId, authoritativeChanges, applyOptions);
                 }
                 catch (error) {
                     if (pushTransferReceipts.length > 0) {
@@ -419,7 +424,7 @@ export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtim
                             errorCode: 'WORKSPACE_SYNC_V2_PUSH_AUTHORITATIVE_APPLY_FAILED',
                         });
                     }
-                    throw new Error(`Authoritative V2 push echo apply failed (${applyResult.status || 0}).`);
+                    throw new Error(authoritativeV2ApplyFailureMessage(applyResult));
                 }
                 for (const entry of appliedTaskUpserts) {
                     const taskId = String(entry.task.id || '').trim();

package/dist/sync/syncService.d.ts

@@ -77,6 +77,8 @@ export interface WorkspacePushSyncResult {
     effectiveDeltaDiagnostics?: WorkspaceSyncDeltaDiagnostics & {
         combinedV3SuppressedChangeCount?: number;
     };
+    /** Exact V3-owned projections excluded while preparing this V2 attempt. */
+    effectiveV2ExcludedProjections?: readonly WorkspaceSyncV2ProjectionExclusion[];
     deleteCount: number;
     currentTaskIds: Set<string>;
     currentTaskWatermarks?: Map<string, string>;

package/dist/sync/syncService.js

@@ -5,7 +5,7 @@ import { createWorkspaceSyncEngineV2PushBoundary, parseWorkspaceSyncEngineApplie
 import { encryptDocument } from './encryptionService.js';
 import { decryptWorkspaceSyncContentChangeInPlace } from './workspaceSyncContentDecryption.js';
 import { decideWorkspaceContentFetch, fingerprintWorkspaceContentBody, } from './workspaceContentManifest.js';
-import { workspaceSyncV2ProjectionExclusionsEqual, } from './v3/workspaceSyncV2ProjectionExclusions.js';
+import { normalizeWorkspaceSyncV2ProjectionExclusions, workspaceSyncV2ProjectionExclusionsEqual, } from './v3/workspaceSyncV2ProjectionExclusions.js';
 import { WORKSPACE_PUSH_PREPARED_PLAN_VERSION, } from './workspacePushPreparedPlan.js';
 import { canonicalWorkspaceSyncJson } from './v3/canonicalWorkspaceSyncJson.js';
 function asObjectRecord(value) {
@@ -464,6 +464,7 @@ export async function runWorkspacePushSyncService(input) {
     }
     const changeCount = preparedChanges.length;
     const effectiveDeltaDiagnostics = buildEffectiveWorkspacePushDiagnostics(input.payload.deltaDiagnostics, preparedChanges, preparedOwnership);
+    const effectiveV2ExcludedProjections = normalizeWorkspaceSyncV2ProjectionExclusions(preparedOwnership.combinedExcludedProjections || []);
     const deleteCount = input.payload.deleteTaskIds.size;
     let requestMs = 0;
     const canElideSteadyStateRequest = changeCount === 0
@@ -478,6 +479,7 @@ export async function runWorkspacePushSyncService(input) {
             requestMs: 0,
             changeCount: 0,
             effectiveDeltaDiagnostics,
+            effectiveV2ExcludedProjections,
             deleteCount,
             currentTaskIds: input.payload.currentTaskIds,
             currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
@@ -841,6 +843,7 @@ export async function runWorkspacePushSyncService(input) {
             failureDomain: null,
         },
         effectiveDeltaDiagnostics,
+        effectiveV2ExcludedProjections,
         deleteCount,
         currentTaskIds: input.payload.currentTaskIds,
         currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),

package/dist/sync/v3/combinedFeedCapability.js

@@ -3,6 +3,7 @@ import { WORKSPACE_SYNC_V3_COMBINED_CAPABILITY_VERSION, WORKSPACE_SYNC_V3_COMBIN
 import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR } from './workspaceSyncV3NestedWireContract.js';
 import { WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR } from './workspaceSyncV3WorkflowWireContract.js';
 import { WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR } from './workspaceSyncV3PlanningOrderWireContract.js';
+import { WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR } from './workspaceSyncV3TaskCoverWireContract.js';
 export { WORKSPACE_SYNC_V3_COMBINED_CAPABILITY_VERSION } from './workspaceSyncV3CombinedWireContract.js';
 export function resolveRequestedCombinedFeedCoverage(env = process.env) {
     const requestedVersion = String(env.TASKFORCE_SYNC_V3_COMBINED_FEED_COVERAGE_VERSION || '').trim();
@@ -18,6 +19,9 @@ export function resolveRequestedCombinedFeedCoverage(env = process.env) {
     if (requestedVersion === String(WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR.coverageVersion)) {
         return WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR;
     }
+    if (requestedVersion === String(WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR.coverageVersion)) {
+        return WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR;
+    }
     throw new Error(`Unsupported TASKFORCE_SYNC_V3_COMBINED_FEED_COVERAGE_VERSION: ${requestedVersion}.`);
 }
 export function resolveCombinedFeedCapability(input) {

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

@@ -12,6 +12,7 @@ export declare function resolveTaskAttachmentLinksMutationCapability(input: {
 export type DurableTaskAttachmentLinksMutationRouterCore = DurableTaskAttachmentLinksServiceCore & LocalTaskAttachmentLinksOutboxCore & {
     getDatabaseAdapter(): DatabaseAdapter;
     getTask(id: string, workspaceId?: string): TaskItem | null;
+    assertTaskDetailRevisionForUpdate(id: string, expected: string, workspaceId?: string): void;
 };
 export declare class DurableTaskAttachmentLinksRouterDisabledError extends Error {
     readonly code = "WORKSPACE_SYNC_V3_TASK_ATTACHMENT_LINKS_ROUTER_DISABLED";
@@ -41,6 +42,7 @@ export declare function createDurableTaskAttachmentLinksMutationRouter(input: {
         taskId: string;
         links: readonly WorkspaceSyncV3TaskAttachmentLink[];
         cardCoverAssetId?: string | null;
+        expectedDetailRevision?: string;
     }): {
         state: "pending" | "committed";
         route: "local-outbox" | "cloud-acceptance";

package/dist/sync/v3/durableTaskAttachmentLinksMutationRouter.js

@@ -140,7 +140,13 @@ export function createDurableTaskAttachmentLinksMutationRouter(input) {
                     catch {
                         throw new DurableTaskAttachmentLinksMutationError('Captured task attachment-link payload is invalid.', 'TASK_ATTACHMENT_LINKS_IDENTITY_CONFLICT', 409);
                     }
-                    if (canonicalWorkspaceSyncJson(frozen) !== canonicalWorkspaceSyncJson(links)
+                    const relationshipIntent = (entries) => entries.map((link) => ({
+                        assetId: link.assetId,
+                        role: link.role,
+                        order: link.order,
+                    }));
+                    if (canonicalWorkspaceSyncJson(relationshipIntent(frozen))
+                        !== canonicalWorkspaceSyncJson(relationshipIntent(links))
                         || String(payload.cardCoverAssetId || '') !== String(cardCoverAssetId || '')) {
                         throw new DurableTaskAttachmentLinksMutationError('Operation identity is assigned to different task attachment links.', 'TASK_ATTACHMENT_LINKS_IDENTITY_CONFLICT', 409);
                     }
@@ -204,6 +210,10 @@ export function createDurableTaskAttachmentLinksMutationRouter(input) {
                 baseEntityRevision: coordinates.entityRevision, baseLifecycleRevision: coordinates.lifecycleRevision,
                 now: acceptedAtIso, leaseExpiresAt: new Date(acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
                 actorRef, onPostCommitError: input.onPostCommitError,
+                expectedDetailRevision: args.expectedDetailRevision,
+                assertPrecondition: args.expectedDetailRevision
+                    ? () => input.core.assertTaskDetailRevisionForUpdate(taskId, args.expectedDetailRevision, workspaceId)
+                    : undefined,
             });
             if (result.state === 'in_progress')
                 throw new DurableTaskAttachmentLinksRouterInProgressError(result.retryAt);

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

@@ -11,6 +11,7 @@ export declare function resolveTaskChecklistMutationCapability(input: {
 export type DurableTaskChecklistMutationRouterCore = DurableTaskChecklistServiceCore & LocalTaskChecklistOutboxCore & {
     getDatabaseAdapter(): DatabaseAdapter;
     getTask(id: string, workspaceId?: string): TaskItem | null;
+    assertTaskDetailRevisionForUpdate(id: string, expected: string, workspaceId?: string): void;
 };
 export declare class DurableTaskChecklistRouterDisabledError extends Error {
     readonly code = "WORKSPACE_SYNC_V3_TASK_CHECKLIST_ROUTER_DISABLED";
@@ -38,6 +39,7 @@ export declare function createDurableTaskChecklistMutationRouter(input: {
     replace(args: {
         taskId: string;
         items: readonly Partial<ChecklistItem>[];
+        expectedDetailRevision?: string;
     }): {
         state: "pending" | "committed";
         route: "local-outbox" | "cloud-acceptance";

package/dist/sync/v3/durableTaskChecklistMutationRouter.js

@@ -170,6 +170,10 @@ export function createDurableTaskChecklistMutationRouter(input) {
                 baseEntityRevision: coordinates.entityRevision, baseLifecycleRevision: coordinates.lifecycleRevision,
                 now: acceptedAtIso, leaseExpiresAt: new Date(acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
                 actorRef, onPostCommitError: input.onPostCommitError,
+                expectedDetailRevision: args.expectedDetailRevision,
+                assertPrecondition: args.expectedDetailRevision
+                    ? () => input.core.assertTaskDetailRevisionForUpdate(taskId, args.expectedDetailRevision, workspaceId)
+                    : undefined,
             });
             if (result.state === 'in_progress')
                 throw new DurableTaskChecklistRouterInProgressError(result.retryAt);

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

@@ -51,6 +51,7 @@ export declare function createDurableTaskHttpBulkMutationRouter(input: {
     }>, options?: {
         saveSource?: "manual" | "autosave";
         atomicItemFailures?: boolean;
+        expectedDetailRevision?: string;
     }): {
         preview: import("../../core/Taskforce.js").BulkUpdateFieldsPreview;
         results: TaskItem[];

package/dist/sync/v3/durableTaskHttpBulkMutationRouter.js

@@ -222,7 +222,12 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
             }, { atomicRecovery: true });
         },
         updateFields(updates, options = {}) {
-            return input.rootRouter.runBatch('bulk-update-fields', { updates }, (batch) => {
+            return input.rootRouter.runBatch('bulk-update-fields', {
+                updates,
+                ...(options.expectedDetailRevision
+                    ? { expectedDetailRevision: options.expectedDetailRevision }
+                    : {}),
+            }, (batch) => {
                 const preview = input.core.bulkUpdateFieldsPreview(updates, input.workspaceId);
                 const results = [];
                 const errors = preview.skipped
@@ -273,14 +278,21 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
                                 && !(durableAttachmentLinks && key === 'cardCoverAssetId'))))
                             : item.fields;
                         let updated = input.core.getTask(item.id, input.workspaceId);
+                        let expectedDetailRevision = options.expectedDetailRevision;
                         if (Object.keys(rootFields).length > 0) {
                             const child = input.createChildRouter(input.deriveChildOperationId('bulk-update-fields-root', item.index, item.id), () => { });
                             updated = child.enabled
-                                ? batch.runChild(() => child.update(item.id, rootFields, options.saveSource || 'manual'))
-                                : input.core.updateTask(item.id, rootFields, input.workspaceId, {
-                                    actorRef: 'user',
-                                    saveSource: options.saveSource || 'manual',
-                                });
+                                ? batch.runChild(() => child.update(item.id, rootFields, options.saveSource || 'manual', undefined, expectedDetailRevision))
+                                : (() => {
+                                    if (expectedDetailRevision) {
+                                        input.core.assertTaskDetailRevisionForUpdate(item.id, expectedDetailRevision, input.workspaceId);
+                                    }
+                                    return input.core.updateTask(item.id, rootFields, input.workspaceId, {
+                                        actorRef: 'user',
+                                        saveSource: options.saveSource || 'manual',
+                                    });
+                                })();
+                            expectedDetailRevision = undefined;
                         }
                         if (durableChecklist && checklist) {
                             const currentTask = input.core.getTask(item.id, input.workspaceId) || updated;
@@ -301,7 +313,12 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
                                     updatedAt: String(unchanged ? existing.updatedAt : existing ? now : source.updatedAt || createdAt),
                                 };
                             });
-                            updated = batch.runChild(() => checklist.replace({ taskId: item.id, items: normalizedChecklist }).task);
+                            updated = batch.runChild(() => checklist.replace({
+                                taskId: item.id,
+                                items: normalizedChecklist,
+                                expectedDetailRevision,
+                            }).task);
+                            expectedDetailRevision = undefined;
                         }
                         if (durableAttachmentLinks && attachmentLinks) {
                             updated = batch.runChild(() => attachmentLinks.replace({
@@ -312,7 +329,9 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
                                         ? null
                                         : String(item.fields.cardCoverAssetId).trim(),
                                 } : {}),
+                                expectedDetailRevision,
                             }).task);
+                            expectedDetailRevision = undefined;
                         }
                         if (updated)
                             results.push(updated);
@@ -327,7 +346,10 @@ export function createDurableTaskHttpBulkMutationRouter(input) {
                 }
                 batch.deferPostCommitNotification(() => input.core.notifyDurableTaskBatchCommitted(input.workspaceId, results.map((task) => task.id)));
                 return { preview, results, errors };
-            }, { atomicRecovery: true, allowIndependentNestedOwnership: true });
+            }, {
+                atomicRecovery: true,
+                allowIndependentNestedOwnership: true,
+            });
         },
     };
 }

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

@@ -3,7 +3,8 @@ import type { TaskRestoreDestination } from '../../shared/taskRestoreDestination
 export declare class DurableTaskHttpRootMutationError extends Error {
     readonly code: string;
     readonly statusCode: number;
-    constructor(message: string, code: string, statusCode: number);
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, statusCode: number, details?: Record<string, unknown> | undefined);
 }
 export declare function resolveTaskHttpRootMutationCapability(input: {
     runtimeMode: 'local' | 'cloud';
@@ -22,8 +23,9 @@ export declare function createDurableTaskHttpRootMutationRouter(input: {
     deferPostCommitNotification?: (notify: () => void) => void;
 }): {
     enabled: boolean;
+    hasCommittedOperation(): boolean;
     create(candidate: unknown): TaskItem;
-    update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed"): TaskItem;
+    update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed", expectedDetailRevision?: string): TaskItem;
     runBatch<T>(routeInput: string, request: unknown, apply: (context: {
         runChild<R>(mutation: () => R): R;
         deferPostCommitNotification(notify: () => void): void;
@@ -36,5 +38,5 @@ export declare function createDurableTaskHttpRootMutationRouter(input: {
     restore(deletedRecordIdInput: string, restoreDestination?: TaskRestoreDestination): TaskItem;
     delete(taskIdInput: string): DeletedTaskRecord;
 };
-type TaskforceCoreForHttpRootMutation = Pick<import('../../core/Taskforce.js').TaskforceCore, 'getDatabaseAdapter' | 'getTask' | 'listAssignableActors' | 'getDeletedTask' | 'updateTask' | 'hasTaskDeletionMarkerForSync' | 'createTask' | 'listTaskAttachmentLinksForDurableSync' | 'resolveTaskAttachmentLinksForDurableSync' | 'normalizeTaskAttachmentDescriptorsForDurableSync' | 'notifyDurableTaskCreateCommitted' | 'notifyDurableTaskBatchCommitted' | 'notifyDurableTaskMetadataCommitted' | 'notifyDurableTaskLifecycleCommitted' | 'notifyDurableTaskDeleteCommitted' | 'getTaskEventForSync' | 'getEntityEventForSync' | 'lockTaskLifecycleMutationDomain' | 'archiveTask' | 'unarchiveTask' | 'restoreDeletedTask' | 'addTaskStatusEventsForDurableSync' | 'lockTaskRelationshipMutationDomain' | 'listTaskRelationships' | 'getTaskRelationshipForSync' | 'deleteTaskForSync'>;
+type TaskforceCoreForHttpRootMutation = Pick<import('../../core/Taskforce.js').TaskforceCore, 'getDatabaseAdapter' | 'getTask' | 'getTaskDetailRevision' | 'assertTaskDetailRevisionForUpdate' | 'listAssignableActors' | 'getDeletedTask' | 'updateTask' | 'hasTaskDeletionMarkerForSync' | 'createTask' | 'listTaskAttachmentLinksForDurableSync' | 'resolveTaskAttachmentLinksForDurableSync' | 'normalizeTaskAttachmentDescriptorsForDurableSync' | 'notifyDurableTaskCreateCommitted' | 'notifyDurableTaskBatchCommitted' | 'notifyDurableTaskMetadataCommitted' | 'notifyDurableTaskLifecycleCommitted' | 'notifyDurableTaskDeleteCommitted' | 'getTaskEventForSync' | 'getEntityEventForSync' | 'lockTaskLifecycleMutationDomain' | 'archiveTask' | 'unarchiveTask' | 'restoreDeletedTask' | 'addTaskStatusEventsForDurableSync' | 'lockTaskRelationshipMutationDomain' | 'listTaskRelationships' | 'getTaskRelationshipForSync' | 'deleteTaskForSync'>;
 export {};

package/dist/sync/v3/durableTaskHttpRootMutationRouter.js

@@ -28,10 +28,12 @@ function requiredText(value, label) {
 export class DurableTaskHttpRootMutationError extends Error {
     code;
     statusCode;
-    constructor(message, code, statusCode) {
+    details;
+    constructor(message, code, statusCode, details) {
         super(message);
         this.code = code;
         this.statusCode = statusCode;
+        this.details = details;
         this.name = 'DurableTaskHttpRootMutationError';
     }
 }
@@ -120,6 +122,11 @@ export function createDurableTaskHttpRootMutationRouter(input) {
             rethrowDurableReplayError(error, 'Committed durable task HTTP response is invalid.');
         }
     };
+    const detailRevisionPrecondition = (taskId, expectedDetailRevision) => {
+        if (!expectedDetailRevision)
+            return undefined;
+        return () => input.core.assertTaskDetailRevisionForUpdate(taskId, expectedDetailRevision, input.workspaceId);
+    };
     const lifecycle = (taskIdInput, mutationKind, payload) => {
         const taskId = requiredText(taskIdInput, 'Task id');
         const operation = context();
@@ -144,6 +151,12 @@ export function createDurableTaskHttpRootMutationRouter(input) {
     };
     return {
         enabled,
+        hasCommittedOperation() {
+            const operationId = String(input.operationId || '').trim();
+            if (!operationId)
+                return false;
+            return Boolean(store.readCommittedOperationResponse(operationIdentity(operationId)));
+        },
         create(candidate) {
             const source = candidate && typeof candidate === 'object' && !Array.isArray(candidate)
                 ? candidate
@@ -183,7 +196,7 @@ export function createDurableTaskHttpRootMutationRouter(input) {
                 throw new DurableTaskHttpRootMutationError('The durable task mutation is already in progress.', 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS', 409);
             return result.response.authoritative.payload;
         },
-        update(taskIdInput, candidate, saveSource, activityAction) {
+        update(taskIdInput, candidate, saveSource, activityAction, expectedDetailRevision) {
             const taskId = requiredText(taskIdInput, 'Task id');
             if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
                 throw new DurableTaskHttpRootMutationError('Task patch must be an object.', 'DURABLE_TASK_PATCH_INVALID', 400);
@@ -224,6 +237,8 @@ export function createDurableTaskHttpRootMutationRouter(input) {
                     now: operation.acceptedAtIso,
                     leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
                     actorRef: input.actorRef,
+                    expectedDetailRevision,
+                    assertPrecondition: detailRevisionPrecondition(taskId, expectedDetailRevision),
                     onPostCommitError: input.onPostCommitError,
                 });
                 if (result.state === 'in_progress')
@@ -283,6 +298,8 @@ export function createDurableTaskHttpRootMutationRouter(input) {
                     actorRef: input.actorRef,
                     saveSource,
                     activityAction,
+                    expectedDetailRevision,
+                    assertPrecondition: detailRevisionPrecondition(taskId, expectedDetailRevision),
                     onPostCommitError: input.onPostCommitError,
                 });
                 if (result.state === 'in_progress')
@@ -341,6 +358,14 @@ export function createDurableTaskHttpRootMutationRouter(input) {
             if (options?.atomicRecovery) {
                 const notifications = [];
                 const result = input.core.getDatabaseAdapter().transaction(() => {
+                    // Child durable mutations lock the workspace sequence before
+                    // touching task rows. Take the same lock first when a batch
+                    // may combine a legacy root write with durable child owners.
+                    store.lockWorkspaceSequenceForMutation({
+                        tenantId: input.tenantId,
+                        workspaceId: input.workspaceId,
+                        now: operation.acceptedAtIso,
+                    });
                     const value = apply({
                         runChild: (mutation) => input.core.getDatabaseAdapter().transaction(mutation)(),
                         deferPostCommitNotification: (notify) => notifications.push(notify),

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

@@ -1,8 +1,10 @@
 import type { TaskEvent, TaskItem } from '../../core/Taskforce.js';
+import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
 import type { DurableTaskAttachmentLinksServiceCore } from './taskAttachmentLinksMutationService.js';
 import { WorkspaceSyncDurabilityStore, type WorkspaceSyncOperationIdentity } from './syncDurabilityStore.js';
 import { type WorkspaceSyncV3TaskAttachmentLink } from './workspaceSyncV3NestedTaskCodecs.js';
 export interface LocalTaskAttachmentLinksOutboxCore extends DurableTaskAttachmentLinksServiceCore {
+    getDatabaseAdapter(): DatabaseAdapter;
     getWorkspaceAssetDispatchReadiness(assetId: string, workspaceId: string): {
         ready: boolean;
         retryable: boolean;

package/dist/sync/v3/localTaskAttachmentLinksOutboxService.js

@@ -5,7 +5,9 @@ import { buildTaskAttachmentLinksActivityEventId } from './taskAttachmentLinksAc
 import { canonicalizeEntityActivityDetailsForSync, serializeTaskActivityForSync, } from './taskActivityJournal.js';
 import { fingerprintWorkspaceSyncPayload, } from './syncDurabilityStore.js';
 import { serializeTaskRootForSync } from './workspaceSyncV3TaskRootProjection.js';
-import { serializeWorkspaceSyncV3TaskAttachmentLinksPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+import { resolveWorkspaceSyncV3RegisteredCoverage } from './workspaceSyncV3CoverageRegistry.js';
+import { WorkspaceSyncV3CombinedProjectionStateStore } from './workspaceSyncV3CombinedProjectionState.js';
+import { serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskAttachmentLinksV2Payload, validateWorkspaceSyncV3TaskAttachmentLinksPayload, validateWorkspaceSyncV3TaskAttachmentLinksV2Payload, } from './workspaceSyncV3NestedTaskCodecs.js';
 import { withOriginActorPayload } from './workspaceSyncV3OriginActor.js';
 export class LocalAuthoritativeTaskAttachmentLinksError extends Error {
     code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID';
@@ -90,6 +92,24 @@ function requireRevision(value, label) {
         throw new LocalAuthoritativeTaskAttachmentLinksError(`${label} is invalid.`);
     return text;
 }
+function resolveOwnedAttachmentProjection(input) {
+    const state = new WorkspaceSyncV3CombinedProjectionStateStore(input.core.getDatabaseAdapter()).read({
+        tenantId: input.identity.tenantId,
+        workspaceId: input.identity.workspaceId,
+    });
+    if (state.owner !== 'v3')
+        return null;
+    const coverage = resolveWorkspaceSyncV3RegisteredCoverage(state)?.profile;
+    if (!coverage)
+        throw new LocalAuthoritativeTaskAttachmentLinksError('Owned task attachment-link coverage is not registered.');
+    if (coverage.projections.some(({ projectionId }) => projectionId === 'task-attachment-links/full-v2')) {
+        return 'task-attachment-links/full-v2';
+    }
+    if (coverage.projections.some(({ projectionId }) => projectionId === 'task-attachment-links/full-v1')) {
+        return 'task-attachment-links/full-v1';
+    }
+    return null;
+}
 export function enqueueLocalTaskAttachmentLinksMutation(input) {
     const requestedLinks = canonicalLinks(input.taskId, input.links);
     let attachments;
@@ -206,9 +226,20 @@ export function applyAuthoritativeTaskAttachmentLinksAndAck(input) {
         throw new LocalAuthoritativeTaskAttachmentLinksError('Authoritative task attachment-link operation ordering is invalid.');
     }
     const rootPayload = serializeTaskRootForSync(root.payload);
-    const attachmentLinksPayload = serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
-        taskId: attachmentLinks.entityId, links: attachmentLinks.payload.links,
-    });
+    const rawAttachmentPayload = attachmentLinks.payload;
+    const hasAuthoritativeCardCover = Object.prototype.hasOwnProperty.call(rawAttachmentPayload, 'cardCoverAssetId');
+    const validatedAttachmentLinksPayload = hasAuthoritativeCardCover
+        ? validateWorkspaceSyncV3TaskAttachmentLinksV2Payload(rawAttachmentPayload)
+        : validateWorkspaceSyncV3TaskAttachmentLinksPayload(rawAttachmentPayload);
+    const ownedAttachmentProjection = resolveOwnedAttachmentProjection(input);
+    const attachmentLinksPayload = ownedAttachmentProjection === 'task-attachment-links/full-v1'
+        ? serializeWorkspaceSyncV3TaskAttachmentLinksPayload(validatedAttachmentLinksPayload)
+        : validatedAttachmentLinksPayload;
+    const authoritativeCardCoverAssetId = hasAuthoritativeCardCover
+        && ownedAttachmentProjection !== 'task-attachment-links/full-v1'
+        ? validatedAttachmentLinksPayload
+            .cardCoverAssetId
+        : undefined;
     const activityPayload = serializeTaskActivityForSync(activity);
     const expectedActivityId = buildTaskAttachmentLinksActivityEventId({
         workspaceId: input.identity.workspaceId, clientId: input.identity.clientId,
@@ -268,6 +299,9 @@ export function applyAuthoritativeTaskAttachmentLinksAndAck(input) {
                 completedAt: rootPayload.completedAt,
                 canceledReason: rootPayload.canceledReason,
                 attachments,
+                ...(authoritativeCardCoverAssetId !== undefined
+                    ? { cardCoverAssetId: authoritativeCardCoverAssetId }
+                    : {}),
             };
             const updated = input.core.updateTask(root.entityId, rootPatch, input.identity.workspaceId, {
                 persistBackup: false, emitRealtime: false, skipTaskEvents: true,
@@ -282,9 +316,15 @@ export function applyAuthoritativeTaskAttachmentLinksAndAck(input) {
             input.core.upsertEntityEventForSync(activity, { allowAuthoritativeReplacement: true });
             const installedLinks = input.core.listTaskAttachmentLinksForDurableSync(updated.id, input.identity.workspaceId);
             if (canonicalWorkspaceSyncJson(serializeTaskRootForSync(updated)) !== canonicalWorkspaceSyncJson(rootPayload)
-                || canonicalWorkspaceSyncJson(serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
-                    taskId: updated.id, links: installedLinks,
-                })) !== canonicalWorkspaceSyncJson(attachmentLinksPayload)) {
+                || canonicalWorkspaceSyncJson(authoritativeCardCoverAssetId !== undefined
+                    ? serializeWorkspaceSyncV3TaskAttachmentLinksV2Payload({
+                        taskId: updated.id,
+                        links: installedLinks,
+                        cardCoverAssetId: updated.cardCoverAssetId ?? null,
+                    })
+                    : serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
+                        taskId: updated.id, links: installedLinks,
+                    })) !== canonicalWorkspaceSyncJson(attachmentLinksPayload)) {
                 throw new LocalAuthoritativeTaskAttachmentLinksError('Installed task attachment-link state does not match authority.');
             }
             return updated;