@mastra/libsql 1.26.0-alpha.3 → 1.26.1-alpha.0

package/dist/index.js

@@ -373,7 +373,7 @@ function isSingleConnectionDatabase({ url, syncUrl }) {
 * transactions rather than failing with `TRANSACTION_ACTIVE`.
 *
 * `transaction()` takes the gate and releases it when the transaction commits,
-* rolls back, or closes. `execute`, `batch`, `executeMultiple`, and `migrate`
+* rolls back, or closes. `execute`, `batch`, `executeMultiple`, `migrate`, and `sync`
 * wait for the gate to be free before running but do not hold it — the driver
 * executes them synchronously on the connection, so they cannot interleave
 * with each other. Every other member passes through untouched.
@@ -424,7 +424,8 @@ function gateSingleConnectionClient(client) {
 			case "execute":
 			case "batch":
 			case "executeMultiple":
-			case "migrate": return (...args) => waitForGate(() => target[prop].apply(target, args));
+			case "migrate":
+			case "sync": return (...args) => waitForGate(() => target[prop].apply(target, args));
 			default: {
 				const value = Reflect.get(target, prop);
 				return typeof value === "function" ? value.bind(target) : value;
@@ -9287,6 +9288,92 @@ var MCPServersLibSQL = class extends MCPServersStorage {
 	}
 };
 //#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/domains/memory/index.ts
 /**
 * Local constant for the observational memory table name.
@@ -9294,6 +9381,13 @@ var MCPServersLibSQL = class extends MCPServersStorage {
 * versions that don't export TABLE_OBSERVATIONAL_MEMORY.
 */
 const OM_TABLE = "mastra_observational_memory";
+/** Canonical head order: newest generation, then earliest createdAt, then lowest id. */
+const OM_HEAD_ORDER = `"generationCount" DESC, "createdAt" ASC, id ASC`;
+/** Lifecycle writes aimed at a retired record follow `supersededBy` to the head at most this many times. */
+const OM_MAX_HEAD_HOPS = 3;
+/** Optimistic lifecycle writes rerun at most this many times when another process changes the row. */
+const OM_MAX_CAS_ATTEMPTS = 10;
+const OM_CAS_CONFLICT = Symbol("om-cas-conflict");
 function addSqliteMetadataFilter(conditions, params, metadataFilter) {
 	if (!metadataFilter) return;
 	for (const [key, value] of Object.entries(metadataFilter)) {
@@ -9359,11 +9453,13 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 		}
 	};
 	#client;
+	#embeddedReplica;
 	#db;
 	constructor(config) {
 		super();
 		const client = resolveClient(config);
 		this.#client = client;
+		this.#embeddedReplica = config.embeddedReplica === true;
 		this.#db = new LibSQLDB({
 			client,
 			maxRetries: config.maxRetries,
@@ -9402,7 +9498,7 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 			tableName: TABLE_MEMORY_RUN_FENCES,
 			schema: RUN_FENCING_TABLE_SCHEMAS[TABLE_MEMORY_RUN_FENCES]
 		});
-		const omSchema = OBSERVATIONAL_MEMORY_TABLE_SCHEMA?.[OM_TABLE];
+		const omSchema = withObservationalMemoryLifecycleColumns(OBSERVATIONAL_MEMORY_TABLE_SCHEMA?.[OM_TABLE]);
 		if (omSchema) {
 			await this.#db.createTable({
 				tableName: OM_TABLE,
@@ -9426,7 +9522,8 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 					"isBufferingReflection",
 					"lastBufferedAtTokens",
 					"lastBufferedAtTime",
-					"metadata"
+					"metadata",
+					"supersededBy"
 				]
 			});
 		}
@@ -9442,10 +9539,13 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 			sql: `CREATE INDEX IF NOT EXISTS idx_messages_thread_resource_created_at ON ${TABLE_MESSAGES} (thread_id, "resourceId", "createdAt")`,
 			args: []
 		}], "write");
-		if (omSchema) await this.#client.execute({
-			sql: `CREATE INDEX IF NOT EXISTS idx_om_lookup_key ON "${OM_TABLE}" ("lookupKey")`,
-			args: []
-		});
+		if (omSchema) {
+			await this.#client.execute({
+				sql: `CREATE INDEX IF NOT EXISTS idx_om_lookup_key ON "${OM_TABLE}" ("lookupKey")`,
+				args: []
+			});
+			await this.#backfillSupersededBy();
+		}
 	}
 	async dangerouslyClearAll() {
 		await this.init();
@@ -10579,18 +10679,218 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 			config: row.config ? JSON.parse(row.config) : {},
 			metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
 			observedMessageIds: row.observedMessageIds ? JSON.parse(row.observedMessageIds) : void 0,
-			observedTimezone: row.observedTimezone || void 0
+			observedTimezone: row.observedTimezone || void 0,
+			supersededBy: row.supersededBy ?? null
 		};
 	}
+	/**
+	* Runs one optimistic lifecycle write under the client write lock (in-process ordering).
+	* `attempt` reads the rows it needs, then writes with statements guarded by those reads
+	* (`#readOMRow`'s guard); it returns `OM_CAS_CONFLICT` when a guard matched no row because
+	* another process changed the row in between, and the attempt reruns on fresh state.
+	*
+	* No interactive transaction is held across `await`s: the `libsql` driver is synchronous, so
+	* an open write transaction makes any other connection's write in this process block the
+	* event loop until `busy_timeout` (SQLITE_BUSY). Each statement or batch here runs in one call.
+	*
+	* With `fencedOperation`, a write made inside a run fence scope is fenced: each attempt first
+	* checks the run's claim, and the attempt's reads put the claim into their guards, so a claim
+	* taken over between the check and the write turns the write into a conflict and the next
+	* attempt's check rejects it.
+	*/
+	async #withOMCas(operation, attempt, fencedOperation) {
+		const check = fencedOperation ? this.#runFenceCheck(void 0, fencedOperation) : void 0;
+		return this.#write(operation, async () => {
+			for (let i = 0; i < OM_MAX_CAS_ATTEMPTS; i++) {
+				if (check) await assertRunFence(this.#client, check);
+				const result = await attempt(i, check);
+				if (result !== OM_CAS_CONFLICT) return result;
+				if (this.#embeddedReplica) await this.#client.sync?.();
+			}
+			throw new MastraError({
+				id: createStorageErrorId("LIBSQL", operation, "CONFLICT"),
+				text: `Observational memory write kept conflicting with concurrent writers (${OM_MAX_CAS_ATTEMPTS} attempts)`,
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY
+			});
+		});
+	}
+	/**
+	* Whether a missing row may only be missing from this embedded replica's local copy: the first
+	* attempt reads before any sync, so it returns a conflict to sync and read again instead of
+	* acting on the absence.
+	*/
+	#mayBeUnsynced(attemptIndex) {
+		return this.#embeddedReplica && attemptIndex === 0;
+	}
+	/**
+	* With `check`, the guard also requires the run's claim to still match it, so a guarded write
+	* made after the claim was taken over matches no row.
+	*/
+	#toOMRow(result, check) {
+		const row = result.rows?.[0];
+		if (!row) return null;
+		const columns = result.columns;
+		const guard = {
+			sql: columns.map((c) => `"${c}" IS ?`).join(" AND "),
+			args: columns.map((c) => row[c])
+		};
+		if (check) {
+			guard.sql += ` AND EXISTS (SELECT 1 FROM ${check.claimsTable} WHERE runId = ? AND generation = ? AND ownerId = ?)`;
+			guard.args.push(check.fence.runId, check.fence.generation, check.fence.ownerId);
+		}
+		return {
+			record: this.parseOMRow(row),
+			guard
+		};
+	}
+	async #readOMRow(id, check) {
+		return this.#toOMRow(await this.#client.execute({
+			sql: `SELECT * FROM "${OM_TABLE}" WHERE id = ?`,
+			args: [id]
+		}), check);
+	}
+	async #readOMHeadRow(lookupKey, check) {
+		return this.#toOMRow(await this.#client.execute({
+			sql: `SELECT * FROM "${OM_TABLE}" WHERE "lookupKey" = ? ORDER BY ${OM_HEAD_ORDER} LIMIT 1`,
+			args: [lookupKey]
+		}), check);
+	}
+	/** The live row a lifecycle write aimed at `row` lands on: the row itself while live, otherwise the head. */
+	async #resolveLiveOMRow(row, check) {
+		let current = row;
+		for (let hop = 0; current.record.supersededBy; hop++) {
+			const head = hop < OM_MAX_HEAD_HOPS ? await this.#readOMHeadRow(this.getOMKey(current.record.threadId, current.record.resourceId), check) : null;
+			if (!head || head.record.id === current.record.id) throw new MastraError({
+				id: createStorageErrorId("LIBSQL", "RESOLVE_OBSERVATIONAL_MEMORY_HEAD", "FAILED"),
+				text: `Observational memory record ${row.record.id} is superseded but no live head was found`,
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { id: row.record.id }
+			});
+			current = head;
+		}
+		return current;
+	}
+	/**
+	* Retire every live row of a lookup key that sorts after the canonical head, marking it
+	* superseded by the head. Rows retired by older adapter versions (which never set
+	* `supersededBy`) become frozen. One statement: the head it computes and the rows it retires
+	* are read under the same SQLite write lock, so a concurrent rollover cannot leave a key
+	* without a live row.
+	*/
+	async #backfillSupersededBy() {
+		const headOf = `(SELECT h.id FROM "${OM_TABLE}" h WHERE h."lookupKey" = "${OM_TABLE}"."lookupKey" ORDER BY ${OM_HEAD_ORDER} LIMIT 1)`;
+		const duplicated = `SELECT "lookupKey" FROM "${OM_TABLE}" WHERE "supersededBy" IS NULL GROUP BY "lookupKey" HAVING COUNT(*) > 1`;
+		if (!(await this.#client.execute({
+			sql: duplicated,
+			args: []
+		})).rows?.length) return;
+		await this.#write("backfillSupersededBy", () => this.#client.execute({
+			sql: `UPDATE "${OM_TABLE}" SET "supersededBy" = ${headOf}
+          WHERE "supersededBy" IS NULL AND "lookupKey" IN (${duplicated}) AND id <> ${headOf}`,
+			args: []
+		}));
+	}
+	/**
+	* Create the next generation from the stored (live) row and retire it in one atomic batch,
+	* guarded by the row as read. Buffered chunks move to the new generation (in order); the
+	* cursor, buffering markers, flags, counters, config, and metadata carry over; buffered
+	* reflection state does not (it is cleared on the retired row). Returns `OM_CAS_CONFLICT`
+	* when the row changed since it was read.
+	*/
+	async #rollOverObservationalMemory(storedRow, observations, tokenCount, newRecordId) {
+		const stored = storedRow.record;
+		const id = newRecordId ?? crypto.randomUUID();
+		const now = /* @__PURE__ */ new Date();
+		const chunks = Array.isArray(stored.bufferedObservationChunks) ? stored.bufferedObservationChunks : [];
+		const lookupKey = this.getOMKey(stored.threadId, stored.resourceId);
+		const record = {
+			id,
+			scope: stored.scope,
+			threadId: stored.threadId,
+			resourceId: stored.resourceId,
+			createdAt: now,
+			updatedAt: now,
+			lastObservedAt: stored.lastObservedAt,
+			originType: "reflection",
+			generationCount: stored.generationCount + 1,
+			activeObservations: observations,
+			bufferedObservationChunks: chunks.length > 0 ? chunks : void 0,
+			totalTokensObserved: stored.totalTokensObserved,
+			observationTokenCount: tokenCount,
+			pendingMessageTokens: stored.pendingMessageTokens,
+			isReflecting: false,
+			isObserving: false,
+			isBufferingObservation: stored.isBufferingObservation,
+			isBufferingReflection: false,
+			lastBufferedAtTokens: stored.lastBufferedAtTokens,
+			lastBufferedAtTime: stored.lastBufferedAtTime,
+			config: stored.config,
+			metadata: stored.metadata,
+			observedTimezone: stored.observedTimezone,
+			supersededBy: null
+		};
+		const [retired] = await this.#client.batch([{
+			sql: `UPDATE "${OM_TABLE}" SET "supersededBy" = ?, "bufferedObservationChunks" = NULL,
+            "bufferedReflection" = NULL, "bufferedReflectionTokens" = NULL,
+            "bufferedReflectionInputTokens" = NULL, "reflectedObservationLineCount" = NULL, "updatedAt" = ?
+            WHERE id = ? AND ${storedRow.guard.sql}`,
+			args: [
+				id,
+				now.toISOString(),
+				stored.id,
+				...storedRow.guard.args
+			]
+		}, {
+			sql: `INSERT INTO "${OM_TABLE}" (
+            id, "lookupKey", scope, "resourceId", "threadId",
+            "activeObservations", "activeObservationsPendingUpdate",
+            "originType", config, "generationCount", "lastObservedAt", "lastReflectionAt",
+            "pendingMessageTokens", "totalTokensObserved", "observationTokenCount",
+            "bufferedObservationChunks",
+            "isObserving", "isReflecting", "isBufferingObservation", "isBufferingReflection", "lastBufferedAtTokens", "lastBufferedAtTime",
+            "observedTimezone", metadata, "supersededBy", "createdAt", "updatedAt"
+          ) SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+            WHERE EXISTS (SELECT 1 FROM "${OM_TABLE}" WHERE id = ? AND "supersededBy" = ?)`,
+			args: [
+				id,
+				lookupKey,
+				record.scope,
+				record.resourceId,
+				record.threadId || null,
+				observations,
+				null,
+				"reflection",
+				JSON.stringify(record.config),
+				record.generationCount,
+				record.lastObservedAt ? record.lastObservedAt.toISOString() : null,
+				now.toISOString(),
+				record.pendingMessageTokens,
+				record.totalTokensObserved,
+				record.observationTokenCount,
+				chunks.length > 0 ? JSON.stringify(chunks) : null,
+				false,
+				false,
+				record.isBufferingObservation,
+				false,
+				record.lastBufferedAtTokens,
+				record.lastBufferedAtTime ? new Date(record.lastBufferedAtTime).toISOString() : null,
+				record.observedTimezone || null,
+				record.metadata ? JSON.stringify(record.metadata) : null,
+				null,
+				now.toISOString(),
+				now.toISOString(),
+				stored.id,
+				id
+			]
+		}], "write");
+		return retired.rowsAffected === 1 ? record : OM_CAS_CONFLICT;
+	}
 	async getObservationalMemory(threadId, resourceId) {
 		try {
 			const lookupKey = this.getOMKey(threadId, resourceId);
-			const result = await this.#client.execute({
-				sql: `SELECT * FROM "${OM_TABLE}" WHERE "lookupKey" = ? ORDER BY "generationCount" DESC LIMIT 1`,
-				args: [lookupKey]
-			});
-			if (!result.rows || result.rows.length === 0) return null;
-			return this.parseOMRow(result.rows[0]);
+			return (await this.#readOMHeadRow(lookupKey))?.record ?? null;
 		} catch (error) {
 			throw new MastraError({
 				id: createStorageErrorId("LIBSQL", "GET_OBSERVATIONAL_MEMORY", "FAILED"),
@@ -10664,9 +10964,9 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 	}
 	async initializeObservationalMemory(input) {
 		try {
+			const lookupKey = this.getOMKey(input.threadId, input.resourceId);
 			const id = crypto.randomUUID();
 			const now = /* @__PURE__ */ new Date();
-			const lookupKey = this.getOMKey(input.threadId, input.resourceId);
 			const record = {
 				id,
 				scope: input.scope,
@@ -10688,45 +10988,52 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 				lastBufferedAtTokens: 0,
 				lastBufferedAtTime: null,
 				config: input.config,
-				observedTimezone: input.observedTimezone
+				observedTimezone: input.observedTimezone,
+				supersededBy: null
 			};
-			await this.#write("initializeObservationalMemory", () => this.#client.execute({
-				sql: `INSERT INTO "${OM_TABLE}" (
+			return await this.#withOMCas("INITIALIZE_OBSERVATIONAL_MEMORY", async () => {
+				const existing = (await this.#readOMHeadRow(lookupKey))?.record ?? null;
+				if (existing) return existing;
+				if ((await this.#client.execute({
+					sql: `INSERT INTO "${OM_TABLE}" (
             id, "lookupKey", scope, "resourceId", "threadId",
             "activeObservations", "activeObservationsPendingUpdate",
             "originType", config, "generationCount", "lastObservedAt", "lastReflectionAt",
             "pendingMessageTokens", "totalTokensObserved", "observationTokenCount",
             "isObserving", "isReflecting", "isBufferingObservation", "isBufferingReflection", "lastBufferedAtTokens", "lastBufferedAtTime",
             "observedTimezone", "createdAt", "updatedAt"
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-				args: [
-					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,
-					now.toISOString(),
-					now.toISOString()
-				]
-			}));
-			return record;
+          ) SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+          WHERE NOT EXISTS (SELECT 1 FROM "${OM_TABLE}" WHERE "lookupKey" = ? AND "supersededBy" IS NULL)`,
+					args: [
+						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,
+						now.toISOString(),
+						now.toISOString(),
+						lookupKey
+					]
+				})).rowsAffected === 1) return record;
+				return (await this.#readOMHeadRow(lookupKey))?.record ?? OM_CAS_CONFLICT;
+			});
 		} catch (error) {
 			throw new MastraError({
 				id: createStorageErrorId("LIBSQL", "INITIALIZE_OBSERVATIONAL_MEMORY", "FAILED"),
@@ -10753,8 +11060,8 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
             "reflectedObservationLineCount",
             "isObserving", "isReflecting", "isBufferingObservation", "isBufferingReflection",
             "lastBufferedAtTokens", "lastBufferedAtTime",
-            "observedTimezone", metadata, "createdAt", "updatedAt"
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            "observedTimezone", metadata, "supersededBy", "createdAt", "updatedAt"
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 				args: [
 					record.id,
 					lookupKey,
@@ -10785,6 +11092,7 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 					record.lastBufferedAtTime ? record.lastBufferedAtTime.toISOString() : null,
 					record.observedTimezone || null,
 					record.metadata ? JSON.stringify(record.metadata) : null,
+					record.supersededBy ?? null,
 					record.createdAt.toISOString(),
 					record.updatedAt.toISOString()
 				]
@@ -10803,11 +11111,36 @@ var MemoryLibSQL = class MemoryLibSQL extends 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;
-			if ((await this.#fencedWrite("updateActiveObservations", this.#runFenceCheck(void 0, "updateActiveObservations"), (writer) => writer.execute({
-				sql: `UPDATE "${OM_TABLE}" SET
+			return await this.#withOMCas("UPDATE_ACTIVE_OBSERVATIONS", async (attemptIndex, check) => {
+				const row = await this.#readOMRow(input.id, check);
+				if (!row) {
+					if (this.#mayBeUnsynced(attemptIndex)) return OM_CAS_CONFLICT;
+					throw new MastraError({
+						id: createStorageErrorId("LIBSQL", "UPDATE_ACTIVE_OBSERVATIONS", "NOT_FOUND"),
+						text: `Observational memory record not found: ${input.id}`,
+						domain: ErrorDomain.STORAGE,
+						category: ErrorCategory.THIRD_PARTY,
+						details: { id: input.id }
+					});
+				}
+				const stored = row.record;
+				if (stored.supersededBy) return {
+					applied: false,
+					reason: "retired"
+				};
+				if (input.expectedActiveObservations !== void 0 && input.expectedActiveObservations !== stored.activeObservations) return {
+					applied: false,
+					reason: "conflict"
+				};
+				const lastObservedAt = maxObservationCursor(stored.lastObservedAt, input.lastObservedAt);
+				return (await this.#client.execute({
+					sql: `UPDATE "${OM_TABLE}" SET
             "activeObservations" = ?,
             "lastObservedAt" = ?,
             "pendingMessageTokens" = 0,
@@ -10815,23 +11148,19 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
             "totalTokensObserved" = "totalTokensObserved" + ?,
             "observedMessageIds" = ?,
             "updatedAt" = ?
-          WHERE id = ?`,
-				args: [
-					input.observations,
-					input.lastObservedAt.toISOString(),
-					input.tokenCount,
-					input.tokenCount,
-					observedMessageIdsJson,
-					now.toISOString(),
-					input.id
-				]
-			}))).rowsAffected === 0) throw new MastraError({
-				id: createStorageErrorId("LIBSQL", "UPDATE_ACTIVE_OBSERVATIONS", "NOT_FOUND"),
-				text: `Observational memory record not found: ${input.id}`,
-				domain: ErrorDomain.STORAGE,
-				category: ErrorCategory.THIRD_PARTY,
-				details: { id: input.id }
-			});
+          WHERE id = ? AND ${row.guard.sql}`,
+					args: [
+						input.observations,
+						lastObservedAt.toISOString(),
+						input.tokenCount,
+						input.tokenCount,
+						observedMessageIdsJson,
+						now.toISOString(),
+						input.id,
+						...row.guard.args
+					]
+				})).rowsAffected === 1 ? { applied: true } : OM_CAS_CONFLICT;
+			}, "commitActiveObservations");
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
 			throw new MastraError({
@@ -10844,19 +11173,23 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 	}
 	async createReflectionGeneration(input) {
 		try {
-			const check = this.#runFenceCheck(void 0, "createReflectionGeneration");
-			return await this.#write("createReflectionGeneration", async () => {
-				const tx = await this.#client.transaction("write");
-				try {
-					if (check) await assertRunFence(tx, check);
-					const record = await this.#insertReflectionGeneration(tx, input);
-					await tx.commit();
-					return record;
-				} catch (error) {
-					if (!tx.closed) await tx.rollback();
-					throw error;
-				}
-			});
+			return await this.#withOMCas("CREATE_REFLECTION_GENERATION", async (attemptIndex, check) => {
+				const { currentRecord } = input;
+				const row = await this.#readOMRow(currentRecord.id, check);
+				if (!row) return this.#mayBeUnsynced(attemptIndex) ? OM_CAS_CONFLICT : currentRecord;
+				const stored = row.record;
+				if (stored.supersededBy) return (await this.#resolveLiveOMRow(row, check)).record;
+				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.#rollOverObservationalMemory(row, plan.observations, plan.tokenCount, input.newRecordId);
+			}, "createReflectionGeneration");
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
 			throw new MastraError({
@@ -10867,79 +11200,6 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 			}, error);
 		}
 	}
-	/**
-	* Inserts a new reflection-generation row. Called inside a locked write
-	* transaction — either from {@link createReflectionGeneration} (standalone)
-	* or from {@link swapBufferedReflectionToActive} (as part of a compound
-	* swap). Must not acquire the write lock itself; the caller owns it.
-	*/
-	async #insertReflectionGeneration(tx, input) {
-		const id = 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
-		};
-		await tx.execute({
-			sql: `INSERT INTO "${OM_TABLE}" (
-        id, "lookupKey", scope, "resourceId", "threadId",
-        "activeObservations", "activeObservationsPendingUpdate",
-        "originType", config, "generationCount", "lastObservedAt", "lastReflectionAt",
-        "pendingMessageTokens", "totalTokensObserved", "observationTokenCount",
-        "isObserving", "isReflecting", "isBufferingObservation", "isBufferingReflection", "lastBufferedAtTokens", "lastBufferedAtTime",
-        "observedTimezone", metadata, "createdAt", "updatedAt"
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-			args: [
-				id,
-				lookupKey,
-				record.scope,
-				record.resourceId,
-				record.threadId || null,
-				input.reflection,
-				null,
-				"reflection",
-				JSON.stringify(record.config),
-				input.currentRecord.generationCount + 1,
-				record.lastObservedAt?.toISOString() || null,
-				now.toISOString(),
-				record.pendingMessageTokens,
-				record.totalTokensObserved,
-				record.observationTokenCount,
-				false,
-				false,
-				false,
-				false,
-				0,
-				null,
-				record.observedTimezone || null,
-				record.metadata ? JSON.stringify(record.metadata) : null,
-				now.toISOString(),
-				now.toISOString()
-			]
-		});
-		return record;
-	}
 	async setReflectingFlag(id, isReflecting) {
 		try {
 			if ((await this.#write("setReflectingFlag", () => this.#client.execute({
@@ -11006,38 +11266,40 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 	}
 	async setBufferingObservationFlag(id, isBuffering, lastBufferedAtTokens) {
 		try {
-			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			let sql;
-			let args;
-			if (lastBufferedAtTokens !== void 0) {
-				sql = `UPDATE "${OM_TABLE}" SET "isBufferingObservation" = ?, "lastBufferedAtTokens" = ?, "updatedAt" = ? WHERE id = ?`;
-				args = [
-					isBuffering,
-					lastBufferedAtTokens,
-					nowStr,
-					id
-				];
-			} else {
-				sql = `UPDATE "${OM_TABLE}" SET "isBufferingObservation" = ?, "updatedAt" = ? WHERE id = ?`;
-				args = [
-					isBuffering,
-					nowStr,
-					id
-				];
-			}
-			if ((await this.#write("setBufferingObservationFlag", () => this.#client.execute({
-				sql,
-				args
-			}))).rowsAffected === 0) throw new MastraError({
-				id: createStorageErrorId("LIBSQL", "SET_BUFFERING_OBSERVATION_FLAG", "NOT_FOUND"),
-				text: `Observational memory record not found: ${id}`,
-				domain: ErrorDomain.STORAGE,
-				category: ErrorCategory.THIRD_PARTY,
-				details: {
-					id,
-					isBuffering,
-					lastBufferedAtTokens: lastBufferedAtTokens ?? null
+			await this.#withOMCas("SET_BUFFERING_OBSERVATION_FLAG", async (attemptIndex) => {
+				const row = await this.#readOMRow(id);
+				if (!row) {
+					if (this.#mayBeUnsynced(attemptIndex)) return OM_CAS_CONFLICT;
+					throw new MastraError({
+						id: createStorageErrorId("LIBSQL", "SET_BUFFERING_OBSERVATION_FLAG", "NOT_FOUND"),
+						text: `Observational memory record not found: ${id}`,
+						domain: ErrorDomain.STORAGE,
+						category: ErrorCategory.THIRD_PARTY,
+						details: {
+							id,
+							isBuffering,
+							lastBufferedAtTokens: lastBufferedAtTokens ?? null
+						}
+					});
 				}
+				const target = (await this.#resolveLiveOMRow(row)).record;
+				const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+				return (lastBufferedAtTokens !== void 0 ? await this.#client.execute({
+					sql: `UPDATE "${OM_TABLE}" SET "isBufferingObservation" = ?, "lastBufferedAtTokens" = ?, "updatedAt" = ? WHERE id = ? AND "supersededBy" IS NULL`,
+					args: [
+						isBuffering,
+						lastBufferedAtTokens,
+						nowStr,
+						target.id
+					]
+				}) : await this.#client.execute({
+					sql: `UPDATE "${OM_TABLE}" SET "isBufferingObservation" = ?, "updatedAt" = ? WHERE id = ? AND "supersededBy" IS NULL`,
+					args: [
+						isBuffering,
+						nowStr,
+						target.id
+					]
+				})).rowsAffected === 1 ? void 0 : OM_CAS_CONFLICT;
 			});
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
@@ -11106,25 +11368,30 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 	}
 	async setPendingMessageTokens(id, tokenCount) {
 		try {
-			if ((await this.#write("setPendingMessageTokens", () => this.#client.execute({
-				sql: `UPDATE "${OM_TABLE}" SET 
-            "pendingMessageTokens" = ?, 
-            "updatedAt" = ? 
-          WHERE id = ?`,
-				args: [
-					tokenCount,
-					(/* @__PURE__ */ new Date()).toISOString(),
-					id
-				]
-			}))).rowsAffected === 0) throw new MastraError({
-				id: createStorageErrorId("LIBSQL", "SET_PENDING_MESSAGE_TOKENS", "NOT_FOUND"),
-				text: `Observational memory record not found: ${id}`,
-				domain: ErrorDomain.STORAGE,
-				category: ErrorCategory.THIRD_PARTY,
-				details: {
-					id,
-					tokenCount
+			await this.#withOMCas("SET_PENDING_MESSAGE_TOKENS", async (attemptIndex) => {
+				const row = await this.#readOMRow(id);
+				if (!row) {
+					if (this.#mayBeUnsynced(attemptIndex)) return OM_CAS_CONFLICT;
+					throw new MastraError({
+						id: createStorageErrorId("LIBSQL", "SET_PENDING_MESSAGE_TOKENS", "NOT_FOUND"),
+						text: `Observational memory record not found: ${id}`,
+						domain: ErrorDomain.STORAGE,
+						category: ErrorCategory.THIRD_PARTY,
+						details: {
+							id,
+							tokenCount
+						}
+					});
 				}
+				const target = (await this.#resolveLiveOMRow(row)).record;
+				return (await this.#client.execute({
+					sql: `UPDATE "${OM_TABLE}" SET "pendingMessageTokens" = ?, "updatedAt" = ? WHERE id = ? AND "supersededBy" IS NULL`,
+					args: [
+						tokenCount,
+						(/* @__PURE__ */ new Date()).toISOString(),
+						target.id
+					]
+				})).rowsAffected === 1 ? void 0 : OM_CAS_CONFLICT;
 			});
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
@@ -11141,36 +11408,33 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 	}
 	async updateObservationalMemoryConfig(input) {
 		try {
-			await this.#write("updateObservationalMemoryConfig", async () => {
-				const tx = await this.#client.transaction("write");
-				try {
-					const selectResult = await tx.execute({
-						sql: `SELECT config FROM "${OM_TABLE}" WHERE id = ?`,
-						args: [input.id]
-					});
-					if (selectResult.rows.length === 0) throw new MastraError({
+			await this.#withOMCas("UPDATE_OM_CONFIG", async (attemptIndex) => {
+				const selectResult = await this.#client.execute({
+					sql: `SELECT config FROM "${OM_TABLE}" WHERE id = ?`,
+					args: [input.id]
+				});
+				if (selectResult.rows.length === 0) {
+					if (this.#mayBeUnsynced(attemptIndex)) return OM_CAS_CONFLICT;
+					throw new MastraError({
 						id: createStorageErrorId("LIBSQL", "UPDATE_OM_CONFIG", "NOT_FOUND"),
 						text: `Observational memory record not found: ${input.id}`,
 						domain: ErrorDomain.STORAGE,
 						category: ErrorCategory.THIRD_PARTY,
 						details: { id: input.id }
 					});
-					const row = selectResult.rows[0];
-					const existing = row.config ? JSON.parse(row.config) : {};
-					const merged = this.deepMergeConfig(existing, input.config);
-					await tx.execute({
-						sql: `UPDATE "${OM_TABLE}" SET config = ?, "updatedAt" = ? WHERE id = ?`,
-						args: [
-							JSON.stringify(merged),
-							(/* @__PURE__ */ new Date()).toISOString(),
-							input.id
-						]
-					});
-					await tx.commit();
-				} catch (error) {
-					if (!tx.closed) await tx.rollback();
-					throw error;
 				}
+				const row = selectResult.rows[0];
+				const existing = row.config ? JSON.parse(row.config) : {};
+				const merged = this.deepMergeConfig(existing, input.config);
+				return (await this.#client.execute({
+					sql: `UPDATE "${OM_TABLE}" SET config = ?, "updatedAt" = ? WHERE id = ? AND config IS ?`,
+					args: [
+						JSON.stringify(merged),
+						(/* @__PURE__ */ new Date()).toISOString(),
+						input.id,
+						row.config ?? null
+					]
+				})).rowsAffected === 1 ? void 0 : OM_CAS_CONFLICT;
 			});
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
@@ -11183,78 +11447,64 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 		}
 	}
 	async updateBufferedObservations(input) {
+		await this.appendBufferedObservations(input);
+	}
+	async appendBufferedObservations(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			const check = this.#runFenceCheck(void 0, "updateBufferedObservations");
-			await this.#write("updateBufferedObservations", async () => {
-				const tx = await this.#client.transaction("write");
-				try {
-					if (check) await assertRunFence(tx, check);
-					const current = await tx.execute({
-						sql: `SELECT "bufferedObservationChunks" FROM "${OM_TABLE}" WHERE id = ?`,
-						args: [input.id]
-					});
-					if (!current.rows || current.rows.length === 0) throw new MastraError({
-						id: createStorageErrorId("LIBSQL", "UPDATE_BUFFERED_OBSERVATIONS", "NOT_FOUND"),
-						text: `Observational memory record not found: ${input.id}`,
-						domain: ErrorDomain.STORAGE,
-						category: ErrorCategory.THIRD_PARTY,
-						details: { id: input.id }
-					});
-					const row = current.rows[0];
-					let existingChunks = [];
-					if (row.bufferedObservationChunks) try {
-						const parsed = typeof row.bufferedObservationChunks === "string" ? JSON.parse(row.bufferedObservationChunks) : row.bufferedObservationChunks;
-						existingChunks = Array.isArray(parsed) ? parsed : [];
-					} catch {
-						existingChunks = [];
-					}
-					if (existingChunks.some((existing) => existing.cycleId === input.chunk.cycleId)) {
-						await tx.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
-					};
-					const newChunks = [...existingChunks, newChunk];
-					const lastBufferedAtTime = input.lastBufferedAtTime ? input.lastBufferedAtTime.toISOString() : null;
-					if ((await tx.execute({
-						sql: `UPDATE "${OM_TABLE}" SET
-              "bufferedObservationChunks" = ?,
-              "lastBufferedAtTime" = COALESCE(?, "lastBufferedAtTime"),
-              "updatedAt" = ?
-            WHERE id = ?`,
-						args: [
-							JSON.stringify(newChunks),
-							lastBufferedAtTime,
-							nowStr,
-							input.id
-						]
-					})).rowsAffected === 0) throw new MastraError({
+			return await this.#withOMCas("UPDATE_BUFFERED_OBSERVATIONS", async (attemptIndex, check) => {
+				const row = await this.#readOMRow(input.id, check);
+				if (!row) {
+					if (this.#mayBeUnsynced(attemptIndex)) return OM_CAS_CONFLICT;
+					throw new MastraError({
 						id: createStorageErrorId("LIBSQL", "UPDATE_BUFFERED_OBSERVATIONS", "NOT_FOUND"),
 						text: `Observational memory record not found: ${input.id}`,
 						domain: ErrorDomain.STORAGE,
 						category: ErrorCategory.THIRD_PARTY,
 						details: { id: input.id }
 					});
-					await tx.commit();
-				} catch (error) {
-					if (!tx.closed) await tx.rollback();
-					throw error;
 				}
-			});
+				const targetRow = await this.#resolveLiveOMRow(row, check);
+				const target = targetRow.record;
+				const existingChunks = Array.isArray(target.bufferedObservationChunks) ? target.bufferedObservationChunks : [];
+				if (existingChunks.some((existing) => existing.cycleId === input.chunk.cycleId) || isBufferedChunkCoveredByCursor(input.chunk.lastObservedAt, target.lastObservedAt)) return {
+					persisted: false,
+					recordId: target.id
+				};
+				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
+				};
+				const lastBufferedAtTime = maxObservationCursor(target.lastBufferedAtTime, input.lastBufferedAtTime);
+				return (await this.#client.execute({
+					sql: `UPDATE "${OM_TABLE}" SET
+            "bufferedObservationChunks" = ?,
+            "lastBufferedAtTime" = ?,
+            "updatedAt" = ?
+          WHERE id = ? AND ${targetRow.guard.sql}`,
+					args: [
+						JSON.stringify([...existingChunks, newChunk]),
+						lastBufferedAtTime ? lastBufferedAtTime.toISOString() : null,
+						nowStr,
+						target.id,
+						...targetRow.guard.args
+					]
+				})).rowsAffected === 1 ? {
+					persisted: true,
+					recordId: target.id
+				} : OM_CAS_CONFLICT;
+			}, "appendBufferedObservations");
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
 			throw new MastraError({
@@ -11268,144 +11518,137 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 	async swapBufferedToActive(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			const check = this.#runFenceCheck(void 0, "swapBufferedToActive");
-			return await this.#write("swapBufferedToActive", async () => {
-				const tx = await this.#client.transaction("write");
-				try {
-					if (check) await assertRunFence(tx, check);
-					const current = await tx.execute({
-						sql: `SELECT * FROM "${OM_TABLE}" WHERE id = ?`,
-						args: [input.id]
-					});
-					if (!current.rows || current.rows.length === 0) throw new MastraError({
+			return await this.#withOMCas("SWAP_BUFFERED_TO_ACTIVE", async (attemptIndex, check) => {
+				const current = await this.#client.execute({
+					sql: `SELECT * FROM "${OM_TABLE}" WHERE id = ?`,
+					args: [input.id]
+				});
+				if (!current.rows || current.rows.length === 0) {
+					if (this.#mayBeUnsynced(attemptIndex)) return OM_CAS_CONFLICT;
+					throw new MastraError({
 						id: createStorageErrorId("LIBSQL", "SWAP_BUFFERED_TO_ACTIVE", "NOT_FOUND"),
 						text: `Observational memory record not found: ${input.id}`,
 						domain: ErrorDomain.STORAGE,
 						category: ErrorCategory.THIRD_PARTY,
 						details: { id: input.id }
 					});
-					const row = current.rows[0];
-					let chunks = [];
-					if (row.bufferedObservationChunks) try {
-						const parsed = typeof row.bufferedObservationChunks === "string" ? JSON.parse(row.bufferedObservationChunks) : row.bufferedObservationChunks;
-						chunks = Array.isArray(parsed) ? parsed : [];
-					} catch {
-						chunks = [];
-					}
-					if (chunks.length === 0) {
-						await tx.commit();
-						return {
-							chunksActivated: 0,
-							messageTokensActivated: 0,
-							observationTokensActivated: 0,
-							messagesActivated: 0,
-							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;
-							}
-						} else if (cumulativeMessageTokens > bestUnderTokens) {
-							bestUnderBoundary = boundary;
-							bestUnderTokens = cumulativeMessageTokens;
+				}
+				const row = current.rows[0];
+				const guard = this.#toOMRow(current, check).guard;
+				const emptyResult = {
+					chunksActivated: 0,
+					messageTokensActivated: 0,
+					observationTokensActivated: 0,
+					messagesActivated: 0,
+					activatedCycleIds: [],
+					activatedMessageIds: []
+				};
+				if (row.supersededBy) return {
+					...emptyResult,
+					retired: true
+				};
+				let persistedChunks = [];
+				if (row.bufferedObservationChunks) try {
+					const parsed = typeof row.bufferedObservationChunks === "string" ? JSON.parse(row.bufferedObservationChunks) : row.bufferedObservationChunks;
+					persistedChunks = Array.isArray(parsed) ? parsed : [];
+				} catch {
+					persistedChunks = [];
+				}
+				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;
 					}
-					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((id) => !!id);
-					const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
-					const latestChunk = activatedChunks[activatedChunks.length - 1];
-					const lastObservedAt = input.lastObservedAt ?? (latestChunk?.lastObservedAt ? new Date(latestChunk.lastObservedAt) : /* @__PURE__ */ new Date());
-					const lastObservedAtStr = lastObservedAt.toISOString();
-					const existingActive = row.activeObservations || "";
-					const existingTokenCount = Number(row.observationTokenCount || 0);
-					const boundary = `\n\n--- message boundary (${lastObservedAt.toISOString()}) ---\n\n`;
-					const newActive = existingActive ? `${existingActive}${boundary}${activatedContent}` : activatedContent;
-					const newTokenCount = existingTokenCount + activatedTokens;
-					const existingPending = Number(row.pendingMessageTokens || 0);
-					const newPending = Math.max(0, existingPending - activatedMessageTokens);
-					const updateResult = await tx.execute({
-						sql: `UPDATE "${OM_TABLE}" SET
+				}
+				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((id) => !!id);
+				const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
+				const latestChunk = activatedChunks[activatedChunks.length - 1];
+				const lastObservedAt = input.lastObservedAt ?? (latestChunk?.lastObservedAt ? new Date(latestChunk.lastObservedAt) : /* @__PURE__ */ new Date());
+				const lastObservedAtStr = maxObservationCursor(row.lastObservedAt, lastObservedAt).toISOString();
+				const existingActive = row.activeObservations || "";
+				const existingTokenCount = Number(row.observationTokenCount || 0);
+				const boundary = `\n\n--- message boundary (${lastObservedAt.toISOString()}) ---\n\n`;
+				const newActive = existingActive ? `${existingActive}${boundary}${activatedContent}` : activatedContent;
+				const newTokenCount = existingTokenCount + activatedTokens;
+				const existingPending = Number(row.pendingMessageTokens || 0);
+				const newPending = Math.max(0, existingPending - activatedMessageTokens);
+				if ((await this.#client.execute({
+					sql: `UPDATE "${OM_TABLE}" SET
               "activeObservations" = ?,
               "observationTokenCount" = ?,
               "pendingMessageTokens" = ?,
               "bufferedObservationChunks" = ?,
               "lastObservedAt" = ?,
               "updatedAt" = ?
-            WHERE id = ?
-              AND "bufferedObservationChunks" IS NOT NULL
-              AND "bufferedObservationChunks" != '[]'`,
-						args: [
-							newActive,
-							newTokenCount,
-							newPending,
-							remainingChunks.length > 0 ? JSON.stringify(remainingChunks) : null,
-							lastObservedAtStr,
-							nowStr,
-							input.id
-						]
-					});
-					await tx.commit();
-					if (updateResult.rowsAffected === 0) return {
-						chunksActivated: 0,
-						messageTokensActivated: 0,
-						observationTokensActivated: 0,
-						messagesActivated: 0,
-						activatedCycleIds: [],
-						activatedMessageIds: []
-					};
-					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
-					};
-				} catch (error) {
-					if (!tx.closed) await tx.rollback();
-					throw error;
-				}
-			});
+            WHERE id = ? AND ${guard.sql}`,
+					args: [
+						newActive,
+						newTokenCount,
+						newPending,
+						remainingChunks.length > 0 ? JSON.stringify(remainingChunks) : null,
+						lastObservedAtStr,
+						nowStr,
+						input.id,
+						...guard.args
+					]
+				})).rowsAffected === 0) return OM_CAS_CONFLICT;
+				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) {
 			if (error instanceof MastraError) throw error;
 			throw new MastraError({
@@ -11459,57 +11702,27 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 	}
 	async swapBufferedReflectionToActive(input) {
 		try {
-			const check = this.#runFenceCheck(void 0, "swapBufferedReflectionToActive");
-			return await this.#write("swapBufferedReflectionToActive", async () => {
-				const tx = await this.#client.transaction("write");
-				try {
-					if (check) await assertRunFence(tx, check);
-					const current = await tx.execute({
-						sql: `SELECT * FROM "${OM_TABLE}" WHERE id = ?`,
-						args: [input.currentRecord.id]
-					});
-					if (!current.rows || current.rows.length === 0) throw new MastraError({
-						id: createStorageErrorId("LIBSQL", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "NOT_FOUND"),
-						text: `Observational memory record not found: ${input.currentRecord.id}`,
-						domain: ErrorDomain.STORAGE,
-						category: ErrorCategory.THIRD_PARTY,
-						details: { id: input.currentRecord.id }
-					});
-					const row = current.rows[0];
-					const bufferedReflection = row.bufferedReflection || "";
-					const reflectedLineCount = Number(row.reflectedObservationLineCount || 0);
-					if (!bufferedReflection) throw new MastraError({
-						id: createStorageErrorId("LIBSQL", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "NO_CONTENT"),
-						text: "No buffered reflection to swap",
-						domain: ErrorDomain.STORAGE,
-						category: 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.#insertReflectionGeneration(tx, {
-						currentRecord: input.currentRecord,
-						reflection: newObservations,
-						tokenCount: input.tokenCount
-					});
-					const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-					await tx.execute({
-						sql: `UPDATE "${OM_TABLE}" SET
-              "bufferedReflection" = NULL,
-              "bufferedReflectionTokens" = NULL,
-              "bufferedReflectionInputTokens" = NULL,
-              "reflectedObservationLineCount" = NULL,
-              "updatedAt" = ?
-            WHERE id = ?`,
-						args: [nowStr, input.currentRecord.id]
-					});
-					await tx.commit();
-					return newRecord;
-				} catch (error) {
-					if (!tx.closed) await tx.rollback();
-					throw error;
-				}
-			});
+			return await this.#withOMCas("SWAP_BUFFERED_REFLECTION_TO_ACTIVE", async (attemptIndex, check) => {
+				const { currentRecord } = input;
+				const row = await this.#readOMRow(currentRecord.id, check);
+				if (!row) return this.#mayBeUnsynced(attemptIndex) ? OM_CAS_CONFLICT : currentRecord;
+				const stored = row.record;
+				if (stored.supersededBy) return (await this.#resolveLiveOMRow(row, check)).record;
+				const bufferedReflection = stored.bufferedReflection || "";
+				if (!bufferedReflection) throw new MastraError({
+					id: createStorageErrorId("LIBSQL", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "NO_CONTENT"),
+					text: "No buffered reflection to swap",
+					domain: ErrorDomain.STORAGE,
+					category: 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.#rollOverObservationalMemory(row, newObservations, tokenCount, input.newRecordId);
+			}, "swapBufferedReflectionToActive");
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
 			throw new MastraError({
@@ -16428,6 +16641,7 @@ var LibSQLStore = class extends MastraCompositeStore {
 		}
 		const domainConfig = {
 			client: this.client,
+			embeddedReplica: "url" in config && !!config.syncUrl,
 			maxRetries: this.maxRetries,
 			initialBackoffMs: this.initialBackoffMs
 		};