@taskforcehq/taskforce 0.3.329 → 0.3.330

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;
@@ -90,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,7 +1,7 @@
 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';
@@ -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(),
@@ -491,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(),
@@ -583,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(),
@@ -670,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)
@@ -689,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;
@@ -732,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,
@@ -744,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),
@@ -765,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(),
@@ -793,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)) {
@@ -806,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],
@@ -828,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(),
@@ -855,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

@@ -4,6 +4,7 @@ import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR } from './workspaceSyncV3Nes
 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();
@@ -22,6 +23,9 @@ export function resolveRequestedCombinedFeedCoverage(env = process.env) {
     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.js

@@ -150,6 +150,9 @@ export function createDurableTaskAttachmentLinksMutationRouter(input) {
                         || String(payload.cardCoverAssetId || '') !== String(cardCoverAssetId || '')) {
                         throw new DurableTaskAttachmentLinksMutationError('Operation identity is assigned to different task attachment links.', 'TASK_ATTACHMENT_LINKS_IDENTITY_CONFLICT', 409);
                     }
+                    store.assertOutboxOperationIdentity(existing, {
+                        domain: 'task-attachment-links', entityId: taskId, mutationKind: 'replace',
+                    });
                     const task = input.core.getTask(taskId, workspaceId);
                     if (!task)
                         throw new DurableTaskAttachmentLinksMutationError('Task not found.', 'TASK_NOT_FOUND', 404);

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

@@ -1,7 +1,7 @@
 import type { ChecklistItem, TaskItem } from '../../core/Taskforce.js';
 import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
 import { type LocalTaskChecklistOutboxCore } from './localTaskChecklistOutboxService.js';
-import { type DurableTaskChecklistServiceCore } from './taskChecklistMutationService.js';
+import { type DurableTaskChecklistServiceCore, type TaskChecklistItemUpdateIntent } from './taskChecklistMutationService.js';
 export declare function resolveTaskChecklistMutationCapability(input: {
     runtimeMode: 'local' | 'cloud';
     surface: 'http' | 'mcp';
@@ -40,6 +40,7 @@ export declare function createDurableTaskChecklistMutationRouter(input: {
         taskId: string;
         items: readonly Partial<ChecklistItem>[];
         expectedDetailRevision?: string;
+        itemUpdateIntent?: TaskChecklistItemUpdateIntent;
     }): {
         state: "pending" | "committed";
         route: "local-outbox" | "cloud-acceptance";