@mastra/mongodb 1.23.1-alpha.0 → 1.23.1

package/dist/index.cjs

@@ -10,7 +10,7 @@ let _mastra_core_agent = require("@mastra/core/agent");
 let _mastra_core_evals = require("@mastra/core/evals");
 let _mastra_core_storage_domains_skills = require("@mastra/core/storage/domains/skills");
 //#region package.json
-var version = "1.23.1-alpha.0";
+var version = "1.23.1";
 //#endregion
 //#region src/vector/filter.ts
 /**
@@ -1619,20 +1619,29 @@ var MongoDBConnector = class MongoDBConnector {
 		return (await this.getConnection()).listCollections({ name: collectionName }).hasNext();
 	}
 	/**
-	* Returns true when the deployment supports multi-document transactions
-	* (replica set or sharded cluster). Standalone servers and custom connector
-	* handlers return false. Probed once and cached.
+	* Whether the deployment supports multi-document transactions (replica set
+	* or sharded cluster). Standalone servers and custom connector handlers
+	* don't. The answer is cached once a probe completes; a probe that fails
+	* rejects and is retried on the next call, so the answer never changes.
 	*/
-	async supportsTransactions() {
+	async probeTransactions() {
 		if (this.#supportsTransactions !== void 0) return this.#supportsTransactions;
 		if (!this.#client) {
 			this.#supportsTransactions = false;
 			return false;
 		}
+		const hello = await (await this.getConnection()).admin().command({ hello: 1 });
+		this.#supportsTransactions = Boolean(hello.setName) || hello.msg === "isdbgrid";
+		return this.#supportsTransactions;
+	}
+	/**
+	* Like {@link probeTransactions}, but a failed probe reads as no
+	* transaction support (and is retried on the next call), so a momentary
+	* outage degrades writes to non-atomic instead of failing them.
+	*/
+	async supportsTransactions() {
 		try {
-			const hello = await (await this.getConnection()).admin().command({ hello: 1 });
-			this.#supportsTransactions = Boolean(hello.setName) || hello.msg === "isdbgrid";
-			return this.#supportsTransactions;
+			return await this.probeTransactions();
 		} catch {
 			return false;
 		}
@@ -2279,14 +2288,19 @@ function cutoffFor(policy, encoding, now = Date.now()) {
 * Delete up to `limit` documents whose anchor field is older than `cutoff`.
 *
 * `deleteMany` has no limit clause, so each batch first collects `_id`s with a
-* bounded `find`, then deletes exactly that set — the Mongo equivalent of the
-* SQL stores' `DELETE ... WHERE rowid/ctid IN (SELECT ... LIMIT n)` pattern.
+* bounded `find`, then deletes that set — the Mongo equivalent of the SQL
+* stores' `DELETE ... WHERE rowid/ctid IN (SELECT ... LIMIT n)` pattern. The
+* delete re-checks the anchor, so a document updated after the `find` (a
+* renewed run ownership, a touched snapshot) survives.
 */
 async function pruneCollectionBatch({ connector, table, column, cutoff, limit }) {
 	const collection = await connector.getCollection(table);
 	const docs = await collection.find({ [column]: { $lt: cutoff } }).project({ _id: 1 }).limit(limit).toArray();
 	if (docs.length === 0) return 0;
-	return (await collection.deleteMany({ _id: { $in: docs.map((doc) => doc._id) } })).deletedCount;
+	return (await collection.deleteMany({
+		_id: { $in: docs.map((doc) => doc._id) },
+		[column]: { $lt: cutoff }
+	})).deletedCount;
 }
 /**
 * Run the bounded/cancellable batched-delete loop for a single logical target,
@@ -6561,6 +6575,40 @@ function isAppendOnlySince(storedObservations, snapshotObservations) {
 	return stored === snapshot || stored.startsWith(snapshot);
 }
 //#endregion
+//#region src/storage/domains/run-fencing.ts
+async function getRunClaims(connector, name) {
+	return await connector.getCollection(name);
+}
+/** Duplicate-key error: an upsert lost the race to insert the document. */
+function isDuplicateKeyError(error) {
+	return error?.code === 11e3;
+}
+/**
+* Runs a write, fenced when `check` is set. A fenced write runs in a
+* transaction that first updates the run's claim document, matching it on
+* the fence. A fence that is no longer current matches nothing, and the write
+* throws `RunFenceConflictError` before anything is written. A claim that
+* changes while the transaction runs makes the update conflict, so the
+* transaction retries and sees the new claim; a claim attempted after the
+* update waits until the transaction commits. Updating the claim document,
+* rather than reading it, is what makes concurrent claims conflict.
+*
+* Fencing is declared only on deployments that support transactions.
+*/
+async function withRunFence(connector, check, write) {
+	if (!check) return write();
+	const { claims, fence, operation } = check;
+	const collection = await getRunClaims(connector, claims);
+	return connector.withTransaction(async (session) => {
+		if ((await collection.updateOne({
+			_id: fence.runId,
+			generation: fence.generation,
+			ownerId: fence.ownerId
+		}, { $inc: { fencedWrites: 1 } }, { session })).matchedCount === 0) throw new _mastra_core_storage.RunFenceConflictError(fence, operation);
+		return write(session);
+	});
+}
+//#endregion
 //#region src/storage/domains/memory/index.ts
 /**
 * Local constant for the observational memory table name.
@@ -6630,9 +6678,6 @@ function buildSuccessorDocument(old, pending) {
 function matchStoredFields(doc, fields) {
 	return Object.fromEntries(fields.map((f) => [f, doc[f] === void 0 ? { $exists: false } : doc[f]]));
 }
-function isDuplicateKeyError(error) {
-	return error?.code === 11e3;
-}
 function omNotFound(operation, id) {
 	return new _mastra_core_error.MastraError({
 		id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", operation, "NOT_FOUND"),
@@ -6672,11 +6717,14 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 		_mastra_core_storage.TABLE_THREADS,
 		_mastra_core_storage.TABLE_MESSAGES,
 		_mastra_core_storage.TABLE_RESOURCES,
-		OM_TABLE
+		OM_TABLE,
+		_mastra_core_storage.TABLE_MEMORY_RUN_FENCES
 	];
 	/**
 	* Retention-eligible collections. The observational-memory collection is
 	* excluded: it has no timestamp anchor to age on. All anchors are BSON dates.
+	* A run fence's `retiredAt` stays null until the execution holding it
+	* settles, and null is never pruned.
 	*/
 	static retentionTables = {
 		messages: {
@@ -6693,6 +6741,11 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			table: _mastra_core_storage.TABLE_THREADS,
 			column: "createdAt",
 			indexed: true
+		},
+		runFences: {
+			table: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			column: "retiredAt",
+			indexed: true
 		}
 	};
 	constructor(config) {
@@ -6711,11 +6764,76 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 		await this.#maintainSupersededBy();
 	}
 	/**
+	* Fenced writes need multi-document transactions, so only replica sets and
+	* sharded clusters fence. Rejects while the deployment can't be probed.
+	*/
+	supportsRunFencing() {
+		return this.#connector.probeTransactions();
+	}
+	async raiseRunFence(fence) {
+		try {
+			const fences = await getRunClaims(this.#connector, _mastra_core_storage.TABLE_MEMORY_RUN_FENCES);
+			for (;;) {
+				try {
+					await fences.updateOne({
+						_id: fence.runId,
+						$or: [{ generation: { $lt: fence.generation } }, {
+							generation: fence.generation,
+							ownerId: fence.ownerId
+						}]
+					}, { $set: {
+						generation: fence.generation,
+						ownerId: fence.ownerId,
+						retiredAt: null
+					} }, { upsert: true });
+					return true;
+				} catch (error) {
+					if (!isDuplicateKeyError(error)) throw error;
+				}
+				const current = await fences.findOne({ _id: fence.runId });
+				if (current && current.generation >= fence.generation) return current.generation === fence.generation && current.ownerId === fence.ownerId;
+			}
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "RAISE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
+	}
+	async retireRunFence(fence) {
+		try {
+			return (await (await getRunClaims(this.#connector, _mastra_core_storage.TABLE_MEMORY_RUN_FENCES)).updateOne({
+				_id: fence.runId,
+				generation: fence.generation,
+				ownerId: fence.ownerId
+			}, [{ $set: { retiredAt: "$$NOW" } }])).matchedCount > 0;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "RETIRE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
+	}
+	/** The check a write must pass: its own fence, otherwise the one in scope. */
+	#runFenceCheck(fence, operation) {
+		const resolved = (0, _mastra_core_storage.resolveRunFence)(this, fence);
+		return resolved && {
+			claims: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			fence: resolved,
+			operation
+		};
+	}
+	/**
 	* Delete memory rows older than each table's `maxAge`, batched. Order is
 	* messages → resources → threads so child rows never outlive the delete of
-	* their thread. Like `deleteThread()`, this does not sweep vector-store
-	* embeddings — semantic-recall vectors live in a separate vector store the
-	* memory domain cannot reach; cleaning those up is the operator's concern.
+	* their thread; run fences are independent and go last. Like
+	* `deleteThread()`, this does not sweep vector-store embeddings —
+	* semantic-recall vectors live in a separate vector store the memory domain
+	* cannot reach; cleaning those up is the operator's concern.
 	*/
 	async prune(policies, options) {
 		const targets = resolveTargets({
@@ -6724,7 +6842,8 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			order: [
 				"messages",
 				"resources",
-				"threads"
+				"threads",
+				"runFences"
 			]
 		});
 		return runPrune({
@@ -6830,17 +6949,19 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 		}
 	}
 	async dangerouslyClearAll() {
-		const [threadsCollection, messagesCollection, resourcesCollection, omCollection] = await Promise.all([
+		const [threadsCollection, messagesCollection, resourcesCollection, omCollection, fencesCollection] = await Promise.all([
 			this.getCollection(_mastra_core_storage.TABLE_THREADS),
 			this.getCollection(_mastra_core_storage.TABLE_MESSAGES),
 			this.getCollection(_mastra_core_storage.TABLE_RESOURCES),
-			this.getCollection(OM_TABLE)
+			this.getCollection(OM_TABLE),
+			this.getCollection(_mastra_core_storage.TABLE_MEMORY_RUN_FENCES)
 		]);
 		await Promise.all([
 			threadsCollection.deleteMany({}),
 			messagesCollection.deleteMany({}),
 			resourcesCollection.deleteMany({}),
-			omCollection.deleteMany({})
+			omCollection.deleteMany({}),
+			fencesCollection.deleteMany({})
 		]);
 	}
 	parseRow(row) {
@@ -7196,7 +7317,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			throw mastraError;
 		}
 	}
-	async saveMessages({ messages }) {
+	async saveMessages({ messages, fence }) {
 		if (messages.length === 0) return { messages: [] };
 		try {
 			if (!messages[0]?.threadId) throw new Error("Thread ID is required");
@@ -7224,12 +7345,16 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			});
 			const allThreadIds = new Set(messages.map((m) => m.threadId));
 			const now = /* @__PURE__ */ new Date();
-			await this.#connector.withTransaction(async (session) => {
+			const writeMessages = async (session) => {
 				await collection.bulkWrite(messagesToInsert, { session });
 				for (const tid of allThreadIds) await threadsCollection.updateOne({ id: tid }, { $set: { updatedAt: now } }, { session });
-			});
+			};
+			const check = this.#runFenceCheck(fence, "saveMessages");
+			if (check) await withRunFence(this.#connector, check, writeMessages);
+			else await this.#connector.withTransaction(writeMessages);
 			return { messages: new _mastra_core_agent.MessageList().add(messages, "memory").get.all.db() };
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "SAVE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -7237,49 +7362,51 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			}, error);
 		}
 	}
-	async updateMessages({ messages }) {
+	async updateMessages({ messages, fence }) {
 		if (messages.length === 0) return [];
 		const messageIds = messages.map((m) => m.id);
 		const collection = await this.getCollection(_mastra_core_storage.TABLE_MESSAGES);
-		const existingMessagesParsed = (await collection.find({ id: { $in: messageIds } }).toArray()).map((msg) => this.parseRow(msg));
-		if (existingMessagesParsed.length === 0) return [];
-		const threadIdsToUpdate = /* @__PURE__ */ new Set();
-		const bulkOps = [];
-		for (const existingMessage of existingMessagesParsed) {
-			const updatePayload = messages.find((m) => m.id === existingMessage.id);
-			if (!updatePayload) continue;
-			const { id, ...fieldsToUpdate } = updatePayload;
-			if (Object.keys(fieldsToUpdate).length === 0) continue;
-			threadIdsToUpdate.add(existingMessage.threadId);
-			if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) threadIdsToUpdate.add(updatePayload.threadId);
-			const updateDoc = {};
-			const updatableFields = { ...fieldsToUpdate };
-			if (updatableFields.content) {
-				const newContent = {
-					...existingMessage.content,
-					...updatableFields.content,
-					...existingMessage.content?.metadata && updatableFields.content.metadata ? { metadata: {
-						...existingMessage.content.metadata,
-						...updatableFields.content.metadata
-					} } : {}
-				};
-				updateDoc.content = JSON.stringify(newContent);
-				delete updatableFields.content;
-			}
-			for (const key in updatableFields) if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
-				const dbKey = key === "threadId" ? "thread_id" : key;
-				let value = updatableFields[key];
-				if (typeof value === "object" && value !== null) value = JSON.stringify(value);
-				updateDoc[dbKey] = value;
+		return withRunFence(this.#connector, this.#runFenceCheck(fence, "updateMessages"), async (session) => {
+			const existingMessagesParsed = (await collection.find({ id: { $in: messageIds } }, { session }).toArray()).map((msg) => this.parseRow(msg));
+			if (existingMessagesParsed.length === 0) return [];
+			const threadIdsToUpdate = /* @__PURE__ */ new Set();
+			const bulkOps = [];
+			for (const existingMessage of existingMessagesParsed) {
+				const updatePayload = messages.find((m) => m.id === existingMessage.id);
+				if (!updatePayload) continue;
+				const { id, ...fieldsToUpdate } = updatePayload;
+				if (Object.keys(fieldsToUpdate).length === 0) continue;
+				threadIdsToUpdate.add(existingMessage.threadId);
+				if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) threadIdsToUpdate.add(updatePayload.threadId);
+				const updateDoc = {};
+				const updatableFields = { ...fieldsToUpdate };
+				if (updatableFields.content) {
+					const newContent = {
+						...existingMessage.content,
+						...updatableFields.content,
+						...existingMessage.content?.metadata && updatableFields.content.metadata ? { metadata: {
+							...existingMessage.content.metadata,
+							...updatableFields.content.metadata
+						} } : {}
+					};
+					updateDoc.content = JSON.stringify(newContent);
+					delete updatableFields.content;
+				}
+				for (const key in updatableFields) if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+					const dbKey = key === "threadId" ? "thread_id" : key;
+					let value = updatableFields[key];
+					if (typeof value === "object" && value !== null) value = JSON.stringify(value);
+					updateDoc[dbKey] = value;
+				}
+				if (Object.keys(updateDoc).length > 0) bulkOps.push({ updateOne: {
+					filter: { id },
+					update: { $set: updateDoc }
+				} });
 			}
-			if (Object.keys(updateDoc).length > 0) bulkOps.push({ updateOne: {
-				filter: { id },
-				update: { $set: updateDoc }
-			} });
-		}
-		if (bulkOps.length > 0) await collection.bulkWrite(bulkOps);
-		if (threadIdsToUpdate.size > 0) await (await this.getCollection(_mastra_core_storage.TABLE_THREADS)).updateMany({ id: { $in: Array.from(threadIdsToUpdate) } }, { $set: { updatedAt: /* @__PURE__ */ new Date() } });
-		return (await collection.find({ id: { $in: messageIds } }).toArray()).map((row) => this.parseRow(row));
+			if (bulkOps.length > 0) await collection.bulkWrite(bulkOps, { session });
+			if (threadIdsToUpdate.size > 0) await (await this.getCollection(_mastra_core_storage.TABLE_THREADS)).updateMany({ id: { $in: Array.from(threadIdsToUpdate) } }, { $set: { updatedAt: /* @__PURE__ */ new Date() } }, { session });
+			return (await collection.find({ id: { $in: messageIds } }, { session }).toArray()).map((row) => this.parseRow(row));
+		});
 	}
 	async getResourceById({ resourceId }) {
 		try {
@@ -7314,9 +7441,11 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			}, error);
 		}
 	}
-	async updateResource({ resourceId, workingMemory, metadata }) {
+	async updateResource({ resourceId, workingMemory, metadata, fence }) {
 		try {
+			const check = this.#runFenceCheck(fence, "updateResource");
 			const existingResource = await this.getResourceById({ resourceId });
+			const collection = await this.getCollection(_mastra_core_storage.TABLE_RESOURCES);
 			if (!existingResource) {
 				const newResource = {
 					id: resourceId,
@@ -7325,7 +7454,11 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 					createdAt: /* @__PURE__ */ new Date(),
 					updatedAt: /* @__PURE__ */ new Date()
 				};
-				return this.saveResource({ resource: newResource });
+				await withRunFence(this.#connector, check, (session) => collection.updateOne({ id: resourceId }, { $set: { ...newResource } }, {
+					upsert: true,
+					session
+				}));
+				return newResource;
 			}
 			const updatedResource = {
 				...existingResource,
@@ -7336,13 +7469,13 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 				} : existingResource.metadata,
 				updatedAt: /* @__PURE__ */ new Date()
 			};
-			const collection = await this.getCollection(_mastra_core_storage.TABLE_RESOURCES);
 			const updateDoc = { updatedAt: updatedResource.updatedAt };
 			if (workingMemory !== void 0) updateDoc.workingMemory = workingMemory;
 			if (metadata) updateDoc.metadata = updatedResource.metadata;
-			await collection.updateOne({ id: resourceId }, { $set: updateDoc });
+			await withRunFence(this.#connector, check, (session) => collection.updateOne({ id: resourceId }, { $set: updateDoc }, { session }));
 			return updatedResource;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "UPDATE_RESOURCE", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -7442,14 +7575,19 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			throw mastraError;
 		}
 	}
-	async saveThread({ thread }) {
+	async saveThread({ thread, fence }) {
 		try {
-			await (await this.getCollection(_mastra_core_storage.TABLE_THREADS)).updateOne({ id: thread.id }, { $set: {
+			const collection = await this.getCollection(_mastra_core_storage.TABLE_THREADS);
+			await withRunFence(this.#connector, this.#runFenceCheck(fence, "saveThread"), (session) => collection.updateOne({ id: thread.id }, { $set: {
 				...thread,
 				metadata: thread.metadata
-			} }, { upsert: true });
+			} }, {
+				upsert: true,
+				session
+			}));
 			return thread;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "SAVE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -7458,7 +7596,8 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			}, error);
 		}
 	}
-	async updateThread({ id, title, metadata }) {
+	async updateThread({ id, title, metadata, fence }) {
+		const check = this.#runFenceCheck(fence, "updateThread");
 		const thread = await this.getThreadById({ threadId: id });
 		if (!thread) throw new _mastra_core_error.MastraError({
 			id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "UPDATE_THREAD", "NOT_FOUND"),
@@ -7481,12 +7620,14 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			updatedAt: now
 		};
 		try {
-			await (await this.getCollection(_mastra_core_storage.TABLE_THREADS)).updateOne({ id }, { $set: {
+			const collection = await this.getCollection(_mastra_core_storage.TABLE_THREADS);
+			await withRunFence(this.#connector, check, (session) => collection.updateOne({ id }, { $set: {
 				title: updatedThread.title,
 				metadata: updatedThread.metadata,
 				updatedAt: now
-			} });
+			} }, { session }));
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "UPDATE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -7509,16 +7650,19 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			}, error);
 		}
 	}
-	async deleteMessages(messageIds) {
+	async deleteMessages(messageIds, options) {
 		if (messageIds.length === 0) return;
 		try {
 			const messagesCollection = await this.getCollection(_mastra_core_storage.TABLE_MESSAGES);
 			const threadsCollection = await this.getCollection(_mastra_core_storage.TABLE_THREADS);
-			const messagesToDelete = await messagesCollection.find({ id: { $in: messageIds } }).toArray();
-			const threadIds = [...new Set(messagesToDelete.map((m) => m.thread_id))];
-			await messagesCollection.deleteMany({ id: { $in: messageIds } });
-			if (threadIds.length > 0) await threadsCollection.updateMany({ id: { $in: threadIds } }, { $set: { updatedAt: /* @__PURE__ */ new Date() } });
+			await withRunFence(this.#connector, this.#runFenceCheck(options?.fence, "deleteMessages"), async (session) => {
+				const messagesToDelete = await messagesCollection.find({ id: { $in: messageIds } }, { session }).toArray();
+				const threadIds = [...new Set(messagesToDelete.map((m) => m.thread_id))];
+				await messagesCollection.deleteMany({ id: { $in: messageIds } }, { session });
+				if (threadIds.length > 0) await threadsCollection.updateMany({ id: { $in: threadIds } }, { $set: { updatedAt: /* @__PURE__ */ new Date() } }, { session });
+			});
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "DELETE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -7885,7 +8029,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 					applied: false,
 					reason: "conflict"
 				};
-				if ((await collection.updateOne({
+				if ((await withRunFence(this.#connector, this.#runFenceCheck(void 0, "updateActiveObservations"), (session) => collection.updateOne({
 					id: input.id,
 					supersededBy: null,
 					...matchStoredFields(doc, ["activeObservations", "lastObservedAt"])
@@ -7899,7 +8043,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 						updatedAt: /* @__PURE__ */ new Date()
 					},
 					$inc: { totalTokensObserved: safeTokenCount }
-				})).matchedCount === 1) return { applied: true };
+				}, { session }))).matchedCount === 1) return { applied: true };
 			}
 			throw omConflict("UPDATE_ACTIVE_OBSERVATIONS", input.id);
 		} catch (error) {
@@ -7915,7 +8059,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 	async createReflectionGeneration(input) {
 		try {
 			const { currentRecord } = input;
-			return await this.#rollOver(currentRecord, (doc) => {
+			return await this.#rollOver(currentRecord, "createReflectionGeneration", (doc) => {
 				const stored = this.parseOMDocument(doc);
 				const plan = planReflectionGenerationText({
 					storedObservations: stored.activeObservations,
@@ -8152,7 +8296,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			let hops = 0;
 			let retries = 0;
 			for (;;) {
-				if ((await collection.updateOne({
+				if ((await withRunFence(this.#connector, this.#runFenceCheck(void 0, "updateBufferedObservations"), (session) => collection.updateOne({
 					id: targetId,
 					supersededBy: null,
 					"bufferedObservationChunks.cycleId": { $ne: input.chunk.cycleId },
@@ -8166,7 +8310,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 					bufferedObservationChunks: { $concatArrays: [{ $ifNull: ["$bufferedObservationChunks", []] }, { $literal: [newChunk] }] },
 					...lastBufferedAtTime ? { lastBufferedAtTime: { $max: ["$lastBufferedAtTime", { $literal: lastBufferedAtTime }] } } : {},
 					updatedAt: { $literal: /* @__PURE__ */ new Date() }
-				} }])).matchedCount === 1) return {
+				} }], { session }))).matchedCount === 1) return {
 					persisted: true,
 					recordId: targetId
 				};
@@ -8189,7 +8333,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 					recordId: targetId
 				};
 				if (stored !== void 0 && stored !== null && !Array.isArray(stored)) {
-					if ((await collection.updateOne({
+					if ((await withRunFence(this.#connector, this.#runFenceCheck(void 0, "updateBufferedObservations"), (session) => collection.updateOne({
 						id: targetId,
 						supersededBy: null,
 						bufferedObservationChunks: stored,
@@ -8198,7 +8342,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 						bufferedObservationChunks: [newChunk],
 						...lastBufferedAtTime ? { lastBufferedAtTime: maxObservationCursor(doc.lastBufferedAtTime, lastBufferedAtTime) } : {},
 						updatedAt: /* @__PURE__ */ new Date()
-					} })).matchedCount === 1) return {
+					} }, { session }))).matchedCount === 1) return {
 						persisted: true,
 						recordId: targetId
 					};
@@ -8288,7 +8432,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 				const newTokenCount = existingTokenCount + activatedTokens;
 				const existingPending = Number(doc.pendingMessageTokens || 0);
 				const newPending = Math.max(0, existingPending - activatedMessageTokens);
-				if ((await collection.updateOne({
+				if ((await withRunFence(this.#connector, this.#runFenceCheck(void 0, "swapBufferedToActive"), (session) => collection.updateOne({
 					id: input.id,
 					supersededBy: null,
 					...matchStoredFields(doc, [
@@ -8305,7 +8449,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 					bufferedObservationChunks: remainingChunks,
 					lastObservedAt: maxObservationCursor(doc.lastObservedAt, lastObservedAt),
 					updatedAt: /* @__PURE__ */ new Date()
-				} })).matchedCount === 0) continue;
+				} }, { session }))).matchedCount === 0) continue;
 				const latestChunkHints = activatedChunks[activatedChunks.length - 1];
 				return {
 					chunksActivated: activatedChunks.length,
@@ -8354,13 +8498,13 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			const newContent = existingContent ? `${existingContent}\n\n${input.reflection}` : input.reflection;
 			const newTokens = existingTokens + input.tokenCount;
 			const newInputTokens = existingInputTokens + input.inputTokenCount;
-			if ((await collection.updateOne({ id: input.id }, { $set: {
+			if ((await withRunFence(this.#connector, this.#runFenceCheck(void 0, "updateBufferedReflection"), (session) => collection.updateOne({ id: input.id }, { $set: {
 				bufferedReflection: newContent,
 				bufferedReflectionTokens: newTokens,
 				bufferedReflectionInputTokens: newInputTokens,
 				reflectedObservationLineCount: input.reflectedObservationLineCount,
 				updatedAt: /* @__PURE__ */ new Date()
-			} })).matchedCount === 0) throw new _mastra_core_error.MastraError({
+			} }, { session }))).matchedCount === 0) throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "UPDATE_BUFFERED_REFLECTION", "NOT_FOUND"),
 				text: `Observational memory record not found: ${input.id}`,
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -8380,7 +8524,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 	async swapBufferedReflectionToActive(input) {
 		try {
 			const { currentRecord } = input;
-			return await this.#rollOver(currentRecord, (doc) => {
+			return await this.#rollOver(currentRecord, "swapBufferedReflectionToActive", (doc) => {
 				const stored = this.parseOMDocument(doc);
 				const bufferedReflection = stored.bufferedReflection || "";
 				if (!bufferedReflection) throw new _mastra_core_error.MastraError({
@@ -8466,7 +8610,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 	*
 	* A crash between 2 and 3 is finished by the next head read (`#getHeadDoc`) or startup.
 	*/
-	async #rollOver(currentRecord, decide) {
+	async #rollOver(currentRecord, operation, decide) {
 		const collection = await this.getCollection(OM_TABLE);
 		for (let attempt = 1; attempt <= OM_MAX_CONDITIONAL_ATTEMPTS; attempt++) {
 			const doc = await collection.findOne({ id: currentRecord.id });
@@ -8477,7 +8621,7 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			}
 			const pending = decide(doc);
 			if (!pending) return this.parseOMDocument(doc);
-			const frozen = await collection.findOneAndUpdate({
+			const frozen = await withRunFence(this.#connector, this.#runFenceCheck(void 0, operation), (session) => collection.findOneAndUpdate({
 				id: doc.id,
 				supersededBy: null,
 				...matchStoredFields(doc, [
@@ -8489,7 +8633,10 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends _mastra_core_stora
 			}, { $set: {
 				supersededBy: pending.newId,
 				pendingSuccessor: pending
-			} }, { returnDocument: "before" });
+			} }, {
+				returnDocument: "before",
+				session
+			}));
 			if (!frozen) continue;
 			return this.parseOMDocument(await this.#completeRollover(collection, frozen, pending));
 		}
@@ -11804,33 +11951,58 @@ var MongoDBWorkflowDefinitionsStore = class MongoDBWorkflowDefinitionsStore exte
 };
 //#endregion
 //#region src/storage/domains/workflows/index.ts
+const RUN_OWNER_PROJECTION = {
+	generation: 1,
+	ownerId: 1,
+	leaseExpiresAt: 1,
+	live: { $gt: ["$leaseExpiresAt", "$$NOW"] }
+};
+const NOT_LIVE = { $or: [{ leaseExpiresAt: null }, { $expr: { $lte: ["$leaseExpiresAt", "$$NOW"] } }] };
+function toRunOwnershipRecord(doc) {
+	return {
+		runId: doc._id,
+		generation: Number(doc.generation),
+		ownerId: doc.ownerId,
+		leaseExpiresAt: doc.leaseExpiresAt ?? null,
+		live: Boolean(doc.live)
+	};
+}
 var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core_storage.WorkflowsStorage {
 	#connector;
 	#skipDefaultIndexes;
 	#indexes;
 	/** Collections managed by this domain */
-	static MANAGED_COLLECTIONS = [_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT];
+	static MANAGED_COLLECTIONS = [_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS];
 	/**
-	* Anchor is `updatedAt` (BSON date), so the policy reads as inactivity:
-	* a run is pruned only after its snapshot has not been touched for `maxAge`.
+	* Both anchors are `updatedAt` (BSON date), so the policies read as
+	* inactivity: a run is pruned only after its snapshot has not been touched
+	* for `maxAge`, and an ownership document only after no claim, renewal or
+	* release has touched it for `maxAge`.
 	*/
-	static retentionTables = { workflowSnapshot: {
-		table: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
-		column: "updatedAt",
-		indexed: true
-	} };
+	static retentionTables = {
+		workflowSnapshot: {
+			table: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+			column: "updatedAt",
+			indexed: true
+		},
+		runOwnership: {
+			table: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			column: "updatedAt",
+			indexed: true
+		}
+	};
 	constructor(config) {
 		super();
 		this.#connector = resolveMongoDBConfig(config);
 		this.#skipDefaultIndexes = config.skipDefaultIndexes;
 		this.#indexes = config.indexes?.filter((idx) => WorkflowsStorageMongoDB.MANAGED_COLLECTIONS.includes(idx.collection));
 	}
-	/** Delete workflow snapshots idle for longer than the policy's `maxAge`, batched. */
+	/** Delete workflow snapshots and ownership documents idle for longer than each policy's `maxAge`, batched. */
 	async prune(policies, options) {
 		const targets = resolveTargets({
 			policies,
 			descriptor: WorkflowsStorageMongoDB.retentionTables,
-			order: ["workflowSnapshot"]
+			order: ["workflowSnapshot", "runOwnership"]
 		});
 		return runPrune({
 			connector: this.#connector,
@@ -11843,6 +12015,13 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 	supportsConcurrentUpdates() {
 		return true;
 	}
+	/**
+	* Fenced writes need multi-document transactions, so only replica sets and
+	* sharded clusters fence. Rejects while the deployment can't be probed.
+	*/
+	supportsRunFencing() {
+		return this.#connector.probeTransactions();
+	}
 	async getCollection(name) {
 		return this.#connector.getCollection(name);
 	}
@@ -11850,6 +12029,124 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 		await this.createDefaultIndexes();
 		await this.createCustomIndexes();
 	}
+	#runFenceCheck(fence, runId, operation) {
+		const resolved = (0, _mastra_core_storage.resolveRunFence)(this, fence, runId);
+		return resolved && {
+			claims: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			fence: resolved,
+			operation
+		};
+	}
+	async #readRunOwner(runId) {
+		const doc = await (await getRunClaims(this.#connector, _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS)).findOne({ _id: runId }, { projection: RUN_OWNER_PROJECTION });
+		return doc ? toRunOwnershipRecord(doc) : null;
+	}
+	#ownershipError(operation, runId, error) {
+		return new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", operation, "FAILED"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+			details: { runId }
+		}, error);
+	}
+	async claimRunOwnership({ runId, ownerId, leaseMs, force, expectedGeneration }) {
+		try {
+			const owners = await getRunClaims(this.#connector, _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS);
+			const claim = (generation) => [{ $set: {
+				generation,
+				ownerId: { $literal: ownerId },
+				leaseExpiresAt: { $add: ["$$NOW", leaseMs] },
+				updatedAt: "$$NOW"
+			} }];
+			if (!expectedGeneration) {
+				try {
+					const created = await owners.findOneAndUpdate({
+						_id: runId,
+						generation: { $exists: false }
+					}, claim({ $max: [1, { $toLong: "$$NOW" }] }), {
+						upsert: true,
+						returnDocument: "after",
+						projection: RUN_OWNER_PROJECTION
+					});
+					if (created) return {
+						acquired: true,
+						record: toRunOwnershipRecord(created)
+					};
+				} catch (error) {
+					if (!isDuplicateKeyError(error)) throw error;
+				}
+				if (expectedGeneration === 0) return {
+					acquired: false,
+					record: await this.#readRunOwner(runId)
+				};
+			}
+			const advanced = await owners.findOneAndUpdate({
+				_id: runId,
+				...expectedGeneration !== void 0 ? { generation: expectedGeneration } : {},
+				...force ? {} : NOT_LIVE
+			}, claim({ $add: ["$generation", 1] }), {
+				returnDocument: "after",
+				projection: RUN_OWNER_PROJECTION
+			});
+			if (advanced) return {
+				acquired: true,
+				record: toRunOwnershipRecord(advanced)
+			};
+			return {
+				acquired: false,
+				record: await this.#readRunOwner(runId)
+			};
+		} catch (error) {
+			throw this.#ownershipError("CLAIM_RUN_OWNERSHIP", runId, error);
+		}
+	}
+	async renewRunOwnership({ leaseMs, ...fence }) {
+		try {
+			const renewed = await (await getRunClaims(this.#connector, _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS)).findOneAndUpdate({
+				_id: fence.runId,
+				generation: fence.generation,
+				ownerId: fence.ownerId,
+				leaseExpiresAt: { $ne: null }
+			}, [{ $set: {
+				leaseExpiresAt: { $add: ["$$NOW", leaseMs] },
+				updatedAt: "$$NOW"
+			} }], {
+				returnDocument: "after",
+				projection: RUN_OWNER_PROJECTION
+			});
+			if (renewed) return {
+				renewed: true,
+				record: toRunOwnershipRecord(renewed)
+			};
+			return {
+				renewed: false,
+				record: await this.#readRunOwner(fence.runId)
+			};
+		} catch (error) {
+			throw this.#ownershipError("RENEW_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async releaseRunOwnership(fence) {
+		try {
+			return (await (await getRunClaims(this.#connector, _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS)).updateOne({
+				_id: fence.runId,
+				generation: fence.generation,
+				ownerId: fence.ownerId
+			}, [{ $set: {
+				leaseExpiresAt: null,
+				updatedAt: "$$NOW"
+			} }])).matchedCount > 0;
+		} catch (error) {
+			throw this.#ownershipError("RELEASE_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async getRunOwnership({ runId }) {
+		try {
+			return await this.#readRunOwner(runId);
+		} catch (error) {
+			throw this.#ownershipError("GET_RUN_OWNERSHIP", runId, error);
+		}
+	}
 	/**
 	* Returns default index definitions for the workflows domain collections.
 	*/
@@ -11909,8 +12206,10 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 	}
 	async dangerouslyClearAll() {
 		await (await this.getCollection(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT)).deleteMany({});
+		await (await this.getCollection(_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS)).deleteMany({});
 	}
-	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state }) {
+	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state, fence }) {
+		const check = this.#runFenceCheck(fence, runId, "updateWorkflowResults");
 		try {
 			const collection = await this.getCollection(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
 			const now = /* @__PURE__ */ new Date();
@@ -11930,7 +12229,7 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 				runId,
 				requestContext: {}
 			};
-			const updatedDoc = await collection.findOneAndUpdate({
+			const updatedDoc = await withRunFence(this.#connector, check, (session) => collection.findOneAndUpdate({
 				workflow_name: workflowName,
 				run_id: runId
 			}, [{ $set: {
@@ -11945,10 +12244,12 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 				createdAt: { $ifNull: ["$createdAt", now] }
 			} }], {
 				upsert: true,
-				returnDocument: "after"
-			});
+				returnDocument: "after",
+				session
+			}));
 			return (typeof updatedDoc?.snapshot === "string" ? JSON.parse(updatedDoc.snapshot) : updatedDoc?.snapshot)?.context || {};
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -11961,7 +12262,8 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 			}, error);
 		}
 	}
-	async updateWorkflowState({ workflowName, runId, opts }) {
+	async updateWorkflowState({ workflowName, runId, opts, fence }) {
+		const check = this.#runFenceCheck(fence, runId, "updateWorkflowState");
 		try {
 			const collection = await this.getCollection(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
 			const { expectedStatus, ...state } = opts;
@@ -11970,10 +12272,13 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 				run_id: runId
 			};
 			if (expectedStatus !== void 0) filter["snapshot.status"] = { $in: Array.isArray(expectedStatus) ? expectedStatus : [expectedStatus] };
-			const updatedDoc = await collection.findOneAndUpdate(filter, [{ $set: {
+			const updatedDoc = await withRunFence(this.#connector, check, (session) => collection.findOneAndUpdate(filter, [{ $set: {
 				snapshot: { $mergeObjects: ["$snapshot", state] },
 				updatedAt: /* @__PURE__ */ new Date()
-			} }], { returnDocument: "after" });
+			} }], {
+				returnDocument: "after",
+				session
+			}));
 			if (!updatedDoc) return;
 			const snapshot = typeof updatedDoc.snapshot === "string" ? JSON.parse(updatedDoc.snapshot) : updatedDoc.snapshot;
 			if (!snapshot?.context) throw new _mastra_core_error.MastraError({
@@ -11988,7 +12293,7 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 			});
 			return snapshot;
 		} catch (error) {
-			if (error instanceof _mastra_core_error.MastraError) throw error;
+			if (error instanceof _mastra_core_error.MastraError || (0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "UPDATE_WORKFLOW_STATE", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -12000,10 +12305,12 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 			}, error);
 		}
 	}
-	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt }) {
+	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt, fence }) {
+		const check = this.#runFenceCheck(fence, runId, "persistWorkflowSnapshot");
 		try {
 			const now = /* @__PURE__ */ new Date();
-			await (await this.getCollection(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT)).updateOne({
+			const collection = await this.getCollection(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+			await withRunFence(this.#connector, check, (session) => collection.updateOne({
 				workflow_name: workflowName,
 				run_id: runId
 			}, {
@@ -12015,8 +12322,12 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 					updatedAt: updatedAt ?? now
 				},
 				$setOnInsert: { createdAt: createdAt ?? now }
-			}, { upsert: true });
+			}, {
+				upsert: true,
+				session
+			}));
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -12109,13 +12420,16 @@ var WorkflowsStorageMongoDB = class WorkflowsStorageMongoDB extends _mastra_core
 			}, error);
 		}
 	}
-	async deleteWorkflowRunById({ runId, workflowName }) {
+	async deleteWorkflowRunById({ runId, workflowName, fence }) {
+		const check = this.#runFenceCheck(fence, runId, "deleteWorkflowRunById");
 		try {
-			await (await this.getCollection(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT)).deleteOne({
+			const collection = await this.getCollection(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+			await withRunFence(this.#connector, check, (session) => collection.deleteOne({
 				workflow_name: workflowName,
 				run_id: runId
-			});
+			}, { session }));
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MONGODB", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,