@taskforcehq/taskforce 0.3.328 → 0.3.330

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) {
@@ -172,7 +173,7 @@ export function createWorkspaceSyncV3TransferBindings(input) {
     };
 }
 export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtimeMode, initiativeFeedActivationEnabled, combinedFeedActivationEnabled, combinedFeedCoverage, workspaceCloudSyncEnabled, currentWorkspaceId, workspaceSyncPhase, isAuthenticated, checkAuthSession, resolveCloudAuthUrl, ensureCloudWorkspaceReadyForSync, ensureWorkspaceSyncReady, handleSyncAuthFailure, clearWorkspaceRetry, clearWorkspaceIssue, isWorkspaceRetryPending, isDurableRecoveryBlockingOrdinaryPush, isExecutionAuthorized = () => true, scheduleWorkspaceSyncRetry, persistWorkspaceSyncPatchSafely, persistWorkspaceSyncPatchBestEffort, persistWorkspaceSyncWatermarksSnapshotBestEffort, refreshWorkspaceAiProfilePushBaselineFromPersistence, reportSyncEvent, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, recordWorkspaceSyncCompletion, reportWorkspaceWindowContention, refreshWorkspaceSyncMarkdownDocumentsSnapshot, refreshWorkspaceSyncAiProfilesSnapshot, refreshWorkspaceSyncAssetsSnapshot, refreshWorkspaceSyncTaxonomySnapshot, refreshWorkspaceSyncPlanningEntitiesSnapshot, refreshWorkspaceSyncDocumentReviewSessionsSnapshot, refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot, refreshWorkspaceSyncTaskforceAgentsSnapshot, refreshLocalWorkspaceTaskCollections, buildWorkspaceSyncPayload, buildWorkspaceSyncSignature, seedWorkspaceSnapshotPushBaseline, shouldSuppressAttachBootstrapPush, recordSuppressedEventIds, runtime, localServices, remoteServices, setWorkspaceSyncBusy, setUserGlobalSyncStatus, setUserGlobalSyncError, setWorkspaceLastErrorMessage, setWorkspaceLastErrorAt, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceSyncPendingChanges, setTasks, setArchivedTasks, now, scheduleTask, logDebug = () => undefined, notifyAiProfilesMutated = () => undefined, notifyAgentsMutated = () => undefined, notifyAgentSkillsMutated = () => undefined }) {
-    const { repairMode: workspaceRepairModeRef, forceFullAiProfilePush: workspaceForceFullAiProfilePushRef, pushInFlight: workspacePushInFlightRef, pullInFlight: workspacePullInFlightRef, pullAfterPushRequested: workspacePullAfterPushRequestedRef, pendingPushReplay: workspacePendingPushReplayRef, blockedPushSignature: workspaceBlockedPushSignatureRef, lastPushedSignature: workspaceLastPushedSignatureRef, pendingSignature: workspacePendingSignatureRef, lastPushedTaskIds: workspaceLastPushedTaskIdsRef, deletedTaskIds: workspaceDeletedTaskIdsRef, deletedTaskWatermarks: workspaceDeletedTaskWatermarksRef, pullCursor: workspacePullCursorRef, lastPushedWatermarks: workspaceLastPushedWatermarksRef, lastPushedTaskChangeKeys: workspaceLastPushedTaskChangeKeysRef, lastPushedTaskRelationshipChangeKeys: workspaceLastPushedTaskRelationshipChangeKeysRef, lastPushedTaxonomyChangeKey: workspaceLastPushedTaxonomyChangeKeyRef, lastPushedInitiativeIds: workspaceLastPushedInitiativeIdsRef, lastPushedInitiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef, lastPushedWorkstreamIds: workspaceLastPushedWorkstreamIdsRef, lastPushedWorkstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef, lastPushedAiProfileIds: workspaceLastPushedAiProfileIdsRef, lastPushedAiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef, lastPushedAiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef, lastPushedDocumentPaths: workspaceLastPushedDocumentPathsRef, lastPushedDocumentWatermarks: workspaceLastPushedDocumentWatermarksRef, lastPushedAssetPaths: workspaceLastPushedAssetPathsRef, lastPushedAssetWatermarks: workspaceLastPushedAssetWatermarksRef, lastPushedDocumentReviewSessionIds: workspaceLastPushedDocumentReviewSessionIdsRef, lastPushedDocumentReviewSessionWatermarks: workspaceLastPushedDocumentReviewSessionWatermarksRef, lastPushedDocumentReviewCommentIds: workspaceLastPushedDocumentReviewCommentIdsRef, lastPushedDocumentReviewCommentWatermarks: workspaceLastPushedDocumentReviewCommentWatermarksRef, lastPushedAnnotatedAttachmentSessionIds: workspaceLastPushedAnnotatedAttachmentSessionIdsRef, lastPushedAnnotatedAttachmentSessionWatermarks: workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, lastPushedTaskforceAgentIds: workspaceLastPushedTaskforceAgentIdsRef, lastPushedTaskforceAgentWatermarks: workspaceLastPushedTaskforceAgentWatermarksRef, lastPushedTaskforceAgentSkillIds: workspaceLastPushedTaskforceAgentSkillIdsRef, lastPushedTaskforceAgentSkillWatermarks: workspaceLastPushedTaskforceAgentSkillWatermarksRef, lastPushedAgentConversationIds: workspaceLastPushedAgentConversationIdsRef, lastPushedAgentConversationWatermarks: workspaceLastPushedAgentConversationWatermarksRef, lastPushedTaskEventWatermarks: workspaceLastPushedTaskEventWatermarksRef, baselineResetReason: workspaceBaselineResetReasonRef, captureAttachBootstrapBaseline: workspaceCaptureAttachBootstrapBaselineRef, startupFullReconcileRan: workspaceStartupFullReconcileRanRef, startupFullReconcileRequested: workspaceStartupFullReconcileRequestedRef, fullReconcileInFlight: workspaceFullReconcileInFlightRef, bootstrapLastProgressAtMs: bootstrapLastProgressAtRef, realtimeSuppressedEventQueue: realtimeSuppressedEventQueueRef, } = runtime;
+    const { repairMode: workspaceRepairModeRef, forceFullAiProfilePush: workspaceForceFullAiProfilePushRef, pushInFlight: workspacePushInFlightRef, pullInFlight: workspacePullInFlightRef, pullAfterPushRequested: workspacePullAfterPushRequestedRef, pendingPushReplay: workspacePendingPushReplayRef, blockedPushSignature: workspaceBlockedPushSignatureRef, lastPushedSignature: workspaceLastPushedSignatureRef, pendingSignature: workspacePendingSignatureRef, lastPushedTaskIds: workspaceLastPushedTaskIdsRef, deletedTaskIds: workspaceDeletedTaskIdsRef, deletedTaskWatermarks: workspaceDeletedTaskWatermarksRef, pullCursor: workspacePullCursorRef, lastPushedWatermarks: workspaceLastPushedWatermarksRef, lastPushedTaskChangeKeys: workspaceLastPushedTaskChangeKeysRef, lastPushedTaskRelationshipChangeKeys: workspaceLastPushedTaskRelationshipChangeKeysRef, lastPushedTaxonomyChangeKey: workspaceLastPushedTaxonomyChangeKeyRef, lastPushedInitiativeIds: workspaceLastPushedInitiativeIdsRef, lastPushedInitiativeWatermarks: workspaceLastPushedInitiativeWatermarksRef, lastPushedWorkstreamIds: workspaceLastPushedWorkstreamIdsRef, lastPushedWorkstreamWatermarks: workspaceLastPushedWorkstreamWatermarksRef, lastPushedPlanningIdentityWatermarks: workspaceLastPushedPlanningIdentityWatermarksRef, lastPushedAiProfileIds: workspaceLastPushedAiProfileIdsRef, lastPushedAiProfileWatermarks: workspaceLastPushedAiProfileWatermarksRef, lastPushedAiProfileChangeKeys: workspaceLastPushedAiProfileChangeKeysRef, lastPushedDocumentPaths: workspaceLastPushedDocumentPathsRef, lastPushedDocumentWatermarks: workspaceLastPushedDocumentWatermarksRef, lastPushedAssetPaths: workspaceLastPushedAssetPathsRef, lastPushedAssetWatermarks: workspaceLastPushedAssetWatermarksRef, lastPushedDocumentReviewSessionIds: workspaceLastPushedDocumentReviewSessionIdsRef, lastPushedDocumentReviewSessionWatermarks: workspaceLastPushedDocumentReviewSessionWatermarksRef, lastPushedDocumentReviewCommentIds: workspaceLastPushedDocumentReviewCommentIdsRef, lastPushedDocumentReviewCommentWatermarks: workspaceLastPushedDocumentReviewCommentWatermarksRef, lastPushedAnnotatedAttachmentSessionIds: workspaceLastPushedAnnotatedAttachmentSessionIdsRef, lastPushedAnnotatedAttachmentSessionWatermarks: workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, lastPushedTaskforceAgentIds: workspaceLastPushedTaskforceAgentIdsRef, lastPushedTaskforceAgentWatermarks: workspaceLastPushedTaskforceAgentWatermarksRef, lastPushedTaskforceAgentSkillIds: workspaceLastPushedTaskforceAgentSkillIdsRef, lastPushedTaskforceAgentSkillWatermarks: workspaceLastPushedTaskforceAgentSkillWatermarksRef, lastPushedAgentConversationIds: workspaceLastPushedAgentConversationIdsRef, lastPushedAgentConversationWatermarks: workspaceLastPushedAgentConversationWatermarksRef, lastPushedTaskEventWatermarks: workspaceLastPushedTaskEventWatermarksRef, baselineResetReason: workspaceBaselineResetReasonRef, captureAttachBootstrapBaseline: workspaceCaptureAttachBootstrapBaselineRef, startupFullReconcileRan: workspaceStartupFullReconcileRanRef, startupFullReconcileRequested: workspaceStartupFullReconcileRequestedRef, fullReconcileInFlight: workspaceFullReconcileInFlightRef, bootstrapLastProgressAtMs: bootstrapLastProgressAtRef, realtimeSuppressedEventQueue: realtimeSuppressedEventQueueRef, } = runtime;
     const scheduledTasks = new Map();
     let disposed = false;
     const scheduleCoordinatorTask = (key, callback, delayMs) => {
@@ -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();
@@ -462,6 +467,8 @@ export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtim
             workspaceLastPushedInitiativeWatermarksRef.current = new Map(pushResult.currentInitiativeWatermarks);
             workspaceLastPushedWorkstreamIdsRef.current = new Set(pushResult.currentWorkstreamIds);
             workspaceLastPushedWorkstreamWatermarksRef.current = new Map(pushResult.currentWorkstreamWatermarks);
+            workspaceLastPushedPlanningIdentityWatermarksRef.current = new Map(pushResult.currentPlanningIdentityWatermarks
+                || payload.currentPlanningIdentityWatermarks);
             workspaceLastPushedAiProfileIdsRef.current = new Set(pushResult.currentAiProfileIds);
             workspaceLastPushedAiProfileWatermarksRef.current = new Map(pushResult.currentAiProfileWatermarks);
             workspaceLastPushedAiProfileChangeKeysRef.current = pushResult.currentAiProfileChangeKeys

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

@@ -12,6 +12,7 @@ type SyncCore = TaskforceCore & TaskforceSyncCapable;
 type ContentSyncState = ReturnType<typeof createContentSyncState>;
 export interface WorkspaceSyncV2DispatchOptions {
     allowReferenceNumberReassignment?: boolean;
+    actorUserId?: string;
     workspaceMembers?: WorkspaceSyncWorkspaceMemberSnapshot[];
     coexistenceDirection?: TaskMetadataCoexistenceDirection;
     assertedActiveV3TaskMetadataIds?: ReadonlySet<string>;

package/dist/sync/engine/workspaceSyncV2ChangeDispatcher.js

@@ -7,6 +7,7 @@ import { WorkspaceSyncDurabilityStore } from '../v3/syncDurabilityStore.js';
 import { assertWorkspaceSyncV2TaskCarrierRootsExist, prepareWorkspaceSyncV2TaskCarriers, } from '../v3/workspaceSyncV2ProjectionExclusions.js';
 import { resolveV3OwnedTaskDeleteIds, resolveV3OwnedTaskLifecycleIds, resolveV3OwnedTaskMetadataIds, resolveV3OwnedTaskReopenAssigneeIds, resolveV3OwnedTaskTaxonomyIds, } from '../v3/taskMetadataCoexistence.js';
 import { assertWorkspaceSyncV2MetadataOnlyApplyPreflight, } from './workspaceSyncEngineLocalApply.js';
+import { assertTaskforceAgentSyncPushAccess } from '../taskforceAgentSyncAuthorization.js';
 function createSyncRouteError(message, details, options) {
     const error = new Error(message);
     error.code = options?.code || 'SYNC_APPLY_FAILED';
@@ -132,6 +133,14 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
             normalizeTaskEventSyncPayload,
             recordSyncDiagnostic,
         });
+        if (options.coexistenceDirection === 'cloud-push') {
+            assertTaskforceAgentSyncPushAccess({
+                agents: applyModel.collaboration.incomingTaskforceAgents.values(),
+                actorUserId: String(options.actorUserId || '').trim() || null,
+                hasUserFeatureGrant: (userId, featureKey) => core.hasUserFeatureGrant(userId, featureKey),
+                createSyncRouteError,
+            });
+        }
         if (metadataOnly) {
             assertWorkspaceSyncV2MetadataOnlyApplyPreflight(incomingChanges);
         }
@@ -304,6 +313,10 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                 incomingAgentRoles: applyModel.collaboration.incomingAgentRoles,
                 incomingTaskforceAgentSkills: applyModel.collaboration.incomingTaskforceAgentSkills,
                 incomingAgentConversations: applyModel.collaboration.incomingAgentConversations,
+                ...(options.coexistenceDirection === 'cloud-push' ? {
+                    taskforceAgentPushActorUserId: String(options.actorUserId || '').trim() || null,
+                    taskforceAgentPushAccessPreflighted: true,
+                } : {}),
                 recordSyncDiagnostic,
                 createSyncRouteError,
             });
@@ -633,6 +646,18 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                 sourceUpdatedAt: intent.sourceUpdatedAt,
                 publishedAt: now().toISOString(),
                 deletedAt: intent.sourceUpdatedAt,
+                // This dispatch path only ever runs from an explicit document-delete/
+                // asset-delete WorkspaceSyncChange (see workspaceSyncV2PreparedContent.ts)
+                // — never from workspace repair, which is intentionally routed to a
+                // durable retry obligation instead (see workspaceRepair.ts) rather than
+                // ever reaching this admission boundary. operationId/actorId are not yet
+                // threaded through the WorkspaceSyncChange wire format from origin to this
+                // layer — see the type's doc comment.
+                provenance: {
+                    source: 'explicit-delete',
+                    sourceRuntime: 'server',
+                    repairInvolved: false,
+                },
             });
             if (tombstone.versionId !== null
                 || tombstone.sourceUpdatedAt !== intent.sourceUpdatedAt
@@ -748,6 +773,10 @@ export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
                     incomingAgentRoles: applyModel.collaboration.incomingAgentRoles,
                     incomingTaskforceAgentSkills: applyModel.collaboration.incomingTaskforceAgentSkills,
                     incomingAgentConversations: applyModel.collaboration.incomingAgentConversations,
+                    ...(options.coexistenceDirection === 'cloud-push' ? {
+                        taskforceAgentPushActorUserId: String(options.actorUserId || '').trim() || null,
+                        taskforceAgentPushAccessPreflighted: true,
+                    } : {}),
                     recordSyncDiagnostic,
                     createSyncRouteError,
                 });

package/dist/sync/syncApplyHandlers.d.ts

@@ -255,6 +255,8 @@ export declare function applyCollaborationSyncChanges(input: {
     incomingAgentRoles?: Map<string, WorkspaceSyncAgentRoleSnapshot>;
     incomingTaskforceAgentSkills?: Map<string, WorkspaceSyncTaskforceAgentSkillSnapshot>;
     incomingAgentConversations?: Map<string, WorkspaceSyncAgentConversationSnapshot>;
+    taskforceAgentPushActorUserId?: string | null;
+    taskforceAgentPushAccessPreflighted?: boolean;
     recordSyncDiagnostic: RecordSyncDiagnostic;
     createSyncRouteError: CreateSyncRouteError;
 }): void;

package/dist/sync/syncApplyHandlers.js

@@ -18,6 +18,7 @@ import { TaskforceAgentStore } from '../storage/taskforceAgentStore.js';
 import { TaskforceAgentSkillStore } from '../storage/taskforceAgentSkillStore.js';
 import { TaskforceAgentConversationStore } from '../storage/taskforceAgentConversationStore.js';
 import { AgentRoleStore } from '../storage/agentRoleStore.js';
+import { assertTaskforceAgentSyncPushAccess } from './taskforceAgentSyncAuthorization.js';
 import { preserveV3OwnedTaskRoot, preserveV3OwnedTaskLifecycle, preserveV3OwnedTaskMetadata, preserveV3OwnedTaskReopenAssignee, preserveV3OwnedTaskTaxonomy, } from './v3/taskMetadataCoexistence.js';
 function createIncomingApplyModel() {
     return {
@@ -1052,7 +1053,15 @@ export async function applyContentSyncChanges(input) {
     }
 }
 export function applyCollaborationSyncChanges(input) {
-    const { core, workspaceId, incomingDocumentReviewSessions, incomingDocumentReviewSessionDeletes, incomingDocumentReviewComments, incomingDocumentReviewCommentDeletes, incomingAnnotatedAttachmentSessions, incomingAnnotatedAttachmentSessionDeletes, incomingTaskforceAgents = new Map(), incomingAgentRoles = new Map(), incomingTaskforceAgentSkills = new Map(), incomingAgentConversations = new Map(), recordSyncDiagnostic, createSyncRouteError, } = input;
+    const { core, workspaceId, incomingDocumentReviewSessions, incomingDocumentReviewSessionDeletes, incomingDocumentReviewComments, incomingDocumentReviewCommentDeletes, incomingAnnotatedAttachmentSessions, incomingAnnotatedAttachmentSessionDeletes, incomingTaskforceAgents = new Map(), incomingAgentRoles = new Map(), incomingTaskforceAgentSkills = new Map(), incomingAgentConversations = new Map(), taskforceAgentPushActorUserId, taskforceAgentPushAccessPreflighted = false, recordSyncDiagnostic, createSyncRouteError, } = input;
+    if (taskforceAgentPushActorUserId !== undefined && !taskforceAgentPushAccessPreflighted) {
+        assertTaskforceAgentSyncPushAccess({
+            agents: incomingTaskforceAgents.values(),
+            actorUserId: taskforceAgentPushActorUserId,
+            hasUserFeatureGrant: (userId, featureKey) => core.hasUserFeatureGrant(userId, featureKey),
+            createSyncRouteError,
+        });
+    }
     if (incomingDocumentReviewSessions.size > 0) {
         for (const session of incomingDocumentReviewSessions.values()) {
             try {

package/dist/sync/syncService.d.ts

@@ -52,6 +52,12 @@ export interface WorkspacePushSyncInput {
     remoteServices?: WorkspaceSyncEngineRemoteServices;
     localServices?: Pick<WorkspaceSyncEngineLocalServices, 'readPushOwnership'>;
     acknowledgedNonApplyingBatchOperationIdentities?: readonly string[];
+    /**
+     * Server-owned pages whose remote receipt, authoritative task echo, and
+     * runner checkpoint contribution committed atomically. Browser callers
+     * must not use this recovery boundary.
+     */
+    settledBatchOperationIdentities?: readonly string[];
     preparedPlan?: WorkspacePushPreparedPlan | null;
     onPreparedPlan?: (input: {
         plan: WorkspacePushPreparedPlan;
@@ -62,6 +68,14 @@ export interface WorkspacePushSyncInput {
         operationIdentity: string;
         acknowledgedOperationIdentities: readonly string[];
     }) => void | Promise<void>;
+    onAcceptedBatchSettled?: (input: {
+        operationIdentity: string;
+        settlementIdentityFingerprint: string;
+        appliedTaskUpserts: WorkspacePushSyncResult['appliedTaskUpserts'];
+        transferReceipt: WorkspaceSyncEngineRemoteTransferReceipt;
+        pushBoundary: WorkspaceSyncEngineV2PushBoundary;
+        excludedProjections?: readonly WorkspaceSyncV2ProjectionExclusion[];
+    }) => void | Promise<void>;
 }
 export interface WorkspacePushSyncResult {
     success: boolean;
@@ -77,6 +91,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>;
@@ -88,6 +104,7 @@ export interface WorkspacePushSyncResult {
     currentInitiativeWatermarks: Map<string, string>;
     currentWorkstreamIds: Set<string>;
     currentWorkstreamWatermarks: Map<string, string>;
+    currentPlanningIdentityWatermarks?: Map<string, string>;
     currentAiProfileIds: Set<string>;
     currentAiProfileWatermarks: Map<string, string>;
     currentAiProfileChangeKeys?: Map<string, string>;

package/dist/sync/syncService.js

@@ -1,11 +1,11 @@
 import { applyLocalWorkspaceChanges, getLocalWorkspaceContentPullObligations, recordLocalWorkspaceContentPullObligationFailures, getLocalWorkspaceContentManifest, pullUserSettings, pushUserSettings, prepareWorkspacePushChanges, } from './cloudSyncApi.js';
 import { workspaceSyncContentPullObligationId, } from './engine/workspaceSyncContentPullObligationStore.js';
 import { createBrowserWorkspaceSyncEngineRemoteServices, } from './engine/workspaceSyncEngineRemoteServices.js';
-import { createWorkspaceSyncEngineV2PushBoundary, parseWorkspaceSyncEngineAppliedTaskUpserts, workspaceSyncEngineExpectedTaskEchoIds, } from './engine/workspaceSyncEnginePushCompletion.js';
+import { createWorkspaceSyncEngineV2SettlementIdentityProjection, createWorkspaceSyncEngineV2PushBoundary, parseWorkspaceSyncEngineAppliedTaskUpserts, workspaceSyncEngineExpectedTaskEchoIds, } from './engine/workspaceSyncEnginePushCompletion.js';
 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) {
@@ -181,13 +181,8 @@ function buildEffectiveWorkspacePushDiagnostics(diagnostics, changes, ownership)
             : {}),
     };
 }
-async function computeIdempotencyKey(workspaceId, changes, repairMode) {
-    const text = canonicalWorkspaceSyncJson({
-        contractVersion: 1,
-        workspaceId,
-        repairMode,
-        changes
-    });
+async function computeCanonicalWorkspaceSyncSha256(value, fallbackNamespace) {
+    const text = canonicalWorkspaceSyncJson(value);
     try {
         const buffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
         return Array.from(new Uint8Array(buffer)).map(b => b.toString(16).padStart(2, '0')).join('');
@@ -202,9 +197,19 @@ async function computeIdempotencyKey(workspaceId, changes, repairMode) {
             hash = Math.imul(hash, 0x01000193);
         }
         const hex = (hash >>> 0).toString(16).padStart(8, '0');
-        return `${workspaceId}:fallback:${hex}`;
+        return fallbackNamespace
+            ? `${fallbackNamespace}:fallback:${hex}`
+            : hex.repeat(8);
     }
 }
+async function computeIdempotencyKey(workspaceId, changes, repairMode) {
+    return computeCanonicalWorkspaceSyncSha256({
+        contractVersion: 1,
+        workspaceId,
+        repairMode,
+        changes
+    }, workspaceId);
+}
 const MAX_WORKSPACE_PUSH_CHANGES_PER_REQUEST = 64;
 const MAX_WORKSPACE_PUSH_BYTES_PER_REQUEST = 4 * 1024 * 1024;
 const MAX_WORKSPACE_PUSH_SINGLE_CHANGE_BYTES = 45 * 1024 * 1024;
@@ -428,6 +433,7 @@ export async function runWorkspacePushSyncService(input) {
                 currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
                 currentWorkstreamIds: input.payload.currentWorkstreamIds,
                 currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+                currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
                 currentAiProfileIds: input.payload.currentAiProfileIds,
                 currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
                 currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
@@ -464,6 +470,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 +485,7 @@ export async function runWorkspacePushSyncService(input) {
             requestMs: 0,
             changeCount: 0,
             effectiveDeltaDiagnostics,
+            effectiveV2ExcludedProjections,
             deleteCount,
             currentTaskIds: input.payload.currentTaskIds,
             currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
@@ -489,6 +497,7 @@ export async function runWorkspacePushSyncService(input) {
             currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
             currentWorkstreamIds: input.payload.currentWorkstreamIds,
             currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+            currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
             currentAiProfileIds: input.payload.currentAiProfileIds,
             currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
             currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
@@ -581,6 +590,7 @@ export async function runWorkspacePushSyncService(input) {
             currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
             currentWorkstreamIds: input.payload.currentWorkstreamIds,
             currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+            currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
             currentAiProfileIds: input.payload.currentAiProfileIds,
             currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
             currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
@@ -668,8 +678,18 @@ export async function runWorkspacePushSyncService(input) {
         && acknowledgedNonApplyingBatchOperationIdentities.size !== requestedAcknowledgements.length) {
         throw new Error('Persisted V2 push batch acknowledgement state does not match the frozen push plan.');
     }
+    const requestedSettledBatchOperationIdentities = input.settledBatchOperationIdentities || [];
+    if ((requestedSettledBatchOperationIdentities.length > 0
+        && !input.onAcceptedBatchSettled)
+        || new Set(requestedSettledBatchOperationIdentities).size
+            !== requestedSettledBatchOperationIdentities.length
+        || requestedSettledBatchOperationIdentities.some((identity) => !batchOperationIdentities.includes(identity))) {
+        throw new Error('Persisted V2 push batch settlement state does not match the frozen push plan.');
+    }
+    const settledBatchOperationIdentities = new Set(requestedSettledBatchOperationIdentities);
     let completedBatchCount = 0;
     let completedChangeCount = 0;
+    let firstPushFailure = null;
     const pushTransferReceipts = [];
     const abandonRetainedPushReceipts = async (errorCode) => {
         if (pushTransferReceipts.length === 0)
@@ -687,7 +707,8 @@ export async function runWorkspacePushSyncService(input) {
             const safeBatchChanges = batch.map((entry) => entry.safe);
             const expectedTaskEchoIds = workspaceSyncEngineExpectedTaskEchoIds(plainBatchChanges);
             const idempotencyKey = batchOperationIdentities[batchIndex];
-            if (acknowledgedNonApplyingBatchOperationIdentities.has(idempotencyKey)) {
+            if (settledBatchOperationIdentities.has(idempotencyKey)
+                || acknowledgedNonApplyingBatchOperationIdentities.has(idempotencyKey)) {
                 completedBatchCount += 1;
                 completedChangeCount += plainBatchChanges.length;
                 continue;
@@ -730,7 +751,12 @@ export async function runWorkspacePushSyncService(input) {
                 const data = asObjectRecord(pushResult.data);
                 const failedOperations = Array.from(new Set(plainBatchChanges.map((change) => change.op)));
                 const failedContentChanges = plainBatchChanges.filter(isWorkspacePushContentChange).length;
-                return {
+                const failureDomain = failedContentChanges === plainBatchChanges.length
+                    ? 'content'
+                    : failedContentChanges === 0
+                        ? 'metadata'
+                        : 'mixed';
+                const failureResult = {
                     success: false,
                     status: pushResult.status,
                     error: typeof data.error === 'string' ? data.error : undefined,
@@ -742,11 +768,7 @@ export async function runWorkspacePushSyncService(input) {
                         failedBatchIndex: batchIndex,
                         failedChangeCount: plainBatchChanges.length,
                         failedOperations,
-                        failureDomain: failedContentChanges === plainBatchChanges.length
-                            ? 'content'
-                            : failedContentChanges === 0
-                                ? 'metadata'
-                                : 'mixed',
+                        failureDomain,
                     },
                     retryAfterMs: pushResult.retryAfterMs,
                     transient: pushInProgress || isTransientWorkspaceSyncStatus(pushResult.status),
@@ -763,6 +785,7 @@ export async function runWorkspacePushSyncService(input) {
                     currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
                     currentWorkstreamIds: input.payload.currentWorkstreamIds,
                     currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+                    currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
                     currentAiProfileIds: input.payload.currentAiProfileIds,
                     currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
                     currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
@@ -791,8 +814,18 @@ export async function runWorkspacePushSyncService(input) {
                     pushedWatermarks: new Map(),
                     pushedTaskChangeKeys: new Map(),
                     emittedEventIds: [],
-                    appliedTaskUpserts: []
+                    appliedTaskUpserts: [],
                 };
+                firstPushFailure ||= failureResult;
+                // Only content is isolated from later durable projections.
+                // Ownership, auth, and metadata failures can invalidate phase
+                // dependencies, so they still stop the attempt immediately.
+                if (failureDomain !== 'content')
+                    return failureResult;
+                // Later phases contain independent relationships, events, and
+                // comments. Let them settle and checkpoint their non-applying
+                // receipts even though this attempt reports the content failure.
+                continue;
             }
             const pushData = asObjectRecord(pushResult.data);
             if (Array.isArray(pushData.emittedEventIds)) {
@@ -804,7 +837,29 @@ export async function runWorkspacePushSyncService(input) {
             }
             const normalizedTaskUpserts = parseWorkspaceSyncEngineAppliedTaskUpserts(pushData, expectedTaskEchoIds);
             appliedTaskUpserts.push(...normalizedTaskUpserts);
-            if (pushResult.transferReceipt && normalizedTaskUpserts.length === 0) {
+            if (input.onAcceptedBatchSettled) {
+                if (!pushResult.transferReceipt) {
+                    throw new Error('Accepted V2 push batch is missing its atomic settlement receipt.');
+                }
+                await input.onAcceptedBatchSettled({
+                    operationIdentity: idempotencyKey,
+                    settlementIdentityFingerprint: await computeCanonicalWorkspaceSyncSha256(createWorkspaceSyncEngineV2SettlementIdentityProjection({
+                        operationIdentity: idempotencyKey,
+                        changes: plainBatchChanges,
+                        appliedTaskUpserts: normalizedTaskUpserts,
+                        excludedProjections: effectiveV2ExcludedProjections,
+                    })),
+                    appliedTaskUpserts: normalizedTaskUpserts,
+                    transferReceipt: pushResult.transferReceipt,
+                    pushBoundary,
+                    excludedProjections: effectiveV2ExcludedProjections,
+                });
+                const receiptIndex = pushTransferReceipts.indexOf(pushResult.transferReceipt);
+                if (receiptIndex >= 0)
+                    pushTransferReceipts.splice(receiptIndex, 1);
+                settledBatchOperationIdentities.add(idempotencyKey);
+            }
+            else if (pushResult.transferReceipt && normalizedTaskUpserts.length === 0) {
                 await remoteServices.acknowledgeNonApplyingTransferReceipts({
                     workspaceId: input.workspaceId,
                     receipts: [pushResult.transferReceipt],
@@ -826,6 +881,17 @@ export async function runWorkspacePushSyncService(input) {
         await abandonRetainedPushReceipts('WORKSPACE_SYNC_V2_PUSH_ATTEMPT_FAILED');
         throw error;
     }
+    if (firstPushFailure) {
+        return {
+            ...firstPushFailure,
+            batchProgress: {
+                ...firstPushFailure.batchProgress,
+                completedBatches: completedBatchCount,
+                completedChanges: completedChangeCount,
+            },
+            requestMs,
+        };
+    }
     return {
         success: true,
         syncedAt: new Date().toISOString(),
@@ -841,6 +907,7 @@ export async function runWorkspacePushSyncService(input) {
             failureDomain: null,
         },
         effectiveDeltaDiagnostics,
+        effectiveV2ExcludedProjections,
         deleteCount,
         currentTaskIds: input.payload.currentTaskIds,
         currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
@@ -852,6 +919,7 @@ export async function runWorkspacePushSyncService(input) {
         currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
         currentWorkstreamIds: input.payload.currentWorkstreamIds,
         currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+        currentPlanningIdentityWatermarks: input.payload.currentPlanningIdentityWatermarks,
         currentAiProfileIds: input.payload.currentAiProfileIds,
         currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
         currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),

package/dist/sync/taskforceAgentSyncAuthorization.d.ts

@@ -0,0 +1,16 @@
+import type { WorkspaceSyncTaskforceAgentSnapshot } from './workspaceSyncModel.js';
+type SyncAuthorizationError = Error & {
+    code?: string;
+    statusCode?: number;
+    details?: Record<string, unknown>;
+};
+export declare function assertTaskforceAgentSyncPushAccess(input: {
+    agents: Iterable<WorkspaceSyncTaskforceAgentSnapshot>;
+    actorUserId: string | null;
+    hasUserFeatureGrant: (userId: string, featureKey: unknown) => boolean;
+    createSyncRouteError: (message: string, details: Record<string, unknown>, options?: {
+        code?: string;
+        statusCode?: number;
+    }) => SyncAuthorizationError;
+}): void;
+export {};

package/dist/sync/taskforceAgentSyncAuthorization.js

@@ -0,0 +1,20 @@
+import { getTaskforceAgentModel } from '../shared/taskforceAgentModels.js';
+import { INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY } from '../shared/userFeatureGrants.js';
+export function assertTaskforceAgentSyncPushAccess(input) {
+    const actorUserId = String(input.actorUserId || '').trim();
+    for (const agent of input.agents) {
+        if (agent.deletedAt)
+            continue;
+        const modelKey = String(agent.definition?.model?.modelKey || agent.modelKey || '').trim();
+        if (getTaskforceAgentModel(modelKey)?.source !== 'subscription_dev')
+            continue;
+        if (actorUserId && input.hasUserFeatureGrant(actorUserId, INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY))
+            continue;
+        throw input.createSyncRouteError(`Subscription-backed Taskforce Agent ${agent.id} requires an internal user grant.`, {
+            source: 'apply.taskforceAgentUpsert',
+            agentId: agent.id,
+            actorUserId: actorUserId || null,
+            featureKey: INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY,
+        }, { code: 'SUBSCRIPTION_MODEL_ACCESS_REQUIRED', statusCode: 403 });
+    }
+}

package/dist/sync/v3/combinedFeedCapability.js

@@ -3,6 +3,8 @@ 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';
+import { WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR } from './workspaceSyncV3WorkflowTaskCoverWireContract.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 +20,12 @@ 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;
+    }
+    if (requestedVersion === String(WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR.coverageVersion)) {
+        return WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR;
+    }
     throw new Error(`Unsupported TASKFORCE_SYNC_V3_COMBINED_FEED_COVERAGE_VERSION: ${requestedVersion}.`);
 }
 export function resolveCombinedFeedCapability(input) {

package/dist/sync/v3/durableInitiativeMutationRouter.js

@@ -7,6 +7,7 @@ import { enqueueLocalInitiativeMutation, } from './localInitiativeOutboxService.
 import { isWorkspaceSyncV3PlanningActivationEnabled } from './planningActivation.js';
 import { serializeEntityActivityForSync } from './taskActivityJournal.js';
 import { WorkspaceSyncDurabilityStore, WorkspaceSyncIdempotencyConflictError } from './syncDurabilityStore.js';
+import { readDurableOperationReplay } from './durableOperationReplay.js';
 import { buildInitiativeActivityEventId } from './initiativeActivityIdentity.js';
 const OPERATION_LEASE_MS = 30_000;
 export class DurableInitiativeMutationRouterDisabledError extends Error {
@@ -85,6 +86,9 @@ export function createDurableInitiativeMutationRouter(input) {
                 if (persistedOutbox.domain !== 'initiative' || persistedOutbox.entityId !== initiativeId) {
                     throw new WorkspaceSyncIdempotencyConflictError();
                 }
+                store.assertOutboxOperationIdentity(persistedOutbox, {
+                    domain: 'initiative', entityId: initiativeId, mutationKind: persistedOutbox.mutationKind,
+                });
                 return {
                     revisions: {
                         entityRevision: persistedOutbox.baseEntityRevision,
@@ -99,18 +103,22 @@ export function createDurableInitiativeMutationRouter(input) {
             if (operationState?.status === 'committed') {
                 if (!operationState.responseJson)
                     throw new Error('Committed operation is missing its response.');
-                const response = JSON.parse(operationState.responseJson);
-                if (response.authoritative.entityId !== initiativeId) {
-                    throw new WorkspaceSyncIdempotencyConflictError();
-                }
-                const lifecycleMutation = response.authoritative.mutationKind === 'archive'
-                    || response.authoritative.mutationKind === 'unarchive';
+                const parsed = JSON.parse(operationState.responseJson);
+                const lifecycleMutation = parsed.authoritative.mutationKind === 'archive'
+                    || parsed.authoritative.mutationKind === 'unarchive';
+                const replay = readDurableOperationReplay({
+                    responseJson: operationState.responseJson,
+                    operationId,
+                    domain: 'initiative',
+                    entityId: initiativeId,
+                    mutationKind: parsed.authoritative.mutationKind,
+                    revisionMode: lifecycleMutation ? 'both' : 'metadata',
+                });
+                const response = replay.response;
                 return {
                     revisions: {
-                        entityRevision: String(BigInt(response.authoritative.entityRevision) - 1n),
-                        lifecycleRevision: lifecycleMutation
-                            ? String(BigInt(response.authoritative.lifecycleRevision) - 1n)
-                            : response.authoritative.lifecycleRevision,
+                        entityRevision: replay.baseEntityRevision,
+                        lifecycleRevision: replay.baseLifecycleRevision,
                     },
                     persistedOutbox: null,
                     committedResponse: response,

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

@@ -15,6 +15,20 @@ export declare class DurableOperationReplayIdentityConflictError extends Error {
     readonly code = "DURABLE_OPERATION_REPLAY_IDENTITY_CONFLICT";
     constructor(message?: string);
 }
+export interface DurableOperationIdentityRecord {
+    operationId: string;
+    domain: string;
+    entityId: string;
+    mutationKind: string;
+    payloadFingerprint: string;
+}
+/**
+ * Canonical identity comparison for durable mutation records. Storage lanes may
+ * retain different reservation metadata, but an accepted operation can have
+ * only one exact domain/entity/mutation/payload meaning.
+ */
+export declare function assertDurableOperationIdentity(actual: Readonly<DurableOperationIdentityRecord>, expected: Readonly<DurableOperationIdentityRecord>): void;
+export declare function assertDurableOperationFingerprint(actual: string, expected: string): void;
 export interface DurableOperationReplayResult<Payload = unknown> {
     response: Readonly<Record<string, unknown>>;
     authoritative: DurableOperationAuthoritativeEntry<Payload>;

package/dist/sync/v3/durableOperationReplay.js

@@ -12,6 +12,24 @@ export class DurableOperationReplayIdentityConflictError extends Error {
         this.name = 'DurableOperationReplayIdentityConflictError';
     }
 }
+/**
+ * Canonical identity comparison for durable mutation records. Storage lanes may
+ * retain different reservation metadata, but an accepted operation can have
+ * only one exact domain/entity/mutation/payload meaning.
+ */
+export function assertDurableOperationIdentity(actual, expected) {
+    if (actual.operationId !== expected.operationId
+        || actual.domain !== expected.domain
+        || actual.entityId !== expected.entityId
+        || actual.mutationKind !== expected.mutationKind
+        || actual.payloadFingerprint !== expected.payloadFingerprint) {
+        throw new DurableOperationReplayIdentityConflictError();
+    }
+}
+export function assertDurableOperationFingerprint(actual, expected) {
+    if (!actual || actual !== expected)
+        throw new DurableOperationReplayIdentityConflictError();
+}
 const DEFAULT_MAX_AUTHORITATIVE_ENTRIES = 1_024;
 const POSITIVE_REVISION = /^[1-9]\d*$/;
 const NON_NEGATIVE_REVISION = /^(0|[1-9]\d*)$/;

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";