@mastra/mysql 0.13.0 → 0.13.1-alpha.1

package/dist/index.cjs

@@ -3,6 +3,7 @@ let _mastra_core_error = require("@mastra/core/error");
 let _mastra_core_storage = require("@mastra/core/storage");
 let mysql2_promise = require("mysql2/promise");
 let _mastra_core_utils = require("@mastra/core/utils");
+let crypto$1 = require("crypto");
 let _mastra_core_agent = require("@mastra/core/agent");
 let _mastra_core_storage_domains_skills = require("@mastra/core/storage/domains/skills");
 //#region src/storage/db/schema-snapshot.ts
@@ -6022,9 +6023,180 @@ var MCPServersMySQL = class MCPServersMySQL extends _mastra_core_storage.MCPServ
 	}
 };
 //#endregion
+//#region ../../packages/_internal-core/dist/memory/index.js
+/**
+* Shared rules for observational memory lifecycle writes. Every storage adapter applies
+* these inside its own atomic section (lock, transaction, or conditional update), so the
+* decisions are identical across adapters.
+*/
+/**
+* Observational memory columns that lifecycle writes depend on. Storage adapters merge these
+* into the table schema they get from `@mastra/core`, so the columns exist even when the
+* installed core predates them.
+*/
+const OBSERVATIONAL_MEMORY_LIFECYCLE_COLUMNS = { supersededBy: {
+	type: "text",
+	nullable: true
+} };
+/** `schema` plus {@link OBSERVATIONAL_MEMORY_LIFECYCLE_COLUMNS}; `undefined` when `schema` is. */
+function withObservationalMemoryLifecycleColumns(schema) {
+	return schema ? {
+		...schema,
+		...OBSERVATIONAL_MEMORY_LIFECYCLE_COLUMNS
+	} : void 0;
+}
+/**
+* A buffered chunk stores `lastObservedAt = max message time + 1ms`. It is wholly covered
+* (every message it observed is already at or before the cursor) iff
+* `cursor >= chunk.lastObservedAt - 1ms`.
+*/
+function isBufferedChunkCoveredByCursor(chunkLastObservedAt, cursor) {
+	if (!cursor) return false;
+	return new Date(cursor).getTime() >= new Date(chunkLastObservedAt).getTime() - 1;
+}
+/** The later of two cursors; `undefined` only when both are absent. */
+function maxObservationCursor(a, b) {
+	if (!a) return b ? new Date(b) : void 0;
+	if (!b) return new Date(a);
+	return new Date(Math.max(new Date(a).getTime(), new Date(b).getTime()));
+}
+/**
+* Decide the new generation's text when a reflection built from `snapshot` commits against
+* the stored record.
+*
+* - Stored text equals the snapshot: the reflection replaces it.
+* - Stored text extends the snapshot (activation only appends): the appended tail is kept
+*   after the reflection, and its tokens are added.
+* - Anything else (a non-append rewrite): `null` — the reflection must not be applied.
+*/
+function planReflectionGenerationText(input) {
+	const stored = input.storedObservations ?? "";
+	const snapshot = input.snapshotObservations ?? "";
+	if (stored === snapshot) return {
+		mode: "equal",
+		observations: input.reflection,
+		tokenCount: input.tokenCount
+	};
+	if (!stored.startsWith(snapshot)) return null;
+	const tail = stored.slice(snapshot.length).trimStart();
+	if (!tail.trim()) return {
+		mode: "equal",
+		observations: input.reflection,
+		tokenCount: input.tokenCount
+	};
+	return {
+		mode: "append",
+		observations: input.reflection ? `${input.reflection}\n\n${tail}` : tail,
+		tokenCount: input.tokenCount + Math.max(0, (input.storedObservationTokenCount ?? 0) - (input.snapshotObservationTokenCount ?? 0))
+	};
+}
+/**
+* Backs `updateActiveObservations` in adapters that implement `commitActiveObservations`.
+* Callers of `updateActiveObservations` (which resolves `void`) can't see a commit result, so a
+* write that was not applied throws instead of resolving as if it had committed.
+*/
+function assertActiveObservationsApplied(result, id) {
+	if (result.applied) return;
+	throw new Error(result.reason === "retired" ? `Observational memory record ${id} was superseded by a newer generation; observations were not written` : `Observational memory record ${id} changed since the observations were composed; observations were not written`);
+}
+/**
+* Whether the stored text can still accept a reflection built from `snapshot`
+* (equal, or only appended to since).
+*/
+function isAppendOnlySince(storedObservations, snapshotObservations) {
+	const stored = storedObservations ?? "";
+	const snapshot = snapshotObservations ?? "";
+	return stored === snapshot || stored.startsWith(snapshot);
+}
+//#endregion
+//#region src/storage/db/run-fencing.ts
+/**
+* Epoch milliseconds on the database clock. `UTC_TIMESTAMP` is the time the
+* statement started and doesn't depend on the session time zone. Every lease
+* comparison runs in a statement that already holds the run's owner row, so
+* no lock wait sits between that start time and the comparison.
+*/
+const DB_NOW_MS = `(TIMESTAMPDIFF(MICROSECOND, '1970-01-01 00:00:00', UTC_TIMESTAMP(3)) DIV 1000)`;
+const ER_DUP_ENTRY = 1062;
+const ER_LOCK_DEADLOCK = 1213;
+const MAX_CLAIM_ATTEMPTS = 5;
+/**
+* The check half of a fenced write; call it first inside the write's
+* transaction. The shared lock holds the claim row until commit, so a claim
+* that updates the row waits for the write to finish, and every later write
+* sees the new claim.
+*/
+async function assertRunFence(q, claimsTable, fence, operation) {
+	const [rows] = await q.execute(`SELECT generation, ${quoteIdentifier("ownerId", "column name")} AS ownerId FROM ${claimsTable}
+     WHERE ${quoteIdentifier("runId", "column name")} = ? LOCK IN SHARE MODE`, [fence.runId]);
+	const row = rows[0];
+	if (!(0, _mastra_core_storage.matchesRunFence)(row ? {
+		generation: Number(row.generation),
+		ownerId: String(row.ownerId)
+	} : null, fence)) throw new _mastra_core_storage.RunFenceConflictError(fence, operation);
+}
+/** Runs `fn` in a transaction on its own pooled connection. */
+async function inTransaction(pool, fn) {
+	const connection = await pool.getConnection();
+	try {
+		await connection.beginTransaction();
+		const result = await fn(connection);
+		await connection.commit();
+		return result;
+	} catch (error) {
+		await connection.rollback().catch(() => {});
+		throw error;
+	} finally {
+		connection.release();
+	}
+}
+/**
+* Runs `write` directly when it carries no fence, or in a transaction behind
+* the fence check when it does.
+*/
+function withRunFence(pool, claimsTable, fence, operation, write) {
+	if (!fence) return write(pool);
+	return inTransaction(pool, async (connection) => {
+		await assertRunFence(connection, claimsTable, fence, operation);
+		return write(connection);
+	});
+}
+/**
+* Runs a transaction that creates or updates a run's claim row, retrying when
+* two first claims race to insert it. Under REPEATABLE READ both lock the gap
+* where the row would go and one is chosen as a deadlock victim; under READ
+* COMMITTED the later insert hits the duplicate key. On retry the row exists
+* and the claim serializes behind its row lock.
+*/
+async function claimTransaction(pool, fn) {
+	for (let attempt = 1;; attempt++) try {
+		return await inTransaction(pool, fn);
+	} catch (error) {
+		const errno = error.errno;
+		if (attempt >= MAX_CLAIM_ATTEMPTS || errno !== ER_DUP_ENTRY && errno !== ER_LOCK_DEADLOCK) throw error;
+	}
+}
+//#endregion
 //#region src/storage/domains/memory/index.ts
 const OM_TABLE = "mastra_observational_memory";
 const OM_TABLE_QUOTED = quoteIdentifier(OM_TABLE, "table name");
+const RUN_FENCES_TABLE = formatTableName(_mastra_core_storage.TABLE_MEMORY_RUN_FENCES);
+const RUN_ID$1 = quoteIdentifier("runId", "column name");
+const OWNER_ID$1 = quoteIdentifier("ownerId", "column name");
+const RETIRED_AT = quoteIdentifier("retiredAt", "column name");
+/** Canonical head order: newest generation, then earliest createdAt, then lowest id. */
+const OM_HEAD_ORDER = `${quoteIdentifier("generationCount", "column name")} DESC, ${quoteIdentifier("createdAt", "column name")} ASC, ${quoteIdentifier("id", "column name")} ASC`;
+/** Max `supersededBy` hops when redirecting a write aimed at a retired record. */
+const OM_MAX_HEAD_HOPS = 3;
+/** Attempts for an OM transaction that hits a deadlock or lock-wait timeout. */
+const OM_MAX_TRANSACTION_ATTEMPTS = 3;
+/** How long initialization waits for the per-key `GET_LOCK` before failing. */
+const OM_INIT_LOCK_TIMEOUT_SECONDS = 30;
+/** ER_LOCK_DEADLOCK (1213) or ER_LOCK_WAIT_TIMEOUT (1205): the transaction was rolled back and can be retried. */
+function isRetryableLockError(error) {
+	const errno = error?.errno;
+	return errno === 1213 || errno === 1205;
+}
 function emitValidationError(message) {
 	return new _mastra_core_error.MastraError({
 		id: "MYSQL_MEMORY_VALIDATION_ERROR",
@@ -6118,6 +6290,69 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 		this.#skipDefaultIndexes = skipDefaultIndexes;
 		this.#indexes = indexes?.filter((idx) => MemoryMySQL.MANAGED_TABLES.includes(idx.table));
 	}
+	supportsRunFencing() {
+		return true;
+	}
+	async raiseRunFence(fence) {
+		try {
+			return await claimTransaction(this.pool, async (connection) => {
+				const [rows] = await connection.execute(`SELECT generation, ${OWNER_ID$1} AS ownerId FROM ${RUN_FENCES_TABLE} WHERE ${RUN_ID$1} = ? FOR UPDATE`, [fence.runId]);
+				const row = rows[0];
+				if (!row) {
+					await connection.execute(`INSERT INTO ${RUN_FENCES_TABLE} (${RUN_ID$1}, generation, ${OWNER_ID$1}) VALUES (?, ?, ?)`, [
+						fence.runId,
+						fence.generation,
+						fence.ownerId
+					]);
+					return true;
+				}
+				const generation = Number(row.generation);
+				const raises = generation < fence.generation;
+				const reaffirms = generation === fence.generation && String(row.ownerId) === fence.ownerId;
+				if (!raises && !reaffirms) return false;
+				await connection.execute(`UPDATE ${RUN_FENCES_TABLE} SET generation = ?, ${OWNER_ID$1} = ?, ${RETIRED_AT} = NULL WHERE ${RUN_ID$1} = ?`, [
+					fence.generation,
+					fence.ownerId,
+					fence.runId
+				]);
+				return true;
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "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 inTransaction(this.pool, async (connection) => {
+				const [rows] = await connection.execute(`SELECT generation, ${OWNER_ID$1} AS ownerId FROM ${RUN_FENCES_TABLE} WHERE ${RUN_ID$1} = ? FOR UPDATE`, [fence.runId]);
+				const row = rows[0];
+				if (!row || Number(row.generation) !== fence.generation || String(row.ownerId) !== fence.ownerId) return false;
+				await connection.execute(`UPDATE ${RUN_FENCES_TABLE} SET ${RETIRED_AT} = ${DB_NOW_MS} WHERE ${RUN_ID$1} = ?`, [fence.runId]);
+				return true;
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "RETIRE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
+	}
+	/** Runs `write` behind its own fence, otherwise the one in scope for this store. */
+	#fenced(fence, operation, write) {
+		return withRunFence(this.pool, RUN_FENCES_TABLE, (0, _mastra_core_storage.resolveRunFence)(this, fence), operation, write);
+	}
+	/** The fence check for a write that already runs in its own transaction. */
+	async #assertFence(connection, fence, operation) {
+		const resolved = (0, _mastra_core_storage.resolveRunFence)(this, fence);
+		if (resolved) await assertRunFence(connection, RUN_FENCES_TABLE, resolved, operation);
+	}
 	async init() {
 		await this.operations.createTable({
 			tableName: _mastra_core_storage.TABLE_THREADS,
@@ -6131,7 +6366,11 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 			tableName: _mastra_core_storage.TABLE_RESOURCES,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_RESOURCES]
 		});
-		const omSchema = _mastra_core_storage.OBSERVATIONAL_MEMORY_TABLE_SCHEMA?.[OM_TABLE];
+		await this.operations.createTable({
+			tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_MEMORY_RUN_FENCES]
+		});
+		const omSchema = withObservationalMemoryLifecycleColumns(_mastra_core_storage.OBSERVATIONAL_MEMORY_TABLE_SCHEMA?.[OM_TABLE]);
 		if (omSchema) {
 			await this.operations.createTable({
 				tableName: OM_TABLE,
@@ -6154,7 +6393,8 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 					"isBufferingObservation",
 					"isBufferingReflection",
 					"lastBufferedAtTokens",
-					"lastBufferedAtTime"
+					"lastBufferedAtTime",
+					"supersededBy"
 				]
 			});
 		}
@@ -6172,6 +6412,7 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 				if (err?.errno !== 1061) throw err;
 			}
 		}
+		if (omSchema) await this.backfillSupersededBy();
 		await this.createDefaultIndexes();
 		await this.createCustomIndexes();
 	}
@@ -6196,6 +6437,10 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 			tableName,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[tableName]
 		}));
+		statements.push(generateTableSQL({
+			tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_MEMORY_RUN_FENCES]
+		}));
 		for (const idx of MemoryMySQL.getDefaultIndexDefs()) statements.push(generateIndexSQL(idx));
 		return statements;
 	}
@@ -6214,6 +6459,7 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 		await this.pool.execute(`DELETE FROM ${formatTableName(_mastra_core_storage.TABLE_MESSAGES)}`);
 		await this.pool.execute(`DELETE FROM ${formatTableName(_mastra_core_storage.TABLE_THREADS)}`);
 		await this.pool.execute(`DELETE FROM ${formatTableName(_mastra_core_storage.TABLE_RESOURCES)}`);
+		await this.pool.execute(`DELETE FROM ${RUN_FENCES_TABLE}`);
 		try {
 			await this.pool.execute(`DELETE FROM ${OM_TABLE_QUOTED}`);
 		} catch (err) {
@@ -6394,8 +6640,8 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 		}
 		return includeMessages;
 	}
-	async upsertThread(thread) {
-		await this.operations.insert({
+	async upsertThread(q, thread) {
+		const statement = prepareStatement({
 			tableName: _mastra_core_storage.TABLE_THREADS,
 			record: {
 				id: thread.id,
@@ -6406,18 +6652,22 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 				updatedAt: thread.updatedAt
 			}
 		});
+		await q.execute(statement.sql, statement.args);
+	}
+	async #readThread(q, threadId, resourceId) {
+		let sql = `SELECT * FROM ${formatTableName(_mastra_core_storage.TABLE_THREADS)} WHERE ${quoteIdentifier("id", "column name")} = ?`;
+		const params = [threadId];
+		if (resourceId !== void 0) {
+			sql += ` AND ${quoteIdentifier("resourceId", "column name")} = ?`;
+			params.push(resourceId);
+		}
+		const [rows] = await q.execute(sql, params);
+		const row = rows[0];
+		return row ? this.mapThread(row) : null;
 	}
 	async getThreadById({ threadId, resourceId }) {
 		try {
-			let sql = `SELECT * FROM ${formatTableName(_mastra_core_storage.TABLE_THREADS)} WHERE ${quoteIdentifier("id", "column name")} = ?`;
-			const params = [threadId];
-			if (resourceId !== void 0) {
-				sql += ` AND ${quoteIdentifier("resourceId", "column name")} = ?`;
-				params.push(resourceId);
-			}
-			const [rows] = await this.pool.execute(sql, params);
-			const row = rows[0];
-			return row ? this.mapThread(row) : null;
+			return await this.#readThread(this.pool, threadId, resourceId);
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: "MYSQL_MEMORY_GET_THREAD_BY_ID_FAILED",
@@ -6570,11 +6820,12 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 			} : void 0
 		});
 	}
-	async saveThread({ thread }) {
+	async saveThread({ thread, fence }) {
 		try {
-			await this.upsertThread(thread);
+			await this.#fenced(fence, "saveThread", (q) => this.upsertThread(q, thread));
 			return thread;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: "MYSQL_MEMORY_SAVE_THREAD_FAILED",
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -6583,36 +6834,39 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async updateThread({ id, title, metadata }) {
+	async updateThread({ id, title, metadata, fence }) {
 		try {
-			const existing = await this.getThreadById({ threadId: id });
-			if (!existing) throw new _mastra_core_error.MastraError({
-				id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "UPDATE_THREAD", "NOT_FOUND"),
-				domain: _mastra_core_error.ErrorDomain.STORAGE,
-				category: _mastra_core_error.ErrorCategory.USER,
-				text: `Thread ${id} not found`,
-				details: { threadId: id }
-			});
-			const mergedMetadata = {
-				...existing.metadata ?? {},
-				...metadata ?? {}
-			};
-			const updatedAt = /* @__PURE__ */ new Date();
-			await this.operations.update({
-				tableName: _mastra_core_storage.TABLE_THREADS,
-				keys: { id },
-				data: {
+			return await this.#fenced(fence, "updateThread", async (q) => {
+				const existing = await this.#readThread(q, id);
+				if (!existing) throw new _mastra_core_error.MastraError({
+					id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "UPDATE_THREAD", "NOT_FOUND"),
+					domain: _mastra_core_error.ErrorDomain.STORAGE,
+					category: _mastra_core_error.ErrorCategory.USER,
+					text: `Thread ${id} not found`,
+					details: { threadId: id }
+				});
+				const mergedMetadata = {
+					...existing.metadata ?? {},
+					...metadata ?? {}
+				};
+				const updatedAt = /* @__PURE__ */ new Date();
+				const statement = prepareUpdateStatement({
+					tableName: _mastra_core_storage.TABLE_THREADS,
+					keys: { id },
+					updates: {
+						title: title ?? existing.title,
+						metadata: JSON.stringify(mergedMetadata),
+						updatedAt
+					}
+				});
+				await q.execute(statement.sql, statement.args);
+				return {
+					...existing,
 					title: title ?? existing.title,
-					metadata: JSON.stringify(mergedMetadata),
+					metadata: mergedMetadata,
 					updatedAt
-				}
+				};
 			});
-			return {
-				...existing,
-				title: title ?? existing.title,
-				metadata: mergedMetadata,
-				updatedAt
-			};
 		} catch (error) {
 			if (error instanceof _mastra_core_error.MastraError) throw error;
 			throw new _mastra_core_error.MastraError({
@@ -6693,6 +6947,7 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 		const insertedIds = [];
 		try {
 			await connection.beginTransaction();
+			await this.#assertFence(connection, args.fence, "saveMessages");
 			for (const message of messages) {
 				if (!message.threadId) throw new _mastra_core_error.MastraError({
 					id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "SAVE_MESSAGES", "INVALID_INPUT"),
@@ -6786,18 +7041,29 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 				if (update.threadId && update.threadId !== current.threadId && current.threadId) affectedThreads.set(current.threadId, now);
 			}
 			if (!updates.length) return existing;
-			await this.operations.batchUpdate({
-				tableName: _mastra_core_storage.TABLE_MESSAGES,
-				items: updates
-			});
-			for (const [threadId, timestamp] of affectedThreads.entries()) await this.operations.update({
-				tableName: _mastra_core_storage.TABLE_THREADS,
-				keys: { id: threadId },
-				data: { updatedAt: timestamp }
+			await inTransaction(this.pool, async (connection) => {
+				await this.#assertFence(connection, args.fence, "updateMessages");
+				for (const { keys, data } of updates) {
+					const statement = prepareUpdateStatement({
+						tableName: _mastra_core_storage.TABLE_MESSAGES,
+						updates: data,
+						keys
+					});
+					await connection.execute(statement.sql, statement.args);
+				}
+				for (const [threadId, timestamp] of affectedThreads.entries()) {
+					const statement = prepareUpdateStatement({
+						tableName: _mastra_core_storage.TABLE_THREADS,
+						updates: { updatedAt: timestamp },
+						keys: { id: threadId }
+					});
+					await connection.execute(statement.sql, statement.args);
+				}
 			});
 			const { messages: updated } = await this.listMessagesById({ messageIds: messages.map((m) => m.id) });
 			return updated;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: "MYSQL_MEMORY_UPDATE_MESSAGES_FAILED",
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -6805,19 +7071,22 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async deleteMessages(messageIds) {
+	async deleteMessages(messageIds, options) {
 		if (!messageIds.length) return;
 		try {
-			const placeholders = messageIds.map(() => "?").join(", ");
-			const [rows] = await this.pool.execute(`SELECT DISTINCT thread_id FROM ${formatTableName(_mastra_core_storage.TABLE_MESSAGES)} WHERE id IN (${placeholders})`, messageIds);
-			const threadIds = rows.map((row) => row.thread_id).filter((threadId) => Boolean(threadId));
-			await this.pool.execute(`DELETE FROM ${formatTableName(_mastra_core_storage.TABLE_MESSAGES)} WHERE id IN (${placeholders})`, messageIds);
-			if (threadIds.length) {
-				const threadPlaceholders = threadIds.map(() => "?").join(", ");
-				const timestamp = transformToSqlValue(/* @__PURE__ */ new Date());
-				await this.pool.execute(`UPDATE ${formatTableName(_mastra_core_storage.TABLE_THREADS)} SET ${quoteIdentifier("updatedAt", "column name")} = ? WHERE id IN (${threadPlaceholders})`, [timestamp, ...threadIds]);
-			}
+			await this.#fenced(options?.fence, "deleteMessages", async (q) => {
+				const placeholders = messageIds.map(() => "?").join(", ");
+				const [rows] = await q.execute(`SELECT DISTINCT thread_id FROM ${formatTableName(_mastra_core_storage.TABLE_MESSAGES)} WHERE id IN (${placeholders})`, messageIds);
+				const threadIds = rows.map((row) => row.thread_id).filter((threadId) => Boolean(threadId));
+				await q.execute(`DELETE FROM ${formatTableName(_mastra_core_storage.TABLE_MESSAGES)} WHERE id IN (${placeholders})`, messageIds);
+				if (threadIds.length) {
+					const threadPlaceholders = threadIds.map(() => "?").join(", ");
+					const timestamp = transformToSqlValue(/* @__PURE__ */ new Date());
+					await q.execute(`UPDATE ${formatTableName(_mastra_core_storage.TABLE_THREADS)} SET ${quoteIdentifier("updatedAt", "column name")} = ? WHERE id IN (${threadPlaceholders})`, [timestamp, ...threadIds]);
+				}
+			});
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: "MYSQL_MEMORY_DELETE_MESSAGES_FAILED",
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -7216,19 +7485,23 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
+	async #insertResource(q, resource) {
+		const metadataValue = resource.metadata === void 0 || resource.metadata === null ? null : JSON.stringify(resource.metadata);
+		const statement = prepareStatement({
+			tableName: _mastra_core_storage.TABLE_RESOURCES,
+			record: {
+				id: resource.id,
+				workingMemory: resource.workingMemory ?? null,
+				metadata: metadataValue,
+				createdAt: resource.createdAt ?? /* @__PURE__ */ new Date(),
+				updatedAt: resource.updatedAt ?? /* @__PURE__ */ new Date()
+			}
+		});
+		await q.execute(statement.sql, statement.args);
+	}
 	async saveResource({ resource }) {
 		try {
-			const metadataValue = resource.metadata === void 0 || resource.metadata === null ? null : JSON.stringify(resource.metadata);
-			await this.operations.insert({
-				tableName: _mastra_core_storage.TABLE_RESOURCES,
-				record: {
-					id: resource.id,
-					workingMemory: resource.workingMemory ?? null,
-					metadata: metadataValue,
-					createdAt: resource.createdAt ?? /* @__PURE__ */ new Date(),
-					updatedAt: resource.updatedAt ?? /* @__PURE__ */ new Date()
-				}
-			});
+			await this.#insertResource(this.pool, resource);
 			return resource;
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
@@ -7239,7 +7512,7 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async updateResource({ resourceId, workingMemory, metadata }) {
+	async updateResource({ resourceId, workingMemory, metadata, fence }) {
 		try {
 			const existing = await this.getResourceById({ resourceId });
 			if (!existing) {
@@ -7250,22 +7523,24 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 					createdAt: /* @__PURE__ */ new Date(),
 					updatedAt: /* @__PURE__ */ new Date()
 				};
-				return await this.saveResource({ resource: newResource });
+				await this.#fenced(fence, "updateResource", (q) => this.#insertResource(q, newResource));
+				return newResource;
 			}
 			const mergedMetadata = metadata !== void 0 ? {
 				...existing.metadata ?? {},
 				...metadata ?? {}
 			} : existing.metadata;
 			const metadataValue = metadata !== void 0 ? metadata === null ? null : JSON.stringify(mergedMetadata ?? {}) : void 0;
-			await this.operations.update({
+			const statement = prepareUpdateStatement({
 				tableName: _mastra_core_storage.TABLE_RESOURCES,
 				keys: { id: resourceId },
-				data: {
+				updates: {
 					...workingMemory !== void 0 ? { workingMemory } : {},
 					...metadataValue !== void 0 ? { metadata: metadataValue } : {},
 					updatedAt: /* @__PURE__ */ new Date()
 				}
 			});
+			await this.#fenced(fence, "updateResource", (q) => q.execute(statement.sql, statement.args));
 			const updated = await this.getResourceById({ resourceId });
 			if (!updated) throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "UPDATE_RESOURCE", "NOT_FOUND_AFTER_UPDATE"),
@@ -7288,7 +7563,7 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 	async getObservationalMemory(threadId, resourceId) {
 		try {
 			const lookupKey = this.getOMKey(threadId, resourceId);
-			const [rows] = await this.pool.execute(`SELECT * FROM ${OM_TABLE_QUOTED} WHERE ${omCol("lookupKey")} = ? ORDER BY ${omCol("generationCount")} DESC LIMIT 1`, [lookupKey]);
+			const [rows] = await this.pool.execute(`SELECT * FROM ${OM_TABLE_QUOTED} WHERE ${omCol("lookupKey")} = ? ORDER BY ${OM_HEAD_ORDER} LIMIT 1`, [lookupKey]);
 			if (!rows || rows.length === 0) return null;
 			return this.parseOMRow(rows[0]);
 		} catch (error) {
@@ -7350,32 +7625,11 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 	}
 	async initializeObservationalMemory(input) {
 		try {
+			const lookupKey = this.getOMKey(input.threadId, input.resourceId);
 			const id = globalThis.crypto.randomUUID();
 			const now = /* @__PURE__ */ new Date();
-			const lookupKey = this.getOMKey(input.threadId, input.resourceId);
-			const record = {
-				id,
-				scope: input.scope,
-				threadId: input.threadId,
-				resourceId: input.resourceId,
-				createdAt: now,
-				updatedAt: now,
-				lastObservedAt: void 0,
-				originType: "initial",
-				generationCount: 0,
-				activeObservations: "",
-				totalTokensObserved: 0,
-				observationTokenCount: 0,
-				pendingMessageTokens: 0,
-				isReflecting: false,
-				isObserving: false,
-				isBufferingObservation: false,
-				isBufferingReflection: false,
-				lastBufferedAtTokens: 0,
-				lastBufferedAtTime: null,
-				config: input.config,
-				observedTimezone: input.observedTimezone
-			};
+			const existing = await this.getObservationalMemory(input.threadId, input.resourceId);
+			if (existing) return existing;
 			const nowSql = transformToSqlValue(now);
 			const cols = [
 				"id",
@@ -7401,36 +7655,53 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 				"lastBufferedAtTime",
 				"observedTimezone",
 				"createdAt",
-				"updatedAt"
+				"updatedAt",
+				"supersededBy"
 			].map(omCol).join(", ");
-			const placeholders = Array.from({ length: 24 }, () => "?").join(", ");
-			await this.pool.execute(`INSERT INTO ${OM_TABLE_QUOTED} (${cols}) VALUES (${placeholders})`, [
-				id,
-				lookupKey,
-				input.scope,
-				input.resourceId,
-				input.threadId || null,
-				"",
-				null,
-				"initial",
-				JSON.stringify(input.config),
-				0,
-				null,
-				null,
-				0,
-				0,
-				0,
-				false,
-				false,
-				false,
-				false,
-				0,
-				null,
-				input.observedTimezone || null,
-				nowSql,
-				nowSql
-			]);
-			return record;
+			const placeholders = Array.from({ length: 25 }, () => "?").join(", ");
+			const lockName = `mastra_om_init:${(0, crypto$1.createHash)("sha256").update(lookupKey).digest("hex").slice(0, 40)}`;
+			const connection = await this.pool.getConnection();
+			try {
+				const [lockRows] = await connection.query("SELECT GET_LOCK(?, ?) AS acquired", [lockName, OM_INIT_LOCK_TIMEOUT_SECONDS]);
+				if (Number(lockRows[0]?.acquired) !== 1) throw new Error(`Timed out waiting for the observational memory initialization lock for ${lookupKey}`);
+				try {
+					const [liveRows] = await connection.query(`SELECT 1 FROM ${OM_TABLE_QUOTED} WHERE ${omCol("lookupKey")} = ? AND ${omCol("supersededBy")} IS NULL LIMIT 1`, [lookupKey]);
+					if (liveRows.length === 0) await connection.execute(`INSERT INTO ${OM_TABLE_QUOTED} (${cols}) VALUES (${placeholders})`, [
+						id,
+						lookupKey,
+						input.scope,
+						input.resourceId,
+						input.threadId || null,
+						"",
+						null,
+						"initial",
+						JSON.stringify(input.config),
+						0,
+						null,
+						null,
+						0,
+						0,
+						0,
+						false,
+						false,
+						false,
+						false,
+						0,
+						null,
+						input.observedTimezone || null,
+						nowSql,
+						nowSql,
+						null
+					]);
+				} finally {
+					await connection.query("SELECT RELEASE_LOCK(?)", [lockName]);
+				}
+			} finally {
+				connection.release();
+			}
+			const head = await this.getObservationalMemory(input.threadId, input.resourceId);
+			if (!head) throwOMNotFound(id, "INITIALIZE_OBSERVATIONAL_MEMORY");
+			return head;
 		} catch (error) {
 			rethrowOrWrapOM(error, "", "INITIALIZE_OBSERVATIONAL_MEMORY", {
 				threadId: input.threadId,
@@ -7439,119 +7710,153 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 		}
 	}
 	async updateActiveObservations(input) {
+		assertActiveObservationsApplied(await this.commitActiveObservations(input), input.id);
+	}
+	async commitActiveObservations(input) {
 		try {
-			const now = /* @__PURE__ */ new Date();
 			const observedMessageIdsJson = input.observedMessageIds ? JSON.stringify(input.observedMessageIds) : null;
-			const [result] = await this.pool.execute(`UPDATE ${OM_TABLE_QUOTED} SET
-          ${omCol("activeObservations")} = ?,
-          ${omCol("lastObservedAt")} = ?,
-          ${omCol("pendingMessageTokens")} = 0,
-          ${omCol("observationTokenCount")} = ?,
-          ${omCol("totalTokensObserved")} = ${omCol("totalTokensObserved")} + ?,
-          ${omCol("observedMessageIds")} = ?,
-          ${omCol("updatedAt")} = ?
-        WHERE ${omCol("id")} = ?`, [
-				input.observations,
-				transformToSqlValue(input.lastObservedAt),
-				input.tokenCount,
-				input.tokenCount,
-				observedMessageIdsJson,
-				transformToSqlValue(now),
-				input.id
-			]);
-			if (result.affectedRows === 0) throwOMNotFound(input.id, "UPDATE_ACTIVE_OBSERVATIONS");
+			return await this.withOMTransaction(async (connection) => {
+				const row = await this.lockOMRow(connection, input.id);
+				if (!row) throwOMNotFound(input.id, "UPDATE_ACTIVE_OBSERVATIONS");
+				if (row.supersededBy) return {
+					applied: false,
+					reason: "retired"
+				};
+				if (input.expectedActiveObservations !== void 0 && input.expectedActiveObservations !== (row.activeObservations || "")) return {
+					applied: false,
+					reason: "conflict"
+				};
+				const lastObservedAt = maxObservationCursor(parseDateTime(row.lastObservedAt), input.lastObservedAt);
+				await connection.execute(`UPDATE ${OM_TABLE_QUOTED} SET
+            ${omCol("activeObservations")} = ?,
+            ${omCol("lastObservedAt")} = ?,
+            ${omCol("pendingMessageTokens")} = 0,
+            ${omCol("observationTokenCount")} = ?,
+            ${omCol("totalTokensObserved")} = ${omCol("totalTokensObserved")} + ?,
+            ${omCol("observedMessageIds")} = ?,
+            ${omCol("updatedAt")} = ?
+          WHERE ${omCol("id")} = ?`, [
+					input.observations,
+					transformToSqlValue(lastObservedAt),
+					input.tokenCount,
+					input.tokenCount,
+					observedMessageIdsJson,
+					transformToSqlValue(/* @__PURE__ */ new Date()),
+					input.id
+				]);
+				return { applied: true };
+			}, "commitActiveObservations");
 		} catch (error) {
 			rethrowOrWrapOM(error, input.id, "UPDATE_ACTIVE_OBSERVATIONS");
 		}
 	}
 	async createReflectionGeneration(input) {
 		try {
-			const id = globalThis.crypto.randomUUID();
-			const now = /* @__PURE__ */ new Date();
-			const lookupKey = this.getOMKey(input.currentRecord.threadId, input.currentRecord.resourceId);
-			const record = {
-				id,
-				scope: input.currentRecord.scope,
-				threadId: input.currentRecord.threadId,
-				resourceId: input.currentRecord.resourceId,
-				createdAt: now,
-				updatedAt: now,
-				lastObservedAt: input.currentRecord.lastObservedAt,
-				originType: "reflection",
-				generationCount: input.currentRecord.generationCount + 1,
-				activeObservations: input.reflection,
-				totalTokensObserved: input.currentRecord.totalTokensObserved,
-				observationTokenCount: input.tokenCount,
-				pendingMessageTokens: 0,
-				isReflecting: false,
-				isObserving: false,
-				isBufferingObservation: false,
-				isBufferingReflection: false,
-				lastBufferedAtTokens: 0,
-				lastBufferedAtTime: null,
-				config: input.currentRecord.config,
-				metadata: input.currentRecord.metadata,
-				observedTimezone: input.currentRecord.observedTimezone
-			};
-			const nowSql = transformToSqlValue(now);
-			const cols = [
-				"id",
-				"lookupKey",
-				"scope",
-				"resourceId",
-				"threadId",
-				"activeObservations",
-				"activeObservationsPendingUpdate",
-				"originType",
-				"config",
-				"generationCount",
-				"lastObservedAt",
-				"lastReflectionAt",
-				"pendingMessageTokens",
-				"totalTokensObserved",
-				"observationTokenCount",
-				"isObserving",
-				"isReflecting",
-				"isBufferingObservation",
-				"isBufferingReflection",
-				"lastBufferedAtTokens",
-				"lastBufferedAtTime",
-				"observedTimezone",
-				"createdAt",
-				"updatedAt"
-			].map(omCol).join(", ");
-			const placeholders = Array.from({ length: 24 }, () => "?").join(", ");
-			await this.pool.execute(`INSERT INTO ${OM_TABLE_QUOTED} (${cols}) VALUES (${placeholders})`, [
-				id,
-				lookupKey,
-				record.scope,
-				record.resourceId,
-				record.threadId || null,
-				input.reflection,
-				null,
-				"reflection",
-				JSON.stringify(record.config),
-				input.currentRecord.generationCount + 1,
-				record.lastObservedAt ? transformToSqlValue(record.lastObservedAt) : null,
-				nowSql,
-				record.pendingMessageTokens,
-				record.totalTokensObserved,
-				record.observationTokenCount,
-				false,
-				false,
-				false,
-				false,
-				0,
-				null,
-				record.observedTimezone || null,
-				nowSql,
-				nowSql
-			]);
-			return record;
+			const { currentRecord } = input;
+			return await this.withOMTransaction(async (connection) => {
+				const row = await this.lockOMRow(connection, currentRecord.id);
+				if (!row) return currentRecord;
+				if (row.supersededBy) return this.parseOMRow(await this.resolveLiveOMRow(connection, row));
+				const stored = this.parseOMRow(row);
+				const plan = planReflectionGenerationText({
+					storedObservations: stored.activeObservations,
+					storedObservationTokenCount: stored.observationTokenCount,
+					snapshotObservations: currentRecord.activeObservations,
+					snapshotObservationTokenCount: currentRecord.observationTokenCount,
+					reflection: input.reflection,
+					tokenCount: input.tokenCount
+				});
+				if (!plan) return stored;
+				return this.rollOverOMRow(connection, stored.id, plan.observations, plan.tokenCount, input.newRecordId, false);
+			}, "createReflectionGeneration");
 		} catch (error) {
 			rethrowOrWrapOM(error, input.currentRecord.id, "CREATE_REFLECTION_GENERATION", { currentRecordId: input.currentRecord.id });
 		}
 	}
+	async #insertReflectionGeneration(q, input) {
+		const id = globalThis.crypto.randomUUID();
+		const now = /* @__PURE__ */ new Date();
+		const lookupKey = this.getOMKey(input.currentRecord.threadId, input.currentRecord.resourceId);
+		const record = {
+			id,
+			scope: input.currentRecord.scope,
+			threadId: input.currentRecord.threadId,
+			resourceId: input.currentRecord.resourceId,
+			createdAt: now,
+			updatedAt: now,
+			lastObservedAt: input.currentRecord.lastObservedAt,
+			originType: "reflection",
+			generationCount: input.currentRecord.generationCount + 1,
+			activeObservations: input.reflection,
+			totalTokensObserved: input.currentRecord.totalTokensObserved,
+			observationTokenCount: input.tokenCount,
+			pendingMessageTokens: 0,
+			isReflecting: false,
+			isObserving: false,
+			isBufferingObservation: false,
+			isBufferingReflection: false,
+			lastBufferedAtTokens: 0,
+			lastBufferedAtTime: null,
+			config: input.currentRecord.config,
+			metadata: input.currentRecord.metadata,
+			observedTimezone: input.currentRecord.observedTimezone
+		};
+		const nowSql = transformToSqlValue(now);
+		const cols = [
+			"id",
+			"lookupKey",
+			"scope",
+			"resourceId",
+			"threadId",
+			"activeObservations",
+			"activeObservationsPendingUpdate",
+			"originType",
+			"config",
+			"generationCount",
+			"lastObservedAt",
+			"lastReflectionAt",
+			"pendingMessageTokens",
+			"totalTokensObserved",
+			"observationTokenCount",
+			"isObserving",
+			"isReflecting",
+			"isBufferingObservation",
+			"isBufferingReflection",
+			"lastBufferedAtTokens",
+			"lastBufferedAtTime",
+			"observedTimezone",
+			"createdAt",
+			"updatedAt"
+		].map(omCol).join(", ");
+		const placeholders = Array.from({ length: 24 }, () => "?").join(", ");
+		await q.execute(`INSERT INTO ${OM_TABLE_QUOTED} (${cols}) VALUES (${placeholders})`, [
+			id,
+			lookupKey,
+			record.scope,
+			record.resourceId,
+			record.threadId || null,
+			input.reflection,
+			null,
+			"reflection",
+			JSON.stringify(record.config),
+			input.currentRecord.generationCount + 1,
+			record.lastObservedAt ? transformToSqlValue(record.lastObservedAt) : null,
+			nowSql,
+			record.pendingMessageTokens,
+			record.totalTokensObserved,
+			record.observationTokenCount,
+			false,
+			false,
+			false,
+			false,
+			0,
+			null,
+			record.observedTimezone || null,
+			nowSql,
+			nowSql
+		]);
+		return record;
+	}
 	async setReflectingFlag(id, isReflecting) {
 		await this.updateOMFlag(id, "isReflecting", isReflecting, "SET_REFLECTING_FLAG");
 	}
@@ -7560,20 +7865,22 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 	}
 	async setBufferingObservationFlag(id, isBuffering, lastBufferedAtTokens) {
 		try {
-			const nowSql = transformToSqlValue(/* @__PURE__ */ new Date());
-			const sets = [
-				`${omCol("isBufferingObservation")} = ?`,
-				...lastBufferedAtTokens !== void 0 ? [`${omCol("lastBufferedAtTokens")} = ?`] : [],
-				`${omCol("updatedAt")} = ?`
-			].join(", ");
-			const params = [
-				isBuffering,
-				...lastBufferedAtTokens !== void 0 ? [lastBufferedAtTokens] : [],
-				nowSql,
-				id
-			];
-			const [result] = await this.pool.execute(`UPDATE ${OM_TABLE_QUOTED} SET ${sets} WHERE ${omCol("id")} = ?`, params);
-			if (result.affectedRows === 0) throwOMNotFound(id, "SET_BUFFERING_OBSERVATION_FLAG");
+			await this.withOMTransaction(async (connection) => {
+				const row = await this.lockOMRow(connection, id);
+				if (!row) throwOMNotFound(id, "SET_BUFFERING_OBSERVATION_FLAG");
+				const target = await this.resolveLiveOMRow(connection, row);
+				const sets = [
+					`${omCol("isBufferingObservation")} = ?`,
+					...lastBufferedAtTokens !== void 0 ? [`${omCol("lastBufferedAtTokens")} = ?`] : [],
+					`${omCol("updatedAt")} = ?`
+				].join(", ");
+				await connection.execute(`UPDATE ${OM_TABLE_QUOTED} SET ${sets} WHERE ${omCol("id")} = ?`, [
+					isBuffering,
+					...lastBufferedAtTokens !== void 0 ? [lastBufferedAtTokens] : [],
+					transformToSqlValue(/* @__PURE__ */ new Date()),
+					target.id
+				]);
+			});
 		} catch (error) {
 			rethrowOrWrapOM(error, id, "SET_BUFFERING_OBSERVATION_FLAG");
 		}
@@ -7594,83 +7901,78 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 	}
 	async setPendingMessageTokens(id, tokenCount) {
 		try {
-			const [result] = await this.pool.execute(`UPDATE ${OM_TABLE_QUOTED} SET
-          ${omCol("pendingMessageTokens")} = ?,
-          ${omCol("updatedAt")} = ?
-        WHERE ${omCol("id")} = ?`, [
-				tokenCount,
-				transformToSqlValue(/* @__PURE__ */ new Date()),
-				id
-			]);
-			if (result.affectedRows === 0) throwOMNotFound(id, "SET_PENDING_MESSAGE_TOKENS");
+			await this.withOMTransaction(async (connection) => {
+				const row = await this.lockOMRow(connection, id);
+				if (!row) throwOMNotFound(id, "SET_PENDING_MESSAGE_TOKENS");
+				const target = await this.resolveLiveOMRow(connection, row);
+				await connection.execute(`UPDATE ${OM_TABLE_QUOTED} SET
+            ${omCol("pendingMessageTokens")} = ?,
+            ${omCol("updatedAt")} = ?
+          WHERE ${omCol("id")} = ?`, [
+					tokenCount,
+					transformToSqlValue(/* @__PURE__ */ new Date()),
+					target.id
+				]);
+			});
 		} catch (error) {
 			rethrowOrWrapOM(error, id, "SET_PENDING_MESSAGE_TOKENS");
 		}
 	}
 	async updateBufferedObservations(input) {
-		try {
-			const connection = await this.pool.getConnection();
-			try {
-				await connection.beginTransaction();
-				const nowSql = transformToSqlValue(/* @__PURE__ */ new Date());
-				const [currentRows] = await connection.execute(`SELECT ${omCol("bufferedObservationChunks")} FROM ${OM_TABLE_QUOTED} WHERE ${omCol("id")} = ? FOR UPDATE`, [input.id]);
-				if (!currentRows || currentRows.length === 0) throwOMNotFound(input.id, "UPDATE_BUFFERED_OBSERVATIONS");
-				const existingChunks = parseBufferedChunks(currentRows[0].bufferedObservationChunks);
-				if (existingChunks.some((existing) => existing.cycleId === input.chunk.cycleId)) {
-					await connection.commit();
-					return;
-				}
-				const newChunk = {
-					id: `ombuf-${globalThis.crypto.randomUUID()}`,
-					cycleId: input.chunk.cycleId,
-					observations: input.chunk.observations,
-					tokenCount: input.chunk.tokenCount,
-					messageIds: input.chunk.messageIds,
-					messageTokens: input.chunk.messageTokens,
-					lastObservedAt: input.chunk.lastObservedAt,
-					createdAt: /* @__PURE__ */ new Date(),
-					suggestedContinuation: input.chunk.suggestedContinuation,
-					currentTask: input.chunk.currentTask,
-					threadTitle: input.chunk.threadTitle,
-					extractedValues: input.chunk.extractedValues,
-					extractionFailures: input.chunk.extractionFailures
+		await this.appendBufferedObservations(input);
+	}
+	async appendBufferedObservations(input) {
+		try {
+			const newChunk = {
+				id: `ombuf-${globalThis.crypto.randomUUID()}`,
+				cycleId: input.chunk.cycleId,
+				observations: input.chunk.observations,
+				tokenCount: input.chunk.tokenCount,
+				messageIds: input.chunk.messageIds,
+				messageTokens: input.chunk.messageTokens,
+				lastObservedAt: input.chunk.lastObservedAt,
+				createdAt: /* @__PURE__ */ new Date(),
+				suggestedContinuation: input.chunk.suggestedContinuation,
+				currentTask: input.chunk.currentTask,
+				threadTitle: input.chunk.threadTitle,
+				extractedValues: input.chunk.extractedValues,
+				extractionFailures: input.chunk.extractionFailures
+			};
+			return await this.withOMTransaction(async (connection) => {
+				const row = await this.lockOMRow(connection, input.id);
+				if (!row) throwOMNotFound(input.id, "UPDATE_BUFFERED_OBSERVATIONS");
+				const target = await this.resolveLiveOMRow(connection, row);
+				const existingChunks = parseBufferedChunks(target.bufferedObservationChunks);
+				if (existingChunks.some((existing) => existing.cycleId === input.chunk.cycleId) || isBufferedChunkCoveredByCursor(input.chunk.lastObservedAt, parseDateTime(target.lastObservedAt))) return {
+					persisted: false,
+					recordId: target.id
 				};
-				const newChunks = [...existingChunks, newChunk];
-				const lastBufferedAtTime = input.lastBufferedAtTime ? transformToSqlValue(input.lastBufferedAtTime) : null;
-				const [result] = await connection.execute(`UPDATE ${OM_TABLE_QUOTED} SET
+				const lastBufferedAtTime = maxObservationCursor(parseDateTime(target.lastBufferedAtTime), input.lastBufferedAtTime ?? void 0);
+				await connection.execute(`UPDATE ${OM_TABLE_QUOTED} SET
             ${omCol("bufferedObservationChunks")} = ?,
-            ${omCol("lastBufferedAtTime")} = COALESCE(?, ${omCol("lastBufferedAtTime")}),
+            ${omCol("lastBufferedAtTime")} = ?,
             ${omCol("updatedAt")} = ?
           WHERE ${omCol("id")} = ?`, [
-					JSON.stringify(newChunks),
-					lastBufferedAtTime,
-					nowSql,
-					input.id
+					JSON.stringify([...existingChunks, newChunk]),
+					transformToSqlValue(lastBufferedAtTime),
+					transformToSqlValue(/* @__PURE__ */ new Date()),
+					target.id
 				]);
-				if (result.affectedRows === 0) throwOMNotFound(input.id, "UPDATE_BUFFERED_OBSERVATIONS");
-				await connection.commit();
-			} catch (error) {
-				await connection.rollback();
-				throw error;
-			} finally {
-				connection.release();
-			}
+				return {
+					persisted: true,
+					recordId: target.id
+				};
+			}, "appendBufferedObservations");
 		} catch (error) {
 			rethrowOrWrapOM(error, input.id, "UPDATE_BUFFERED_OBSERVATIONS");
 		}
 	}
 	async swapBufferedToActive(input) {
-		const connection = await this.pool.getConnection();
 		try {
-			await connection.beginTransaction();
-			const nowSql = transformToSqlValue(/* @__PURE__ */ new Date());
-			const [currentRows] = await connection.execute(`SELECT * FROM ${OM_TABLE_QUOTED} WHERE ${omCol("id")} = ? FOR UPDATE`, [input.id]);
-			if (!currentRows || currentRows.length === 0) throwOMNotFound(input.id, "SWAP_BUFFERED_TO_ACTIVE");
-			const row = currentRows[0];
-			const chunks = parseBufferedChunks(row.bufferedObservationChunks);
-			if (chunks.length === 0) {
-				await connection.commit();
-				return {
+			return await this.withOMTransaction(async (connection) => {
+				const row = await this.lockOMRow(connection, input.id);
+				if (!row) throwOMNotFound(input.id, "SWAP_BUFFERED_TO_ACTIVE");
+				const emptyResult = {
 					chunksActivated: 0,
 					messageTokensActivated: 0,
 					observationTokensActivated: 0,
@@ -7678,102 +7980,110 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 					activatedCycleIds: [],
 					activatedMessageIds: []
 				};
-			}
-			const retentionFloor = input.messageTokensThreshold * (1 - input.activationRatio);
-			const targetMessageTokens = Math.max(0, input.currentPendingTokens - retentionFloor);
-			let cumulativeMessageTokens = 0;
-			let bestOverBoundary = 0;
-			let bestOverTokens = 0;
-			let bestUnderBoundary = 0;
-			let bestUnderTokens = 0;
-			for (let i = 0; i < chunks.length; i++) {
-				cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
-				const boundary = i + 1;
-				if (cumulativeMessageTokens >= targetMessageTokens) {
-					if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
-						bestOverBoundary = boundary;
-						bestOverTokens = cumulativeMessageTokens;
+				if (row.supersededBy) return {
+					...emptyResult,
+					retired: true
+				};
+				const persistedChunks = parseBufferedChunks(row.bufferedObservationChunks);
+				const refreshedWeights = new Map((Array.isArray(input.bufferedChunks) ? input.bufferedChunks : []).map((c) => [c.id, c.messageTokens]));
+				const chunks = persistedChunks.map((c) => refreshedWeights.has(c.id) ? {
+					...c,
+					messageTokens: refreshedWeights.get(c.id)
+				} : c);
+				if (chunks.length === 0) return emptyResult;
+				const retentionFloor = input.messageTokensThreshold * (1 - input.activationRatio);
+				const targetMessageTokens = Math.max(0, input.currentPendingTokens - retentionFloor);
+				let cumulativeMessageTokens = 0;
+				let bestOverBoundary = 0;
+				let bestOverTokens = 0;
+				let bestUnderBoundary = 0;
+				let bestUnderTokens = 0;
+				for (let i = 0; i < chunks.length; i++) {
+					cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
+					const boundary = i + 1;
+					if (cumulativeMessageTokens >= targetMessageTokens) {
+						if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
+							bestOverBoundary = boundary;
+							bestOverTokens = cumulativeMessageTokens;
+						}
+					} else if (cumulativeMessageTokens > bestUnderTokens) {
+						bestUnderBoundary = boundary;
+						bestUnderTokens = cumulativeMessageTokens;
 					}
-				} else if (cumulativeMessageTokens > bestUnderTokens) {
-					bestUnderBoundary = boundary;
-					bestUnderTokens = cumulativeMessageTokens;
-				}
-			}
-			const maxOvershoot = retentionFloor * .95;
-			const overshoot = bestOverTokens - targetMessageTokens;
-			const remainingAfterOver = input.currentPendingTokens - bestOverTokens;
-			const remainingAfterUnder = input.currentPendingTokens - bestUnderTokens;
-			const minRemaining = Math.min(1e3, retentionFloor);
-			let chunksToActivate;
-			if (input.forceMaxActivation && bestOverBoundary > 0 && remainingAfterOver >= minRemaining) chunksToActivate = bestOverBoundary;
-			else if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) chunksToActivate = bestOverBoundary;
-			else if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) chunksToActivate = bestUnderBoundary;
-			else if (bestOverBoundary > 0) chunksToActivate = bestOverBoundary;
-			else chunksToActivate = 1;
-			const activatedChunks = chunks.slice(0, chunksToActivate);
-			const remainingChunks = chunks.slice(chunksToActivate);
-			const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
-			const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
-			const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
-			const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + c.messageIds.length, 0);
-			const activatedCycleIds = activatedChunks.map((c) => c.cycleId).filter((cid) => !!cid);
-			const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
-			const latestChunk = activatedChunks[activatedChunks.length - 1];
-			const lastObservedAtSql = transformToSqlValue(input.lastObservedAt ?? (latestChunk?.lastObservedAt ? new Date(latestChunk.lastObservedAt) : /* @__PURE__ */ new Date()));
-			const existingActive = row.activeObservations || "";
-			const existingTokenCount = Number(row.observationTokenCount || 0);
-			const newActive = existingActive ? `${existingActive}\n\n${activatedContent}` : activatedContent;
-			const newTokenCount = existingTokenCount + activatedTokens;
-			const existingPending = Number(row.pendingMessageTokens || 0);
-			const newPending = Math.max(0, existingPending - activatedMessageTokens);
-			await connection.execute(`UPDATE ${OM_TABLE_QUOTED} SET
-          ${omCol("activeObservations")} = ?,
-          ${omCol("observationTokenCount")} = ?,
-          ${omCol("pendingMessageTokens")} = ?,
-          ${omCol("bufferedObservationChunks")} = ?,
-          ${omCol("lastObservedAt")} = ?,
-          ${omCol("updatedAt")} = ?
-        WHERE ${omCol("id")} = ?`, [
-				newActive,
-				newTokenCount,
-				newPending,
-				remainingChunks.length > 0 ? JSON.stringify(remainingChunks) : null,
-				lastObservedAtSql,
-				nowSql,
-				input.id
-			]);
-			await connection.commit();
-			const latestChunkHints = activatedChunks[activatedChunks.length - 1];
-			return {
-				chunksActivated: activatedChunks.length,
-				messageTokensActivated: activatedMessageTokens,
-				observationTokensActivated: activatedTokens,
-				messagesActivated: activatedMessageCount,
-				activatedCycleIds,
-				activatedMessageIds,
-				observations: activatedContent,
-				perChunk: activatedChunks.map((c) => ({
-					cycleId: c.cycleId ?? "",
-					messageTokens: c.messageTokens ?? 0,
-					observationTokens: c.tokenCount,
-					messageCount: c.messageIds.length,
-					observations: c.observations
-				})),
-				suggestedContinuation: latestChunkHints?.suggestedContinuation ?? void 0,
-				currentTask: latestChunkHints?.currentTask ?? void 0
-			};
+				}
+				const maxOvershoot = retentionFloor * .95;
+				const overshoot = bestOverTokens - targetMessageTokens;
+				const remainingAfterOver = input.currentPendingTokens - bestOverTokens;
+				const remainingAfterUnder = input.currentPendingTokens - bestUnderTokens;
+				const minRemaining = Math.min(1e3, retentionFloor);
+				let chunksToActivate;
+				if (input.forceMaxActivation && bestOverBoundary > 0 && remainingAfterOver >= minRemaining) chunksToActivate = bestOverBoundary;
+				else if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) chunksToActivate = bestOverBoundary;
+				else if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) chunksToActivate = bestUnderBoundary;
+				else if (bestOverBoundary > 0) chunksToActivate = bestOverBoundary;
+				else chunksToActivate = 1;
+				const activatedChunks = chunks.slice(0, chunksToActivate);
+				const remainingChunks = persistedChunks.slice(chunksToActivate);
+				const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
+				const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
+				const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
+				const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + c.messageIds.length, 0);
+				const activatedCycleIds = activatedChunks.map((c) => c.cycleId).filter((cid) => !!cid);
+				const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
+				const latestChunk = activatedChunks[activatedChunks.length - 1];
+				const derivedLastObservedAt = input.lastObservedAt ?? (latestChunk?.lastObservedAt ? new Date(latestChunk.lastObservedAt) : /* @__PURE__ */ new Date());
+				const lastObservedAt = maxObservationCursor(parseDateTime(row.lastObservedAt), derivedLastObservedAt);
+				const existingActive = row.activeObservations || "";
+				const existingTokenCount = Number(row.observationTokenCount || 0);
+				const newActive = existingActive ? `${existingActive}\n\n${activatedContent}` : activatedContent;
+				const newTokenCount = existingTokenCount + activatedTokens;
+				const existingPending = Number(row.pendingMessageTokens || 0);
+				const newPending = Math.max(0, existingPending - activatedMessageTokens);
+				await connection.execute(`UPDATE ${OM_TABLE_QUOTED} SET
+            ${omCol("activeObservations")} = ?,
+            ${omCol("observationTokenCount")} = ?,
+            ${omCol("pendingMessageTokens")} = ?,
+            ${omCol("bufferedObservationChunks")} = ?,
+            ${omCol("lastObservedAt")} = ?,
+            ${omCol("updatedAt")} = ?
+          WHERE ${omCol("id")} = ?`, [
+					newActive,
+					newTokenCount,
+					newPending,
+					remainingChunks.length > 0 ? JSON.stringify(remainingChunks) : null,
+					transformToSqlValue(lastObservedAt),
+					transformToSqlValue(/* @__PURE__ */ new Date()),
+					input.id
+				]);
+				const latestChunkHints = activatedChunks[activatedChunks.length - 1];
+				return {
+					chunksActivated: activatedChunks.length,
+					messageTokensActivated: activatedMessageTokens,
+					observationTokensActivated: activatedTokens,
+					messagesActivated: activatedMessageCount,
+					activatedCycleIds,
+					activatedMessageIds,
+					observations: activatedContent,
+					perChunk: activatedChunks.map((c) => ({
+						cycleId: c.cycleId ?? "",
+						messageTokens: c.messageTokens ?? 0,
+						observationTokens: c.tokenCount,
+						messageCount: c.messageIds.length,
+						observations: c.observations
+					})),
+					suggestedContinuation: latestChunkHints?.suggestedContinuation ?? void 0,
+					currentTask: latestChunkHints?.currentTask ?? void 0
+				};
+			}, "swapBufferedToActive");
 		} catch (error) {
-			await connection.rollback();
 			rethrowOrWrapOM(error, input.id, "SWAP_BUFFERED_TO_ACTIVE");
-		} finally {
-			connection.release();
 		}
 	}
 	async updateBufferedReflection(input) {
 		try {
 			const nowSql = transformToSqlValue(/* @__PURE__ */ new Date());
 			const br = omCol("bufferedReflection");
-			const [result] = await this.pool.execute(`UPDATE ${OM_TABLE_QUOTED} SET
+			const [result] = await this.#fenced(void 0, "updateBufferedReflection", (q) => q.execute(`UPDATE ${OM_TABLE_QUOTED} SET
           ${br} = CASE
             WHEN ${br} IS NOT NULL AND ${br} != ''
             THEN CONCAT(${br}, CHAR(10), CHAR(10), ?)
@@ -7791,7 +8101,7 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 				input.reflectedObservationLineCount,
 				nowSql,
 				input.id
-			]);
+			]));
 			if (result.affectedRows === 0) throwOMNotFound(input.id, "UPDATE_BUFFERED_REFLECTION");
 		} catch (error) {
 			rethrowOrWrapOM(error, input.id, "UPDATE_BUFFERED_REFLECTION");
@@ -7799,38 +8109,183 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 	}
 	async swapBufferedReflectionToActive(input) {
 		try {
-			const [currentRows] = await this.pool.execute(`SELECT * FROM ${OM_TABLE_QUOTED} WHERE ${omCol("id")} = ?`, [input.currentRecord.id]);
-			if (!currentRows || currentRows.length === 0) throwOMNotFound(input.currentRecord.id, "SWAP_BUFFERED_REFLECTION_TO_ACTIVE");
-			const row = currentRows[0];
-			const bufferedReflection = row.bufferedReflection || "";
-			const reflectedLineCount = Number(row.reflectedObservationLineCount || 0);
-			if (!bufferedReflection) throw new _mastra_core_error.MastraError({
-				id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "NO_CONTENT"),
-				text: "No buffered reflection to swap",
-				domain: _mastra_core_error.ErrorDomain.STORAGE,
-				category: _mastra_core_error.ErrorCategory.USER,
-				details: { id: input.currentRecord.id }
-			});
-			const unreflectedContent = (row.activeObservations || "").split("\n").slice(reflectedLineCount).join("\n").trim();
-			const newObservations = unreflectedContent ? `${bufferedReflection}\n\n${unreflectedContent}` : bufferedReflection;
-			const newRecord = await this.createReflectionGeneration({
-				currentRecord: input.currentRecord,
-				reflection: newObservations,
-				tokenCount: input.tokenCount
-			});
-			const nowSql = transformToSqlValue(/* @__PURE__ */ new Date());
-			await this.pool.execute(`UPDATE ${OM_TABLE_QUOTED} SET
-          ${omCol("bufferedReflection")} = NULL,
-          ${omCol("bufferedReflectionTokens")} = NULL,
-          ${omCol("bufferedReflectionInputTokens")} = NULL,
-          ${omCol("reflectedObservationLineCount")} = NULL,
-          ${omCol("updatedAt")} = ?
-        WHERE ${omCol("id")} = ?`, [nowSql, input.currentRecord.id]);
-			return newRecord;
+			const { currentRecord } = input;
+			return await this.withOMTransaction(async (connection) => {
+				const row = await this.lockOMRow(connection, currentRecord.id);
+				if (!row) return currentRecord;
+				if (row.supersededBy) return this.parseOMRow(await this.resolveLiveOMRow(connection, row));
+				const stored = this.parseOMRow(row);
+				const bufferedReflection = stored.bufferedReflection || "";
+				if (!bufferedReflection) throw new _mastra_core_error.MastraError({
+					id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "NO_CONTENT"),
+					text: "No buffered reflection to swap",
+					domain: _mastra_core_error.ErrorDomain.STORAGE,
+					category: _mastra_core_error.ErrorCategory.USER,
+					details: { id: currentRecord.id }
+				});
+				if (!isAppendOnlySince(stored.activeObservations, currentRecord.activeObservations)) return stored;
+				const reflectedLineCount = stored.reflectedObservationLineCount ?? 0;
+				const unreflectedContent = (stored.activeObservations || "").split("\n").slice(reflectedLineCount).join("\n").trim();
+				const newObservations = unreflectedContent ? `${bufferedReflection}\n\n${unreflectedContent}` : bufferedReflection;
+				const tokenCount = input.tokenCount + Math.max(0, (stored.observationTokenCount ?? 0) - (currentRecord.observationTokenCount ?? 0));
+				return this.rollOverOMRow(connection, stored.id, newObservations, tokenCount, input.newRecordId, true);
+			}, "swapBufferedReflectionToActive");
 		} catch (error) {
 			rethrowOrWrapOM(error, input.currentRecord.id, "SWAP_BUFFERED_REFLECTION_TO_ACTIVE");
 		}
 	}
+	/**
+	* Runs `fn` in one transaction on a dedicated connection. Every OM lifecycle write locks its
+	* target row by primary key (`SELECT … FOR UPDATE`, a record lock — never a range), so the
+	* only expected lock conflict is a wait; a deadlock or lock-wait timeout (e.g. against the
+	* startup backfill's scan) is retried a bounded number of times.
+	*/
+	async withOMTransaction(fn, fencedOperation) {
+		for (let attempt = 1;; attempt++) {
+			const connection = await this.pool.getConnection();
+			try {
+				await connection.beginTransaction();
+				if (fencedOperation) await this.#assertFence(connection, void 0, fencedOperation);
+				const result = await fn(connection);
+				await connection.commit();
+				return result;
+			} catch (error) {
+				await connection.rollback().catch(() => {});
+				if (attempt < OM_MAX_TRANSACTION_ATTEMPTS && isRetryableLockError(error)) continue;
+				throw error;
+			} finally {
+				connection.release();
+			}
+		}
+	}
+	/** Row-locks one OM record by primary key for the rest of the transaction. */
+	async lockOMRow(connection, id) {
+		const [rows] = await connection.execute(`SELECT * FROM ${OM_TABLE_QUOTED} WHERE ${omCol("id")} = ? FOR UPDATE`, [id]);
+		return rows?.[0] ?? null;
+	}
+	/**
+	* The live, row-locked record a lifecycle write aimed at `row` lands on: `row` itself while
+	* live, otherwise the head. The head is found with a plain (non-locking, so no range locks)
+	* canonical head read, then locked by primary key. Under REPEATABLE READ that read can predate
+	* a rollover committed after this transaction started; the locking read sees the latest
+	* committed row, so a head retired since is followed through `supersededBy` (bounded).
+	*/
+	async resolveLiveOMRow(connection, row) {
+		if (!row.supersededBy) return row;
+		const [heads] = await connection.execute(`SELECT id FROM ${OM_TABLE_QUOTED} WHERE ${omCol("lookupKey")} = ? ORDER BY ${OM_HEAD_ORDER} LIMIT 1`, [row.lookupKey]);
+		const headId = heads?.[0]?.id ?? row.supersededBy;
+		let current = await this.lockOMRow(connection, headId) ?? row;
+		for (let hop = 0; current.supersededBy; hop++) {
+			const next = hop < OM_MAX_HEAD_HOPS ? await this.lockOMRow(connection, current.supersededBy) : null;
+			if (!next) throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "RESOLVE_OBSERVATIONAL_MEMORY_HEAD", "FAILED"),
+				text: `Observational memory record ${row.id} is superseded but no live head was found`,
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { id: row.id }
+			});
+			current = next;
+		}
+		return current;
+	}
+	/**
+	* Create the next generation from the stored (live, row-locked) record and retire the stored
+	* record in the same transaction. Carried columns are copied in SQL from the stored row, so
+	* nothing round-trips through a client-side date conversion. Buffered chunks move to the new
+	* generation; the cursor, buffering markers, flags, and counters carry over; buffered
+	* reflection state does not (and is cleared on the retired row after a buffered swap).
+	*/
+	async rollOverOMRow(connection, storedId, observations, tokenCount, newRecordId, clearBufferedReflection) {
+		const id = newRecordId ?? globalThis.crypto.randomUUID();
+		const nowSql = transformToSqlValue(/* @__PURE__ */ new Date());
+		const c = omCol;
+		await connection.execute(`INSERT INTO ${OM_TABLE_QUOTED} (
+        ${c("id")}, ${c("lookupKey")}, ${c("scope")}, ${c("resourceId")}, ${c("threadId")},
+        ${c("activeObservations")}, ${c("activeObservationsPendingUpdate")},
+        ${c("originType")}, ${c("config")}, ${c("generationCount")}, ${c("lastObservedAt")}, ${c("lastReflectionAt")},
+        ${c("pendingMessageTokens")}, ${c("totalTokensObserved")}, ${c("observationTokenCount")}, ${c("bufferedObservationChunks")},
+        ${c("isObserving")}, ${c("isReflecting")}, ${c("isBufferingObservation")}, ${c("isBufferingReflection")},
+        ${c("lastBufferedAtTokens")}, ${c("lastBufferedAtTime")},
+        ${c("observedTimezone")}, ${c("metadata")}, ${c("supersededBy")}, ${c("createdAt")}, ${c("updatedAt")}
+      )
+      SELECT
+        ?, ${c("lookupKey")}, ${c("scope")}, ${c("resourceId")}, ${c("threadId")},
+        ?, NULL,
+        'reflection', ${c("config")}, ${c("generationCount")} + 1, ${c("lastObservedAt")}, ?,
+        ${c("pendingMessageTokens")}, ${c("totalTokensObserved")}, ?, ${c("bufferedObservationChunks")},
+        false, false, ${c("isBufferingObservation")}, false,
+        ${c("lastBufferedAtTokens")}, ${c("lastBufferedAtTime")},
+        ${c("observedTimezone")}, ${c("metadata")}, NULL, ?, ?
+      FROM ${OM_TABLE_QUOTED} WHERE ${c("id")} = ?`, [
+			id,
+			observations,
+			nowSql,
+			Math.round(tokenCount),
+			nowSql,
+			nowSql,
+			storedId
+		]);
+		const [retired] = await connection.execute(`UPDATE ${OM_TABLE_QUOTED} SET
+        ${c("supersededBy")} = ?,
+        ${c("bufferedObservationChunks")} = NULL,
+        ${clearBufferedReflection ? `${c("bufferedReflection")} = NULL, ${c("bufferedReflectionTokens")} = NULL,
+        ${c("bufferedReflectionInputTokens")} = NULL, ${c("reflectedObservationLineCount")} = NULL,` : ""}
+        ${c("updatedAt")} = ?
+      WHERE ${c("id")} = ? AND ${c("supersededBy")} IS NULL`, [
+			id,
+			nowSql,
+			storedId
+		]);
+		if (retired.affectedRows !== 1) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", "CREATE_REFLECTION_GENERATION", "RETIRE_FAILED"),
+			text: `Failed to retire observational memory record ${storedId}`,
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+			details: { id: storedId }
+		});
+		const inserted = await this.lockOMRow(connection, id);
+		if (!inserted) throwOMNotFound(id, "CREATE_REFLECTION_GENERATION");
+		return this.parseOMRow(inserted);
+	}
+	/**
+	* Retire every live row that sorts after its key's canonical head, marking it superseded by
+	* the head. Rows retired by older adapter versions (which never set `supersededBy`) become
+	* frozen. Only keys with more than one live row are touched; each update embeds the head's
+	* ordering key, so a row created by a concurrent rollover (a newer generation) never matches.
+	* Runs at READ COMMITTED so the scan takes no gap locks.
+	*/
+	async backfillSupersededBy() {
+		const [keys] = await this.pool.execute(`SELECT ${omCol("lookupKey")} AS lookupKey FROM ${OM_TABLE_QUOTED}
+      WHERE ${omCol("supersededBy")} IS NULL GROUP BY ${omCol("lookupKey")} HAVING COUNT(*) > 1`);
+		for (const { lookupKey } of keys ?? []) for (let attempt = 1;; attempt++) {
+			const connection = await this.pool.getConnection();
+			try {
+				await connection.query("SET TRANSACTION ISOLATION LEVEL READ COMMITTED");
+				await connection.beginTransaction();
+				await connection.execute(`UPDATE ${OM_TABLE_QUOTED} AS r
+            JOIN (
+              SELECT ${omCol("id")} AS id, ${omCol("generationCount")} AS generationCount, ${omCol("createdAt")} AS createdAt
+              FROM ${OM_TABLE_QUOTED} WHERE ${omCol("lookupKey")} = ? ORDER BY ${OM_HEAD_ORDER} LIMIT 1
+            ) AS h
+            SET r.${omCol("supersededBy")} = h.id
+            WHERE r.${omCol("lookupKey")} = ?
+              AND r.${omCol("supersededBy")} IS NULL
+              AND (
+                r.${omCol("generationCount")} < h.generationCount
+                OR (r.${omCol("generationCount")} = h.generationCount AND r.${omCol("createdAt")} > h.createdAt)
+                OR (r.${omCol("generationCount")} = h.generationCount AND r.${omCol("createdAt")} = h.createdAt AND r.${omCol("id")} > h.id)
+              )`, [lookupKey, lookupKey]);
+				await connection.commit();
+				break;
+			} catch (error) {
+				await connection.rollback().catch(() => {});
+				if (attempt < OM_MAX_TRANSACTION_ATTEMPTS && isRetryableLockError(error)) continue;
+				throw error;
+			} finally {
+				connection.release();
+			}
+		}
+	}
 	async updateOMFlag(id, column, value, operation) {
 		try {
 			const [result] = await this.pool.execute(`UPDATE ${OM_TABLE_QUOTED} SET ${omCol(column)} = ?, ${omCol("updatedAt")} = ? WHERE ${omCol("id")} = ?`, [
@@ -7878,7 +8333,8 @@ var MemoryMySQL = class MemoryMySQL extends _mastra_core_storage.MemoryStorage {
 			config: parseJSONColumn(row.config) ?? {},
 			metadata: parseJSONColumn(row.metadata),
 			observedMessageIds: parseJSONColumn(row.observedMessageIds),
-			observedTimezone: row.observedTimezone || void 0
+			observedTimezone: row.observedTimezone || void 0,
+			supersededBy: row.supersededBy ?? null
 		};
 	}
 };
@@ -10866,6 +11322,26 @@ function parseSnapshot(snapshot) {
 	}
 	return snapshot;
 }
+const RUN_OWNERS_TABLE = formatTableName(_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS);
+const RUN_ID = quoteIdentifier("runId", "column name");
+const OWNER_ID = quoteIdentifier("ownerId", "column name");
+const LEASE_EXPIRES_AT = quoteIdentifier("leaseExpiresAt", "column name");
+const UPDATED_AT = quoteIdentifier("updatedAt", "column name");
+const RUN_OWNER_COLUMNS = `generation, ${OWNER_ID} AS ownerId, ${LEASE_EXPIRES_AT} AS leaseExpiresAt, ${DB_NOW_MS} AS nowMs`;
+function toRunOwnershipRecord(runId, row) {
+	const leaseExpiresAt = row.leaseExpiresAt === null ? null : Number(row.leaseExpiresAt);
+	return {
+		runId,
+		generation: Number(row.generation),
+		ownerId: String(row.ownerId),
+		leaseExpiresAt: leaseExpiresAt === null ? null : new Date(leaseExpiresAt),
+		live: leaseExpiresAt !== null && leaseExpiresAt > Number(row.nowMs)
+	};
+}
+async function readRunOwner(q, runId) {
+	const [rows] = await q.execute(`SELECT ${RUN_OWNER_COLUMNS} FROM ${RUN_OWNERS_TABLE} WHERE ${RUN_ID} = ?`, [runId]);
+	return rows[0] ? toRunOwnershipRecord(runId, rows[0]) : null;
+}
 function mapWorkflowRow(row) {
 	return {
 		workflowName: row.workflow_name,
@@ -10898,6 +11374,9 @@ var WorkflowsMySQL = class WorkflowsMySQL extends _mastra_core_storage.Workflows
 			tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT],
 			compositePrimaryKey: ["workflow_name", "run_id"]
+		}), generateTableSQL({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS]
 		})];
 	}
 	constructor({ operations, pool, skipDefaultIndexes, indexes }) {
@@ -10941,16 +11420,125 @@ var WorkflowsMySQL = class WorkflowsMySQL extends _mastra_core_storage.Workflows
 			schema,
 			ifNotExists: ["resourceId"]
 		});
+		await this.operations.createTable({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS]
+		});
 		await this.createDefaultIndexes();
 		await this.createCustomIndexes();
 	}
 	async dangerouslyClearAll() {
 		await this.pool.execute(`DELETE FROM ${formatTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT)}`);
+		await this.pool.execute(`DELETE FROM ${RUN_OWNERS_TABLE}`);
 	}
-	async deleteWorkflowRunById({ runId, workflowName }) {
+	supportsRunFencing() {
+		return true;
+	}
+	#ownershipError(operation, runId, error) {
+		return new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("MYSQL", 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 {
+			return await claimTransaction(this.pool, async (connection) => {
+				const [existing] = await connection.execute(`SELECT generation FROM ${RUN_OWNERS_TABLE} WHERE ${RUN_ID} = ? FOR UPDATE`, [runId]);
+				if (existing.length === 0) {
+					if (expectedGeneration !== void 0 && expectedGeneration !== 0) return {
+						acquired: false,
+						record: null
+					};
+					await connection.execute(`INSERT INTO ${RUN_OWNERS_TABLE} (${RUN_ID}, generation, ${OWNER_ID}, ${LEASE_EXPIRES_AT}, ${UPDATED_AT})
+             VALUES (?, GREATEST(1, ${DB_NOW_MS}), ?, ${DB_NOW_MS} + ?, ${DB_NOW_MS})`, [
+						runId,
+						ownerId,
+						leaseMs
+					]);
+					return {
+						acquired: true,
+						record: await readRunOwner(connection, runId)
+					};
+				}
+				await connection.execute(`UPDATE ${RUN_OWNERS_TABLE}
+           SET generation = generation + 1, ${OWNER_ID} = ?, ${LEASE_EXPIRES_AT} = ${DB_NOW_MS} + ?,
+               ${UPDATED_AT} = ${DB_NOW_MS}
+           WHERE ${RUN_ID} = ?
+             AND (? IS NULL OR generation = ?)
+             AND (? OR ${LEASE_EXPIRES_AT} IS NULL OR ${LEASE_EXPIRES_AT} <= ${DB_NOW_MS})`, [
+					ownerId,
+					leaseMs,
+					runId,
+					expectedGeneration ?? null,
+					expectedGeneration ?? null,
+					force === true
+				]);
+				const record = await readRunOwner(connection, runId);
+				return record && record.generation === Number(existing[0].generation) + 1 ? {
+					acquired: true,
+					record
+				} : {
+					acquired: false,
+					record
+				};
+			});
+		} catch (error) {
+			throw this.#ownershipError("CLAIM_RUN_OWNERSHIP", runId, error);
+		}
+	}
+	async renewRunOwnership({ leaseMs, ...fence }) {
 		try {
-			await this.pool.execute(`DELETE FROM ${formatTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT)} WHERE ${quoteIdentifier("workflow_name", "column name")} = ? AND ${quoteIdentifier("run_id", "column name")} = ?`, [workflowName, runId]);
+			return await inTransaction(this.pool, async (connection) => {
+				await connection.execute(`UPDATE ${RUN_OWNERS_TABLE}
+           SET ${LEASE_EXPIRES_AT} = ${DB_NOW_MS} + ?, ${UPDATED_AT} = ${DB_NOW_MS}
+           WHERE ${RUN_ID} = ? AND generation = ? AND ${OWNER_ID} = ? AND ${LEASE_EXPIRES_AT} IS NOT NULL`, [
+					leaseMs,
+					fence.runId,
+					fence.generation,
+					fence.ownerId
+				]);
+				const record = await readRunOwner(connection, fence.runId);
+				return record && (0, _mastra_core_storage.matchesRunFence)(record, fence) && record.leaseExpiresAt !== null ? {
+					renewed: true,
+					record
+				} : {
+					renewed: false,
+					record
+				};
+			});
 		} catch (error) {
+			throw this.#ownershipError("RENEW_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async releaseRunOwnership(fence) {
+		try {
+			return await inTransaction(this.pool, async (connection) => {
+				await connection.execute(`UPDATE ${RUN_OWNERS_TABLE} SET ${LEASE_EXPIRES_AT} = NULL, ${UPDATED_AT} = ${DB_NOW_MS}
+           WHERE ${RUN_ID} = ? AND generation = ? AND ${OWNER_ID} = ?`, [
+					fence.runId,
+					fence.generation,
+					fence.ownerId
+				]);
+				return (0, _mastra_core_storage.matchesRunFence)(await readRunOwner(connection, fence.runId), fence);
+			});
+		} catch (error) {
+			throw this.#ownershipError("RELEASE_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async getRunOwnership({ runId }) {
+		try {
+			return await readRunOwner(this.pool, runId);
+		} catch (error) {
+			throw this.#ownershipError("GET_RUN_OWNERSHIP", runId, error);
+		}
+	}
+	async deleteWorkflowRunById({ runId, workflowName, fence }) {
+		try {
+			await withRunFence(this.pool, RUN_OWNERS_TABLE, (0, _mastra_core_storage.resolveRunFence)(this, fence, runId), "deleteWorkflowRunById", (q) => q.execute(`DELETE FROM ${formatTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT)} WHERE ${quoteIdentifier("workflow_name", "column name")} = ? AND ${quoteIdentifier("run_id", "column name")} = ?`, [workflowName, runId]));
+		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: "MYSQL_WORKFLOWS_DELETE_RUN_BY_ID_FAILED",
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -10962,10 +11550,12 @@ var WorkflowsMySQL = class WorkflowsMySQL extends _mastra_core_storage.Workflows
 			}, error);
 		}
 	}
-	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state }) {
+	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state, fence: explicitFence }) {
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence, runId);
 		const connection = await this.pool.getConnection();
 		try {
 			await connection.beginTransaction();
+			if (fence) await assertRunFence(connection, RUN_OWNERS_TABLE, fence, "updateWorkflowResults");
 			const [rows] = await connection.execute(`SELECT snapshot FROM ${formatTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT)} WHERE ${quoteIdentifier("workflow_name", "column name")} = ? AND ${quoteIdentifier("run_id", "column name")} = ? FOR UPDATE`, [workflowName, runId]);
 			if (!Array.isArray(rows) || rows.length === 0) {
 				await connection.rollback();
@@ -11016,10 +11606,12 @@ var WorkflowsMySQL = class WorkflowsMySQL extends _mastra_core_storage.Workflows
 			connection.release();
 		}
 	}
-	async updateWorkflowState({ workflowName, runId, opts }) {
+	async updateWorkflowState({ workflowName, runId, opts, fence: explicitFence }) {
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence, runId);
 		const connection = await this.pool.getConnection();
 		try {
 			await connection.beginTransaction();
+			if (fence) await assertRunFence(connection, RUN_OWNERS_TABLE, fence, "updateWorkflowState");
 			const [rows] = await connection.execute(`SELECT snapshot FROM ${formatTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT)} WHERE ${quoteIdentifier("workflow_name", "column name")} = ? AND ${quoteIdentifier("run_id", "column name")} = ? FOR UPDATE`, [workflowName, runId]);
 			if (!Array.isArray(rows) || rows.length === 0) {
 				await connection.rollback();
@@ -11045,6 +11637,7 @@ var WorkflowsMySQL = class WorkflowsMySQL extends _mastra_core_storage.Workflows
 			return updatedSnapshot;
 		} catch (error) {
 			await connection.rollback();
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: "MYSQL_WORKFLOWS_UPDATE_STATE_FAILED",
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -11058,35 +11651,38 @@ var WorkflowsMySQL = class WorkflowsMySQL extends _mastra_core_storage.Workflows
 			connection.release();
 		}
 	}
-	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt }) {
+	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt, fence }) {
 		const now = /* @__PURE__ */ new Date();
 		const createdAtValue = createdAt ?? now;
 		const updatedAtValue = updatedAt ?? now;
+		const tableName = formatTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
 		try {
-			const tableName = formatTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
-			const [updateResult] = await this.pool.execute(`UPDATE ${tableName}
-         SET ${quoteIdentifier("resourceId", "column name")} = ?,
-             ${quoteIdentifier("snapshot", "column name")} = ?,
-             ${quoteIdentifier("updatedAt", "column name")} = ?
-         WHERE ${quoteIdentifier("workflow_name", "column name")} = ? AND ${quoteIdentifier("run_id", "column name")} = ?`, [
-				resourceId ?? null,
-				JSON.stringify(snapshot),
-				transformToSqlValue(updatedAtValue),
-				workflowName,
-				runId
-			]);
-			if (updateResult.affectedRows > 0) return;
-			await this.pool.execute(`INSERT INTO ${tableName} (${quoteIdentifier("workflow_name", "column name")}, ${quoteIdentifier("run_id", "column name")}, ${quoteIdentifier("resourceId", "column name")}, ${quoteIdentifier("snapshot", "column name")}, ${quoteIdentifier("createdAt", "column name")}, ${quoteIdentifier("updatedAt", "column name")})
-         VALUES (?, ?, ?, ?, ?, ?)
-         ON DUPLICATE KEY UPDATE ${quoteIdentifier("resourceId", "column name")} = VALUES(${quoteIdentifier("resourceId", "column name")}), ${quoteIdentifier("snapshot", "column name")} = VALUES(${quoteIdentifier("snapshot", "column name")}), ${quoteIdentifier("updatedAt", "column name")} = VALUES(${quoteIdentifier("updatedAt", "column name")})`, [
-				workflowName,
-				runId,
-				resourceId ?? null,
-				JSON.stringify(snapshot),
-				transformToSqlValue(createdAtValue),
-				transformToSqlValue(updatedAtValue)
-			]);
+			await withRunFence(this.pool, RUN_OWNERS_TABLE, (0, _mastra_core_storage.resolveRunFence)(this, fence, runId), "persistWorkflowSnapshot", async (q) => {
+				const [updateResult] = await q.execute(`UPDATE ${tableName}
+           SET ${quoteIdentifier("resourceId", "column name")} = ?,
+               ${quoteIdentifier("snapshot", "column name")} = ?,
+               ${quoteIdentifier("updatedAt", "column name")} = ?
+           WHERE ${quoteIdentifier("workflow_name", "column name")} = ? AND ${quoteIdentifier("run_id", "column name")} = ?`, [
+					resourceId ?? null,
+					JSON.stringify(snapshot),
+					transformToSqlValue(updatedAtValue),
+					workflowName,
+					runId
+				]);
+				if (updateResult.affectedRows > 0) return;
+				await q.execute(`INSERT INTO ${tableName} (${quoteIdentifier("workflow_name", "column name")}, ${quoteIdentifier("run_id", "column name")}, ${quoteIdentifier("resourceId", "column name")}, ${quoteIdentifier("snapshot", "column name")}, ${quoteIdentifier("createdAt", "column name")}, ${quoteIdentifier("updatedAt", "column name")})
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON DUPLICATE KEY UPDATE ${quoteIdentifier("resourceId", "column name")} = VALUES(${quoteIdentifier("resourceId", "column name")}), ${quoteIdentifier("snapshot", "column name")} = VALUES(${quoteIdentifier("snapshot", "column name")}), ${quoteIdentifier("updatedAt", "column name")} = VALUES(${quoteIdentifier("updatedAt", "column name")})`, [
+					workflowName,
+					runId,
+					resourceId ?? null,
+					JSON.stringify(snapshot),
+					transformToSqlValue(createdAtValue),
+					transformToSqlValue(updatedAtValue)
+				]);
+			});
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: "MYSQL_WORKFLOWS_PERSIST_SNAPSHOT_FAILED",
 				domain: _mastra_core_error.ErrorDomain.STORAGE,