@mastra/pg 1.31.0 → 1.31.1-alpha.1

package/dist/index.js

@@ -11587,6 +11587,92 @@ var MCPServersPG = class MCPServersPG 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/db/run-fencing.ts
 /**
 * Epoch milliseconds on the database clock. `clock_timestamp()` rather than
@@ -11632,6 +11718,8 @@ const OM_TABLE = "mastra_observational_memory";
 * one wins so the active record stays stable across reads.
 */
 const OM_GENERATION_ORDER = `"generationCount" DESC, "createdAt" ASC, id ASC`;
+/** Lifecycle writes aimed at a retired record follow it to the head at most this many times. */
+const OM_MAX_HEAD_HOPS = 3;
 const POSTGRES_MAX_BIND_PARAMETERS = 65535;
 const MESSAGE_INSERT_BIND_PARAMETERS = 8;
 const MAX_MESSAGES_PER_INSERT = Math.floor(POSTGRES_MAX_BIND_PARAMETERS / MESSAGE_INSERT_BIND_PARAMETERS);
@@ -11659,7 +11747,8 @@ const OM_MIGRATION_COLUMNS = [
 	"isBufferingReflection",
 	"lastBufferedAtTokens",
 	"lastBufferedAtTime",
-	"metadata"
+	"metadata",
+	"supersededBy"
 ];
 /**
 * The OM schema is imported statically above: the peer dependency range
@@ -11669,7 +11758,10 @@ const OM_MIGRATION_COLUMNS = [
 * bundle to a shim that always throws, and the silent catch meant the
 * published ESM build skipped creating the OM table entirely (#18954).
 */
-const _omTableSchema = OBSERVATIONAL_MEMORY_TABLE_SCHEMA;
+const _omTableSchema = {
+	...OBSERVATIONAL_MEMORY_TABLE_SCHEMA,
+	[OM_TABLE]: withObservationalMemoryLifecycleColumns(OBSERVATIONAL_MEMORY_TABLE_SCHEMA?.[OM_TABLE])
+};
 function getSchemaName$3(schema) {
 	return schema ? `"${schema}"` : "\"public\"";
 }
@@ -11693,6 +11785,14 @@ function inPlaceholders(count, startIndex = 1) {
 function toUtcISOString(date) {
 	return date.toISOString();
 }
+/**
+* Read a `timestamp without time zone` column written from a UTC ISO string. Postgres drops the
+* zone on input, so the stored wall time is UTC; node-postgres parses it as local time.
+*/
+function utcFromTimestampWithoutTimeZone(value) {
+	if (value instanceof Date) return new Date(Date.UTC(value.getFullYear(), value.getMonth(), value.getDate(), value.getHours(), value.getMinutes(), value.getSeconds(), value.getMilliseconds()));
+	return new Date(/[zZ]|[+-]\d{2}:?\d{2}$/.test(value) ? value : `${value.replace(" ", "T")}Z`);
+}
 function dedupeMessagesForSave(messages) {
 	const deduped = /* @__PURE__ */ new Map();
 	for (const message of messages) {
@@ -11807,6 +11907,7 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 				schemaName: getSchemaName$3(this.#schema)
 			});
 			await this.#db.createIndexFromStatement("idx_om_lookup_key", `CREATE INDEX IF NOT EXISTS idx_om_lookup_key ON ${omTableName} ("lookupKey")`);
+			await this.#backfillSupersededBy(omTableName);
 		}
 		await this.#db.createTable({
 			tableName: TABLE_MEMORY_RUN_FENCES,
@@ -13404,6 +13505,115 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 	async #getLatestOMRow(client, tableName, lookupKey) {
 		return client.oneOrNone(`SELECT * FROM ${tableName} WHERE "lookupKey" = $1 ORDER BY ${OM_GENERATION_ORDER} LIMIT 1`, [lookupKey]);
 	}
+	#omTableName() {
+		return getTableName$3({
+			indexName: OM_TABLE,
+			schemaName: getSchemaName$3(this.#schema)
+		});
+	}
+	/** Row-locks one OM record by primary key for the rest of the transaction. */
+	async #lockOMRow(t, tableName, id) {
+		return t.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1 FOR UPDATE`, [id]);
+	}
+	/**
+	* The live, row-locked record a lifecycle write aimed at `row` lands on: `row` itself while
+	* live, otherwise the head of its lookup key (locked, then re-checked — a rollover may retire
+	* it between the head read and the lock).
+	*/
+	async #resolveLiveOMRow(t, tableName, row) {
+		let current = row;
+		for (let hop = 0; current.supersededBy; hop++) {
+			const head = hop < OM_MAX_HEAD_HOPS ? await this.#getLatestOMRow(t, tableName, current.lookupKey) : null;
+			const locked = head && head.id !== current.id ? await this.#lockOMRow(t, tableName, head.id) : null;
+			if (!locked) throw new MastraError({
+				id: createStorageErrorId("PG", "RESOLVE_OBSERVATIONAL_MEMORY_HEAD", "FAILED"),
+				text: `Observational memory record ${row.id} is superseded but no live head was found`,
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { id: row.id }
+			});
+			current = locked;
+		}
+		return current;
+	}
+	/**
+	* 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. One statement: the head's ordering key is part of the condition, and a row the
+	* statement waits on (a head being retired by a concurrent rollover) is re-checked against
+	* `"supersededBy" IS NULL` after that rollover commits.
+	*/
+	async #backfillSupersededBy(tableName) {
+		await this.#db.client.none(`UPDATE ${tableName} AS r SET "supersededBy" = h.id
+      FROM (
+        SELECT DISTINCT ON ("lookupKey") "lookupKey", id, "generationCount", "createdAt"
+        FROM ${tableName}
+        WHERE "lookupKey" IN (
+          SELECT "lookupKey" FROM ${tableName} WHERE "supersededBy" IS NULL GROUP BY "lookupKey" HAVING COUNT(*) > 1
+        )
+        ORDER BY "lookupKey", ${OM_GENERATION_ORDER}
+      ) AS h
+      WHERE r."lookupKey" = h."lookupKey"
+        AND r."supersededBy" IS NULL
+        AND (
+          r."generationCount" < h."generationCount"
+          OR (r."generationCount" = h."generationCount" AND r."createdAt" > h."createdAt")
+          OR (r."generationCount" = h."generationCount" AND r."createdAt" = h."createdAt" AND r.id > h.id)
+        )`);
+	}
+	/**
+	* 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 timezone conversion. Buffered chunks move to the
+	* new generation; the cursor, buffering markers, flags, and counters carry over; buffered
+	* reflection state does not.
+	*/
+	async #rollOverOMRow(t, tableName, storedId, observations, tokenCount, newRecordId) {
+		const id = newRecordId ?? crypto.randomUUID();
+		const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+		const inserted = await t.one(`INSERT INTO ${tableName} (
+        id, "lookupKey", scope, "resourceId", "threadId",
+        "activeObservations", "activeObservationsPendingUpdate",
+        "originType", config, "generationCount", "lastObservedAt", "lastObservedAtZ", "lastReflectionAt", "lastReflectionAtZ",
+        "pendingMessageTokens", "totalTokensObserved", "observationTokenCount", "bufferedObservationChunks",
+        "isObserving", "isReflecting", "isBufferingObservation", "isBufferingReflection", "lastBufferedAtTokens", "lastBufferedAtTime",
+        "observedTimezone", metadata, "supersededBy", "createdAt", "createdAtZ", "updatedAt", "updatedAtZ"
+      )
+      SELECT
+        $1, "lookupKey", scope, "resourceId", "threadId",
+        $2, NULL,
+        'reflection', config, "generationCount" + 1, "lastObservedAt", "lastObservedAtZ", $4, $5,
+        "pendingMessageTokens", "totalTokensObserved", $3, "bufferedObservationChunks",
+        false, false, "isBufferingObservation", false, "lastBufferedAtTokens", "lastBufferedAtTime",
+        "observedTimezone", metadata, NULL, $6, $7, $8, $9
+      FROM ${tableName} WHERE id = $10
+      RETURNING *`, [
+			id,
+			observations,
+			Math.round(tokenCount),
+			nowStr,
+			nowStr,
+			nowStr,
+			nowStr,
+			nowStr,
+			nowStr,
+			storedId
+		]);
+		if ((await t.query(`UPDATE ${tableName} SET "supersededBy" = $1, "bufferedObservationChunks" = NULL, "updatedAt" = $2, "updatedAtZ" = $3
+      WHERE id = $4 AND "supersededBy" IS NULL`, [
+			id,
+			nowStr,
+			nowStr,
+			storedId
+		])).rowCount !== 1) throw new MastraError({
+			id: createStorageErrorId("PG", "CREATE_REFLECTION_GENERATION", "RETIRE_FAILED"),
+			text: `Failed to retire observational memory record ${storedId}`,
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.THIRD_PARTY,
+			details: { id: storedId }
+		});
+		return this.parseOMRow(inserted);
+	}
 	parseOMRow(row) {
 		return {
 			id: row.id,
@@ -13432,11 +13642,12 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 			isBufferingObservation: row.isBufferingObservation === true || row.isBufferingObservation === "true",
 			isBufferingReflection: row.isBufferingReflection === true || row.isBufferingReflection === "true",
 			lastBufferedAtTokens: typeof row.lastBufferedAtTokens === "number" ? row.lastBufferedAtTokens : parseInt(String(row.lastBufferedAtTokens ?? "0"), 10) || 0,
-			lastBufferedAtTime: row.lastBufferedAtTime ? new Date(String(row.lastBufferedAtTime)) : null,
+			lastBufferedAtTime: row.lastBufferedAtTime ? utcFromTimestampWithoutTimeZone(row.lastBufferedAtTime) : null,
 			config: row.config ? typeof row.config === "string" ? JSON.parse(row.config) : row.config : {},
 			metadata: row.metadata ? typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata : void 0,
 			observedMessageIds: row.observedMessageIds ? typeof row.observedMessageIds === "string" ? JSON.parse(row.observedMessageIds) : row.observedMessageIds : void 0,
-			observedTimezone: row.observedTimezone || void 0
+			observedTimezone: row.observedTimezone || void 0,
+			supersededBy: row.supersededBy ?? null
 		};
 	}
 	async getObservationalMemory(threadId, resourceId) {
@@ -13446,7 +13657,7 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 				indexName: OM_TABLE,
 				schemaName: getSchemaName$3(this.#schema)
 			});
-			const result = await this.#getLatestOMRow(this.#db.readClient, tableName, lookupKey);
+			const result = await this.#getLatestOMRow(this.#db.client, tableName, lookupKey);
 			if (!result) return null;
 			return this.parseOMRow(result);
 		} catch (error) {
@@ -13529,9 +13740,9 @@ var MemoryPG = class MemoryPG 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,
@@ -13553,7 +13764,8 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 				lastBufferedAtTokens: 0,
 				lastBufferedAtTime: null,
 				config: input.config,
-				observedTimezone: input.observedTimezone
+				observedTimezone: input.observedTimezone,
+				supersededBy: null
 			};
 			const tableName = getTableName$3({
 				indexName: OM_TABLE,
@@ -13633,8 +13845,8 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
           "reflectedObservationLineCount",
           "isObserving", "isReflecting", "isBufferingObservation", "isBufferingReflection",
           "lastBufferedAtTokens", "lastBufferedAtTime",
-          "observedTimezone", metadata, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ"
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $30, $31, $32, $33, $34, $35)`, [
+          "observedTimezone", metadata, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ", "supersededBy"
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $30, $31, $32, $33, $34, $35, $36)`, [
 				record.id,
 				lookupKey,
 				record.scope,
@@ -13669,7 +13881,8 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 				record.createdAt.toISOString(),
 				record.createdAt.toISOString(),
 				record.updatedAt.toISOString(),
-				record.updatedAt.toISOString()
+				record.updatedAt.toISOString(),
+				record.supersededBy ?? null
 			]);
 		} catch (error) {
 			throw new MastraError({
@@ -13685,41 +13898,55 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 		}
 	}
 	async updateActiveObservations(input) {
+		assertActiveObservationsApplied(await this.commitActiveObservations(input), input.id);
+	}
+	async commitActiveObservations(input) {
 		try {
-			const now = /* @__PURE__ */ new Date();
-			const tableName = getTableName$3({
-				indexName: OM_TABLE,
-				schemaName: getSchemaName$3(this.#schema)
-			});
-			const lastObservedAtStr = input.lastObservedAt.toISOString();
-			const nowStr = now.toISOString();
+			const tableName = this.#omTableName();
+			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
 			const observedMessageIdsJson = input.observedMessageIds ? toPgJson(input.observedMessageIds) : null;
-			if ((await this.#fenced(void 0, "updateActiveObservations", (q) => q.query(`UPDATE ${tableName} SET
-          "activeObservations" = $1,
-          "lastObservedAt" = $2,
-          "lastObservedAtZ" = $3,
-          "pendingMessageTokens" = 0,
-          "observationTokenCount" = $4,
-          "totalTokensObserved" = "totalTokensObserved" + $5,
-          "observedMessageIds" = $6,
-          "updatedAt" = $7,
-          "updatedAtZ" = $8
-        WHERE id = $9`, [
-				input.observations,
-				lastObservedAtStr,
-				lastObservedAtStr,
-				Math.round(input.tokenCount),
-				Math.round(input.tokenCount),
-				observedMessageIdsJson,
-				nowStr,
-				nowStr,
-				input.id
-			]))).rowCount === 0) throw new MastraError({
-				id: createStorageErrorId("PG", "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 fence = resolveRunFence(this, void 0);
+			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runFencesTable(), fence, "commitActiveObservations");
+				const row = await this.#lockOMRow(t, tableName, input.id);
+				if (!row) throw new MastraError({
+					id: createStorageErrorId("PG", "UPDATE_ACTIVE_OBSERVATIONS", "NOT_FOUND"),
+					text: `Observational memory record not found: ${input.id}`,
+					domain: ErrorDomain.STORAGE,
+					category: ErrorCategory.THIRD_PARTY,
+					details: { id: input.id }
+				});
+				if (row.supersededBy) return {
+					applied: false,
+					reason: "retired"
+				};
+				if (input.expectedActiveObservations !== void 0 && input.expectedActiveObservations !== (row.activeObservations || "")) return {
+					applied: false,
+					reason: "conflict"
+				};
+				const lastObservedAtStr = maxObservationCursor(row.lastObservedAtZ, input.lastObservedAt).toISOString();
+				await t.none(`UPDATE ${tableName} SET
+            "activeObservations" = $1,
+            "lastObservedAt" = $2,
+            "lastObservedAtZ" = $3,
+            "pendingMessageTokens" = 0,
+            "observationTokenCount" = $4,
+            "totalTokensObserved" = "totalTokensObserved" + $5,
+            "observedMessageIds" = $6,
+            "updatedAt" = $7,
+            "updatedAtZ" = $8
+          WHERE id = $9`, [
+					input.observations,
+					lastObservedAtStr,
+					lastObservedAtStr,
+					Math.round(input.tokenCount),
+					Math.round(input.tokenCount),
+					observedMessageIdsJson,
+					nowStr,
+					nowStr,
+					input.id
+				]);
+				return { applied: true };
 			});
 		} catch (error) {
 			if (error instanceof MastraError || isRunFenceConflictError(error)) throw error;
@@ -13733,18 +13960,27 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 	}
 	async createReflectionGeneration(input) {
 		try {
-			const lookupKey = this.getOMKey(input.currentRecord.threadId, input.currentRecord.resourceId);
-			const tableName = getTableName$3({
-				indexName: OM_TABLE,
-				schemaName: getSchemaName$3(this.#schema)
-			});
+			const { currentRecord } = input;
+			const lookupKey = this.getOMKey(currentRecord.threadId, currentRecord.resourceId);
+			const tableName = this.#omTableName();
 			return await this.#withOMLookupKeyLock(tableName, lookupKey, async (t) => {
-				const newer = await this.#getNewerOMGeneration(t, tableName, lookupKey, input.currentRecord.generationCount);
-				if (newer) return newer;
-				return this.#insertReflectionGeneration(t, tableName, lookupKey, input);
+				const row = await this.#lockOMRow(t, tableName, currentRecord.id);
+				if (!row) return currentRecord;
+				if (row.supersededBy) return this.parseOMRow(await this.#resolveLiveOMRow(t, tableName, 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(t, tableName, stored.id, plan.observations, plan.tokenCount, input.newRecordId);
 			}, "createReflectionGeneration");
 		} catch (error) {
-			if (isRunFenceConflictError(error)) throw error;
+			if (error instanceof MastraError) throw error;
 			throw new MastraError({
 				id: createStorageErrorId("PG", "CREATE_REFLECTION_GENERATION", "FAILED"),
 				domain: ErrorDomain.STORAGE,
@@ -13753,84 +13989,6 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 			}, error);
 		}
 	}
-	/**
-	* Returns the active record when another writer already created a generation
-	* after `generationCount`. Reflecting from the older generation again would
-	* add a second record with the same generation.
-	*/
-	async #getNewerOMGeneration(t, tableName, lookupKey, generationCount) {
-		const latest = await this.#getLatestOMRow(t, tableName, lookupKey);
-		return latest && Number(latest.generationCount) > generationCount ? this.parseOMRow(latest) : null;
-	}
-	async #insertReflectionGeneration(t, tableName, lookupKey, input) {
-		const id = crypto.randomUUID();
-		const now = /* @__PURE__ */ new Date();
-		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 nowStr = now.toISOString();
-		const lastObservedAtStr = record.lastObservedAt?.toISOString() || null;
-		await t.none(`INSERT INTO ${tableName} (
-        id, "lookupKey", scope, "resourceId", "threadId",
-        "activeObservations", "activeObservationsPendingUpdate",
-        "originType", config, "generationCount", "lastObservedAt", "lastObservedAtZ", "lastReflectionAt", "lastReflectionAtZ",
-        "pendingMessageTokens", "totalTokensObserved", "observationTokenCount",
-        "isObserving", "isReflecting", "isBufferingObservation", "isBufferingReflection", "lastBufferedAtTokens", "lastBufferedAtTime",
-        "observedTimezone", metadata, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ"
-      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29)`, [
-			id,
-			lookupKey,
-			record.scope,
-			record.resourceId,
-			record.threadId || null,
-			input.reflection,
-			null,
-			"reflection",
-			toPgJson(record.config),
-			input.currentRecord.generationCount + 1,
-			lastObservedAtStr,
-			lastObservedAtStr,
-			nowStr,
-			nowStr,
-			record.pendingMessageTokens,
-			Math.round(record.totalTokensObserved),
-			Math.round(record.observationTokenCount),
-			false,
-			false,
-			false,
-			false,
-			0,
-			null,
-			record.observedTimezone || null,
-			record.metadata ? toPgJson(record.metadata) : null,
-			nowStr,
-			nowStr,
-			nowStr,
-			nowStr
-		]);
-		return record;
-	}
 	async setReflectingFlag(id, isReflecting) {
 		try {
 			const tableName = getTableName$3({
@@ -13903,41 +14061,35 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 	}
 	async setBufferingObservationFlag(id, isBuffering, lastBufferedAtTokens) {
 		try {
-			const tableName = getTableName$3({
-				indexName: OM_TABLE,
-				schemaName: getSchemaName$3(this.#schema)
-			});
+			const tableName = this.#omTableName();
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			let query;
-			let values;
-			if (lastBufferedAtTokens !== void 0) {
-				query = `UPDATE ${tableName} SET "isBufferingObservation" = $1, "lastBufferedAtTokens" = $2, "updatedAt" = $3, "updatedAtZ" = $4 WHERE id = $5`;
-				values = [
+			await this.#db.client.tx(async (t) => {
+				const row = await this.#lockOMRow(t, tableName, id);
+				if (!row) throw new MastraError({
+					id: createStorageErrorId("PG", "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(t, tableName, row);
+				if (lastBufferedAtTokens !== void 0) await t.none(`UPDATE ${tableName} SET "isBufferingObservation" = $1, "lastBufferedAtTokens" = $2, "updatedAt" = $3, "updatedAtZ" = $4 WHERE id = $5`, [
 					isBuffering,
 					Math.round(lastBufferedAtTokens),
 					nowStr,
 					nowStr,
-					id
-				];
-			} else {
-				query = `UPDATE ${tableName} SET "isBufferingObservation" = $1, "updatedAt" = $2, "updatedAtZ" = $3 WHERE id = $4`;
-				values = [
+					target.id
+				]);
+				else await t.none(`UPDATE ${tableName} SET "isBufferingObservation" = $1, "updatedAt" = $2, "updatedAtZ" = $3 WHERE id = $4`, [
 					isBuffering,
 					nowStr,
 					nowStr,
-					id
-				];
-			}
-			if ((await this.#db.client.query(query, values)).rowCount === 0) throw new MastraError({
-				id: createStorageErrorId("PG", "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
-				}
+					target.id
+				]);
 			});
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
@@ -14010,29 +14162,27 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 	}
 	async setPendingMessageTokens(id, tokenCount) {
 		try {
-			const tableName = getTableName$3({
-				indexName: OM_TABLE,
-				schemaName: getSchemaName$3(this.#schema)
-			});
+			const tableName = this.#omTableName();
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			if ((await this.#db.client.query(`UPDATE ${tableName} SET 
-          "pendingMessageTokens" = $1, 
-          "updatedAt" = $2,
-          "updatedAtZ" = $3
-        WHERE id = $4`, [
-				Math.round(tokenCount),
-				nowStr,
-				nowStr,
-				id
-			])).rowCount === 0) throw new MastraError({
-				id: createStorageErrorId("PG", "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.#db.client.tx(async (t) => {
+				const row = await this.#lockOMRow(t, tableName, id);
+				if (!row) throw new MastraError({
+					id: createStorageErrorId("PG", "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(t, tableName, row);
+				await t.none(`UPDATE ${tableName} SET "pendingMessageTokens" = $1, "updatedAt" = $2, "updatedAtZ" = $3 WHERE id = $4`, [
+					Math.round(tokenCount),
+					nowStr,
+					nowStr,
+					target.id
+				]);
 			});
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
@@ -14082,11 +14232,11 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 		}
 	}
 	async updateBufferedObservations(input) {
+		await this.appendBufferedObservations(input);
+	}
+	async appendBufferedObservations(input) {
 		try {
-			const tableName = getTableName$3({
-				indexName: OM_TABLE,
-				schemaName: getSchemaName$3(this.#schema)
-			});
+			const tableName = this.#omTableName();
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
 			const newChunk = {
 				id: `ombuf-${globalThis.crypto.randomUUID()}`,
@@ -14103,32 +14253,42 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 				extractedValues: input.chunk.extractedValues,
 				extractionFailures: input.chunk.extractionFailures
 			};
-			const lastBufferedAtTime = input.lastBufferedAtTime ? input.lastBufferedAtTime.toISOString() : null;
-			if ((await this.#fenced(void 0, "updateBufferedObservations", (q) => q.query(`UPDATE ${tableName} SET
-          "bufferedObservationChunks" = CASE
-            WHEN EXISTS (
-              SELECT 1
-              FROM jsonb_array_elements(COALESCE("bufferedObservationChunks", '[]'::jsonb)) AS chunk
-              WHERE chunk->>'cycleId' = $2
-            ) THEN COALESCE("bufferedObservationChunks", '[]'::jsonb)
-            ELSE COALESCE("bufferedObservationChunks", '[]'::jsonb) || $1::jsonb
-          END,
-          "lastBufferedAtTime" = COALESCE($3, "lastBufferedAtTime"),
-          "updatedAt" = $4,
-          "updatedAtZ" = $5
-        WHERE id = $6`, [
-				toPgJson([newChunk]),
-				input.chunk.cycleId,
-				lastBufferedAtTime,
-				nowStr,
-				nowStr,
-				input.id
-			]))).rowCount === 0) throw new MastraError({
-				id: createStorageErrorId("PG", "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 fence = resolveRunFence(this, void 0);
+			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runFencesTable(), fence, "appendBufferedObservations");
+				const row = await this.#lockOMRow(t, tableName, input.id);
+				if (!row) throw new MastraError({
+					id: createStorageErrorId("PG", "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 target = this.parseOMRow(await this.#resolveLiveOMRow(t, tableName, row));
+				if ((Array.isArray(target.bufferedObservationChunks) ? target.bufferedObservationChunks : []).some((existing) => existing.cycleId === input.chunk.cycleId) || isBufferedChunkCoveredByCursor(input.chunk.lastObservedAt, target.lastObservedAt)) return {
+					persisted: false,
+					recordId: target.id
+				};
+				const lastBufferedAtTime = input.lastBufferedAtTime ? input.lastBufferedAtTime.toISOString() : null;
+				await t.none(`UPDATE ${tableName} SET
+            "bufferedObservationChunks" = CASE
+              WHEN jsonb_typeof("bufferedObservationChunks") = 'array' THEN "bufferedObservationChunks" || $1::jsonb
+              ELSE $1::jsonb
+            END,
+            "lastBufferedAtTime" = GREATEST("lastBufferedAtTime", $2::timestamp),
+            "updatedAt" = $3,
+            "updatedAtZ" = $4
+          WHERE id = $5`, [
+					toPgJson([newChunk]),
+					lastBufferedAtTime,
+					nowStr,
+					nowStr,
+					target.id
+				]);
+				return {
+					persisted: true,
+					recordId: target.id
+				};
 			});
 		} catch (error) {
 			if (error instanceof MastraError || isRunFenceConflictError(error)) throw error;
@@ -14147,73 +14307,86 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 				schemaName: getSchemaName$3(this.#schema)
 			});
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			const record = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [input.id]);
-			if (!record) throw new MastraError({
-				id: createStorageErrorId("PG", "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 }
-			});
-			let chunks = [];
-			if (record.bufferedObservationChunks) try {
-				const parsed = typeof record.bufferedObservationChunks === "string" ? JSON.parse(record.bufferedObservationChunks) : record.bufferedObservationChunks;
-				chunks = Array.isArray(parsed) ? parsed : [];
-			} catch {
-				chunks = [];
-			}
-			if (chunks.length === 0) 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 chunksToActivate = 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;
+			const fence = resolveRunFence(this, void 0);
+			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runFencesTable(), fence, "swapBufferedToActive");
+				const record = await this.#lockOMRow(t, tableName, input.id);
+				if (!record) throw new MastraError({
+					id: createStorageErrorId("PG", "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 emptyResult = {
+					chunksActivated: 0,
+					messageTokensActivated: 0,
+					observationTokensActivated: 0,
+					messagesActivated: 0,
+					activatedCycleIds: [],
+					activatedMessageIds: []
+				};
+				if (record.supersededBy) return {
+					...emptyResult,
+					retired: true
+				};
+				let persistedChunks = [];
+				if (record.bufferedObservationChunks) try {
+					const parsed = typeof record.bufferedObservationChunks === "string" ? JSON.parse(record.bufferedObservationChunks) : record.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 chunksToActivate = 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);
-			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 = Math.round(activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0));
-			const activatedMessageTokens = Math.round(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 boundary = `\n\n--- message boundary (${lastObservedAt.toISOString()}) ---\n\n`;
-			if ((await this.#fenced(void 0, "swapBufferedToActive", (q) => q.query(`UPDATE ${tableName} 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);
+				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 = Math.round(activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0));
+				const activatedMessageTokens = Math.round(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(record.lastObservedAtZ, lastObservedAt).toISOString();
+				const boundary = `\n\n--- message boundary (${lastObservedAt.toISOString()}) ---\n\n`;
+				if ((await t.query(`UPDATE ${tableName} SET
           "activeObservations" = CASE
             WHEN "activeObservations" IS NOT NULL AND "activeObservations" != ''
             THEN "activeObservations" || $10 || $1
@@ -14227,45 +14400,40 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
           "updatedAt" = $7,
           "updatedAtZ" = $8
         WHERE id = $9
+          AND "supersededBy" IS NULL
           AND "bufferedObservationChunks" IS NOT NULL
           AND "bufferedObservationChunks"::text != '[]'`, [
-				activatedContent,
-				activatedTokens,
-				activatedMessageTokens,
-				remainingChunks.length > 0 ? toPgJson(remainingChunks) : null,
-				lastObservedAtStr,
-				lastObservedAtStr,
-				nowStr,
-				nowStr,
-				input.id,
-				boundary
-			]))).rowCount === 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
-			};
+					activatedContent,
+					activatedTokens,
+					activatedMessageTokens,
+					remainingChunks.length > 0 ? toPgJson(remainingChunks) : null,
+					lastObservedAtStr,
+					lastObservedAtStr,
+					nowStr,
+					nowStr,
+					input.id,
+					boundary
+				])).rowCount === 0) return emptyResult;
+				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 (error instanceof MastraError || isRunFenceConflictError(error)) throw error;
 			throw new MastraError({
@@ -14321,50 +14489,40 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 	}
 	async swapBufferedReflectionToActive(input) {
 		try {
-			const tableName = getTableName$3({
-				indexName: OM_TABLE,
-				schemaName: getSchemaName$3(this.#schema)
-			});
-			const lookupKey = this.getOMKey(input.currentRecord.threadId, input.currentRecord.resourceId);
+			const { currentRecord } = input;
+			const tableName = this.#omTableName();
+			const lookupKey = this.getOMKey(currentRecord.threadId, currentRecord.resourceId);
 			return await this.#withOMLookupKeyLock(tableName, lookupKey, async (t) => {
-				const newer = await this.#getNewerOMGeneration(t, tableName, lookupKey, input.currentRecord.generationCount);
-				if (newer) return newer;
-				const record = await t.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [input.currentRecord.id]);
-				if (!record) throw new MastraError({
-					id: createStorageErrorId("PG", "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 bufferedReflection = record.bufferedReflection || "";
-				const reflectedLineCount = Number(record.reflectedObservationLineCount || 0);
+				const row = await this.#lockOMRow(t, tableName, currentRecord.id);
+				if (!row) return currentRecord;
+				if (row.supersededBy) return this.parseOMRow(await this.#resolveLiveOMRow(t, tableName, row));
+				const stored = this.parseOMRow(row);
+				const bufferedReflection = stored.bufferedReflection || "";
 				if (!bufferedReflection) throw new MastraError({
 					id: createStorageErrorId("PG", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "NO_CONTENT"),
 					text: "No buffered reflection to swap",
 					domain: ErrorDomain.STORAGE,
 					category: ErrorCategory.USER,
-					details: { id: input.currentRecord.id }
+					details: { id: currentRecord.id }
 				});
-				const unreflectedContent = (record.activeObservations || "").split("\n").slice(reflectedLineCount).join("\n").trim();
+				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 newRecord = await this.#insertReflectionGeneration(t, tableName, lookupKey, {
-					currentRecord: input.currentRecord,
-					reflection: newObservations,
-					tokenCount: input.tokenCount
-				});
+				const tokenCount = input.tokenCount + Math.max(0, (stored.observationTokenCount ?? 0) - (currentRecord.observationTokenCount ?? 0));
+				const newRecord = await this.#rollOverOMRow(t, tableName, stored.id, newObservations, tokenCount, input.newRecordId);
 				const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-				await t.query(`UPDATE ${tableName} SET
-          "bufferedReflection" = NULL,
-          "bufferedReflectionTokens" = NULL,
-          "bufferedReflectionInputTokens" = NULL,
-          "reflectedObservationLineCount" = NULL,
-          "updatedAt" = $1,
-          "updatedAtZ" = $2
-        WHERE id = $3`, [
+				await t.none(`UPDATE ${tableName} SET
+            "bufferedReflection" = NULL,
+            "bufferedReflectionTokens" = NULL,
+            "bufferedReflectionInputTokens" = NULL,
+            "reflectedObservationLineCount" = NULL,
+            "updatedAt" = $1,
+            "updatedAtZ" = $2
+          WHERE id = $3`, [
 					nowStr,
 					nowStr,
-					input.currentRecord.id
+					stored.id
 				]);
 				return newRecord;
 			}, "swapBufferedReflectionToActive");
@@ -24969,25 +25127,9 @@ var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 					schemaName: getSchemaName(this.#schema)
 				});
 				const existingSnapshotResult = await t.oneOrNone(`SELECT snapshot FROM ${tableName} WHERE workflow_name = $1 AND run_id = $2 FOR UPDATE`, [workflowName, runId]);
-				let snapshot;
-				if (!existingSnapshotResult) snapshot = {
-					context: {},
-					activePaths: [],
-					timestamp: Date.now(),
-					suspendedPaths: {},
-					activeStepsPath: {},
-					resumeLabels: {},
-					serializedStepGraph: [],
-					status: "pending",
-					value: {},
-					waitingPaths: {},
-					runId,
-					requestContext: {}
-				};
-				else {
-					const existingSnapshot = existingSnapshotResult.snapshot;
-					snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
-				}
+				if (!existingSnapshotResult) return {};
+				const existingSnapshot = existingSnapshotResult.snapshot;
+				const snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
 				mergeWorkflowStepResult({
 					snapshot,
 					stepId,