@mastra/pg 1.31.0-alpha.3 → 1.31.0

package/dist/index.cjs

@@ -3213,9 +3213,10 @@ var PgDB = class extends _mastra_core_base.MastraBase {
 		}
 		await flush();
 	}
-	async insert({ tableName, record }) {
+	/** `client` lets a caller run the insert inside its own transaction. */
+	async insert({ tableName, record }, client = this.client) {
 		try {
-			await this.executeInsert(this.client, {
+			await this.executeInsert(client, {
 				tableName,
 				record
 			});
@@ -4049,13 +4050,15 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			indexName: tableName,
 			schemaName: getSchemaName$6(this.schemaName)
 		});
+		const parsedColumn = `"${(0, _mastra_core_utils.parseSqlIdentifier)(column, "column name")}"`;
 		const sql = `
       DELETE FROM ${fullTableName}
       WHERE ctid IN (
         SELECT ctid FROM ${fullTableName}
-        WHERE ${`"${(0, _mastra_core_utils.parseSqlIdentifier)(column, "column name")}"`} < $1
+        WHERE ${parsedColumn} < $1
         LIMIT $2
       )
+      AND ${parsedColumn} < $1
     `;
 		return (await this.client.query(sql, [cutoff, limit])).rowCount ?? 0;
 	}
@@ -4518,6 +4521,7 @@ var AgentsPG = class AgentsPG extends _mastra_core_storage.AgentsStorage {
 	}
 	async create(input) {
 		const { agent } = input;
+		let draftInserted = false;
 		try {
 			const agentsTable = getTableName$5({
 				indexName: _mastra_core_storage.TABLE_AGENTS,
@@ -4544,6 +4548,7 @@ var AgentsPG = class AgentsPG extends _mastra_core_storage.AgentsStorage {
 				nowIso,
 				nowIso
 			]);
+			draftInserted = true;
 			const { id: _id, authorId: _authorId, visibility: _visibility, metadata: _metadata, ...snapshotConfig } = agent;
 			const versionId = crypto.randomUUID();
 			await this.createVersion({
@@ -4566,14 +4571,14 @@ var AgentsPG = class AgentsPG extends _mastra_core_storage.AgentsStorage {
 				updatedAt: now
 			};
 		} catch (error) {
-			if (error instanceof _mastra_core_error.MastraError) throw error;
-			try {
+			if (draftInserted) try {
 				const agentsTable = getTableName$5({
 					indexName: _mastra_core_storage.TABLE_AGENTS,
 					schemaName: getSchemaName$5(this.#schema)
 				});
 				await this.#db.client.none(`DELETE FROM ${agentsTable} WHERE id = $1 AND status = 'draft' AND "activeVersionId" IS NULL`, [agent.id]);
 			} catch {}
+			if (error instanceof _mastra_core_error.MastraError) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "CREATE_AGENT", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -10569,6 +10574,7 @@ var MCPClientsPG = class MCPClientsPG extends _mastra_core_storage.MCPClientsSto
 	}
 	async create(input) {
 		const { mcpClient } = input;
+		let draftInserted = false;
 		try {
 			const tableName = getTableName$5({
 				indexName: _mastra_core_storage.TABLE_MCP_CLIENTS,
@@ -10591,6 +10597,7 @@ var MCPClientsPG = class MCPClientsPG extends _mastra_core_storage.MCPClientsSto
 				nowIso,
 				nowIso
 			]);
+			draftInserted = true;
 			const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = mcpClient;
 			const versionId = crypto.randomUUID();
 			await this.createVersion({
@@ -10611,7 +10618,7 @@ var MCPClientsPG = class MCPClientsPG extends _mastra_core_storage.MCPClientsSto
 				updatedAt: now
 			};
 		} catch (error) {
-			try {
+			if (draftInserted) try {
 				const tableName = getTableName$5({
 					indexName: _mastra_core_storage.TABLE_MCP_CLIENTS,
 					schemaName: getSchemaName$5(this.#schema)
@@ -11137,6 +11144,7 @@ var MCPServersPG = class MCPServersPG extends _mastra_core_storage.MCPServersSto
 	}
 	async create(input) {
 		const { mcpServer } = input;
+		let draftInserted = false;
 		try {
 			const tableName = getTableName$5({
 				indexName: _mastra_core_storage.TABLE_MCP_SERVERS,
@@ -11158,6 +11166,7 @@ var MCPServersPG = class MCPServersPG extends _mastra_core_storage.MCPServersSto
 				nowIso,
 				nowIso
 			]);
+			draftInserted = true;
 			const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = mcpServer;
 			const versionId = crypto.randomUUID();
 			await this.createVersion({
@@ -11178,7 +11187,7 @@ var MCPServersPG = class MCPServersPG extends _mastra_core_storage.MCPServersSto
 				updatedAt: now
 			};
 		} catch (error) {
-			try {
+			if (draftInserted) try {
 				const tableName = getTableName$5({
 					indexName: _mastra_core_storage.TABLE_MCP_SERVERS,
 					schemaName: getSchemaName$5(this.#schema)
@@ -11602,6 +11611,38 @@ var MCPServersPG = class MCPServersPG extends _mastra_core_storage.MCPServersSto
 	}
 };
 //#endregion
+//#region src/storage/db/run-fencing.ts
+/**
+* Epoch milliseconds on the database clock. `clock_timestamp()` rather than
+* `now()`: a statement can wait on a row lock, and lease math must use the
+* time it actually runs, not when its transaction started.
+*/
+const DB_NOW_MS = `(EXTRACT(EPOCH FROM clock_timestamp()) * 1000)::bigint`;
+/**
+* The check half of a fenced write; call it first inside the write's
+* transaction. `FOR SHARE` holds the claim row until commit, so a claim that
+* updates the row waits for the write to finish, and every later write sees
+* the new claim.
+*/
+async function assertRunFence(t, claimsTable, fence, operation) {
+	const row = await t.oneOrNone(`SELECT generation, "ownerId" FROM ${claimsTable} WHERE "runId" = $1 FOR SHARE`, [fence.runId]);
+	if (!(0, _mastra_core_storage.matchesRunFence)(row && {
+		generation: Number(row.generation),
+		ownerId: row.ownerId
+	}, fence)) throw new _mastra_core_storage.RunFenceConflictError(fence, operation);
+}
+/**
+* Runs `write` directly when it carries no fence, or in a transaction behind
+* the fence check when it does.
+*/
+function withRunFence(client, claimsTable, fence, operation, write) {
+	if (!fence) return write(client);
+	return client.tx(async (t) => {
+		await assertRunFence(t, claimsTable, fence, operation);
+		return write(t);
+	});
+}
+//#endregion
 //#region src/storage/domains/memory/index.ts
 /**
 * Local constant for the observational memory table name.
@@ -11702,6 +11743,10 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 	* and are indexed for fast batched deletes. Cascade order is enforced in
 	* `prune()` (children before threads), not here. Observational memory has no
 	* timestamp anchor and is deliberately excluded.
+	*
+	* Run fences anchor on `retiredAt` (epoch ms), which stays NULL until the
+	* execution holding the fence settles, so a running execution's fence is
+	* never pruned.
 	*/
 	static retentionTables = {
 		messages: {
@@ -11718,6 +11763,12 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			table: _mastra_core_storage.TABLE_THREADS,
 			column: "createdAtZ",
 			indexed: true
+		},
+		runFences: {
+			table: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			column: "retiredAt",
+			indexed: true,
+			anchorType: "epoch-ms"
 		}
 	};
 	#db;
@@ -11781,6 +11832,10 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			});
 			await this.#db.createIndexFromStatement("idx_om_lookup_key", `CREATE INDEX IF NOT EXISTS idx_om_lookup_key ON ${omTableName} ("lookupKey")`);
 		}
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_MEMORY_RUN_FENCES]
+		});
 		await this.createDefaultIndexes();
 		await this.createCustomIndexes();
 	}
@@ -11858,6 +11913,12 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			statements.push(`CREATE INDEX IF NOT EXISTS "${idxPrefix}idx_om_lookup_key" ON ${fullOmTableName} ("lookupKey");`);
 		}
 		for (const idx of MemoryPG.getDefaultIndexDefs(schemaPrefix)) statements.push(generateIndexSQL(idx, schemaName));
+		statements.push(generateTableSQL({
+			tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_MEMORY_RUN_FENCES],
+			schemaName,
+			includeAllConstraints: true
+		}));
 		return statements;
 	}
 	/**
@@ -11893,6 +11954,61 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_MESSAGES });
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_THREADS });
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_RESOURCES });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES });
+	}
+	supportsRunFencing() {
+		return true;
+	}
+	#runFencesTable() {
+		return getTableName$3({
+			indexName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			schemaName: getSchemaName$3(this.#schema)
+		});
+	}
+	/** Runs `write` behind the run's fence check when it carries a fence. */
+	#fenced(fence, operation, write) {
+		return withRunFence(this.#db.client, this.#runFencesTable(), (0, _mastra_core_storage.resolveRunFence)(this, fence), operation, write);
+	}
+	async raiseRunFence(fence) {
+		try {
+			return await this.#db.client.oneOrNone(`INSERT INTO ${this.#runFencesTable()} AS f ("runId", generation, "ownerId")
+         VALUES ($1, $2, $3)
+         ON CONFLICT ("runId") DO UPDATE
+           SET generation = EXCLUDED.generation, "ownerId" = EXCLUDED."ownerId", "retiredAt" = NULL
+         WHERE f.generation < EXCLUDED.generation
+            OR (f.generation = EXCLUDED.generation AND f."ownerId" = EXCLUDED."ownerId")
+         RETURNING "runId"`, [
+				fence.runId,
+				fence.generation,
+				fence.ownerId
+			]) !== null;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "RAISE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
+	}
+	async retireRunFence(fence) {
+		try {
+			return await this.#db.client.oneOrNone(`UPDATE ${this.#runFencesTable()}
+         SET "retiredAt" = ${DB_NOW_MS}
+         WHERE "runId" = $1 AND generation = $2 AND "ownerId" = $3
+         RETURNING "runId"`, [
+				fence.runId,
+				fence.generation,
+				fence.ownerId
+			]) !== null;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "RETIRE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
 	}
 	/**
 	* Deletes rows older than the configured `maxAge` per table, in bounded,
@@ -11913,7 +12029,8 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			order: [
 				"messages",
 				"resources",
-				"threads"
+				"threads",
+				"runFences"
 			]
 		});
 		const results = await runPrune({
@@ -12171,7 +12288,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			throw mastraError;
 		}
 	}
-	async saveThread({ thread }) {
+	async saveThread({ thread, fence }) {
 		try {
 			const tableName = getTableName$3({
 				indexName: _mastra_core_storage.TABLE_THREADS,
@@ -12180,7 +12297,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			const createdAt = toUtcISOString(thread.createdAt);
 			const updatedAt = toUtcISOString(thread.updatedAt);
 			const metadataJson = thread.metadata ? toPgJson(thread.metadata) : null;
-			await this.#db.client.none(`INSERT INTO ${tableName} (
+			await this.#fenced(fence, "saveThread", (q) => q.none(`INSERT INTO ${tableName} (
           id,
           "resourceId",
           title,
@@ -12206,12 +12323,13 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				createdAt,
 				updatedAt,
 				updatedAt
-			]);
+			]));
 			return {
 				...thread,
 				metadata: metadataJson ? JSON.parse(metadataJson) : thread.metadata
 			};
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "SAVE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -12220,29 +12338,30 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async updateThread({ id, title, metadata }) {
+	async updateThread({ id, title, metadata, fence }) {
 		const threadTableName = getTableName$3({
 			indexName: _mastra_core_storage.TABLE_THREADS,
 			schemaName: getSchemaName$3(this.#schema)
 		});
-		const existingThread = await this.#getThreadById(this.#db.client, { threadId: id });
-		if (!existingThread) throw new _mastra_core_error.MastraError({
-			id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_THREAD", "FAILED"),
-			domain: _mastra_core_error.ErrorDomain.STORAGE,
-			category: _mastra_core_error.ErrorCategory.USER,
-			text: `Thread ${id} not found`,
-			details: {
-				threadId: id,
-				title: title ?? null
-			}
-		});
-		const mergedMetadata = {
-			...existingThread.metadata,
-			...metadata
-		};
 		try {
-			const nowStr = toUtcISOString(/* @__PURE__ */ new Date());
-			const thread = await this.#db.client.one(`UPDATE ${threadTableName}
+			return await this.#fenced(fence, "updateThread", async (q) => {
+				const existingThread = await this.#getThreadById(q, { threadId: id });
+				if (!existingThread) throw new _mastra_core_error.MastraError({
+					id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_THREAD", "FAILED"),
+					domain: _mastra_core_error.ErrorDomain.STORAGE,
+					category: _mastra_core_error.ErrorCategory.USER,
+					text: `Thread ${id} not found`,
+					details: {
+						threadId: id,
+						title: title ?? null
+					}
+				});
+				const mergedMetadata = {
+					...existingThread.metadata,
+					...metadata
+				};
+				const nowStr = toUtcISOString(/* @__PURE__ */ new Date());
+				const thread = await q.one(`UPDATE ${threadTableName}
                     SET
                         title = COALESCE($1, title),
                         metadata = $2,
@@ -12251,21 +12370,23 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
                     WHERE id = $5
                     RETURNING *
                 `, [
-				title ?? null,
-				mergedMetadata,
-				nowStr,
-				nowStr,
-				id
-			]);
-			return {
-				id: thread.id,
-				resourceId: thread.resourceId,
-				title: thread.title,
-				metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-				createdAt: thread.createdAtZ || thread.createdAt,
-				updatedAt: thread.updatedAtZ || thread.updatedAt
-			};
+					title ?? null,
+					mergedMetadata,
+					nowStr,
+					nowStr,
+					id
+				]);
+				return {
+					id: thread.id,
+					resourceId: thread.resourceId,
+					title: thread.title,
+					metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+					createdAt: thread.createdAtZ || thread.createdAt,
+					updatedAt: thread.updatedAtZ || thread.updatedAt
+				};
+			});
 		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError || (0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -12818,8 +12939,9 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			throw mastraError;
 		}
 	}
-	async saveMessages({ messages }) {
+	async saveMessages({ messages, fence: explicitFence }) {
 		if (messages.length === 0) return { messages: [] };
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence);
 		const threadId = messages[0]?.threadId;
 		if (!threadId) throw new _mastra_core_error.MastraError({
 			id: (0, _mastra_core_storage.createStorageErrorId)("PG", "SAVE_MESSAGES", "FAILED"),
@@ -12847,6 +12969,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			});
 			const messagesToSave = dedupeMessagesForSave(messages);
 			await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runFencesTable(), fence, "saveMessages");
 				for (let offset = 0; offset < messagesToSave.length; offset += MAX_MESSAGES_PER_INSERT) {
 					const batch = messagesToSave.slice(offset, offset + MAX_MESSAGES_PER_INSERT);
 					const values = [];
@@ -12893,7 +13016,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			});
 			return { messages: new _mastra_core_agent.MessageList().add(messagesWithParsedContent, "memory").get.all.db() };
 		} catch (error) {
-			if (error instanceof _mastra_core_error.MastraError) throw error;
+			if (error instanceof _mastra_core_error.MastraError || (0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "SAVE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -12902,8 +13025,9 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async updateMessages({ messages }) {
+	async updateMessages({ messages, fence: explicitFence }) {
 		if (messages.length === 0) return [];
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence);
 		const messageIds = messages.map((m) => m.id);
 		const selectQuery = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId" FROM ${getTableName$3({
 			indexName: _mastra_core_storage.TABLE_MESSAGES,
@@ -12919,6 +13043,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		});
 		const threadIdsToUpdate = /* @__PURE__ */ new Set();
 		await this.#db.client.tx(async (t) => {
+			if (fence) await assertRunFence(t, this.#runFencesTable(), fence, "updateMessages");
 			const queries = [];
 			const columnMapping = { threadId: "thread_id" };
 			for (const existingMessage of existingMessages) {
@@ -12979,8 +13104,9 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			return message;
 		});
 	}
-	async deleteMessages(messageIds) {
+	async deleteMessages(messageIds, options) {
 		if (!messageIds || messageIds.length === 0) return;
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, options?.fence);
 		try {
 			const messageTableName = getTableName$3({
 				indexName: _mastra_core_storage.TABLE_MESSAGES,
@@ -12991,12 +13117,14 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				schemaName: getSchemaName$3(this.#schema)
 			});
 			await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runFencesTable(), fence, "deleteMessages");
 				const placeholders = messageIds.map((_, idx) => `$${idx + 1}`).join(",");
 				const threadIds = (await t.manyOrNone(`SELECT DISTINCT thread_id FROM ${messageTableName} WHERE id IN (${placeholders})`, messageIds))?.map((msg) => msg.thread_id).filter(Boolean) || [];
 				await t.none(`DELETE FROM ${messageTableName} WHERE id IN (${placeholders})`, messageIds);
 				if (threadIds.length > 0) await t.none(`UPDATE ${threadTableName} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id IN (${inPlaceholders(threadIds.length)})`, threadIds);
 			});
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "DELETE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -13024,6 +13152,9 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		};
 	}
 	async saveResource({ resource }) {
+		return this.#insertResource(this.#db.client, resource);
+	}
+	async #insertResource(q, resource) {
 		const createdAt = toUtcISOString(resource.createdAt);
 		const updatedAt = toUtcISOString(resource.updatedAt);
 		const metadataJson = toPgJson(resource.metadata);
@@ -13035,7 +13166,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				createdAt,
 				updatedAt
 			}
-		});
+		}, q);
 		return {
 			...resource,
 			metadata: metadataJson ? JSON.parse(metadataJson) : resource.metadata
@@ -13046,9 +13177,11 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			indexName: _mastra_core_storage.TABLE_RESOURCES,
 			schemaName: getSchemaName$3(this.#schema)
 		});
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, void 0);
 		const callbackError = {};
 		try {
 			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runFencesTable(), fence, "mergeResourceWorkingMemory");
 				const now = (/* @__PURE__ */ new Date()).toISOString();
 				await t.none(`INSERT INTO ${tableName} (id, metadata, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ")
          VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (id) DO NOTHING`, [
@@ -13092,8 +13225,15 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async updateResource({ resourceId, workingMemory, metadata }) {
-		const existingResource = await this.#getResourceById(this.#db.client, resourceId);
+	async updateResource({ resourceId, workingMemory, metadata, fence }) {
+		return this.#fenced(fence, "updateResource", (q) => this.#updateResource(q, {
+			resourceId,
+			workingMemory,
+			metadata
+		}));
+	}
+	async #updateResource(q, { resourceId, workingMemory, metadata }) {
+		const existingResource = await this.#getResourceById(q, resourceId);
 		if (!existingResource) {
 			const newResource = {
 				id: resourceId,
@@ -13102,7 +13242,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				createdAt: /* @__PURE__ */ new Date(),
 				updatedAt: /* @__PURE__ */ new Date()
 			};
-			return this.saveResource({ resource: newResource });
+			return this.#insertResource(q, newResource);
 		}
 		const updatedResource = {
 			...existingResource,
@@ -13138,7 +13278,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		updates.push(`"updatedAtZ" = $${paramIndex++}`);
 		values.push(updatedAtStr);
 		values.push(resourceId);
-		await this.#db.client.none(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = $${paramIndex}`, values);
+		await q.none(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = $${paramIndex}`, values);
 		return metadataJson ? {
 			...updatedResource,
 			metadata: JSON.parse(metadataJson)
@@ -13277,9 +13417,11 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 	* serializes generation creation across processes instead. It is
 	* transaction-scoped so it also works behind transaction-pooling proxies.
 	*/
-	async #withOMLookupKeyLock(tableName, lookupKey, fn) {
+	async #withOMLookupKeyLock(tableName, lookupKey, fn, fencedOperation) {
+		const fence = fencedOperation ? (0, _mastra_core_storage.resolveRunFence)(this, void 0) : void 0;
 		return this.#db.client.tx(async (t) => {
 			await t.query("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [`${tableName}:${lookupKey}`]);
+			if (fence && fencedOperation) await assertRunFence(t, this.#runFencesTable(), fence, fencedOperation);
 			return fn(t);
 		});
 	}
@@ -13576,7 +13718,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			const lastObservedAtStr = input.lastObservedAt.toISOString();
 			const nowStr = now.toISOString();
 			const observedMessageIdsJson = input.observedMessageIds ? toPgJson(input.observedMessageIds) : null;
-			if ((await this.#db.client.query(`UPDATE ${tableName} SET
+			if ((await this.#fenced(void 0, "updateActiveObservations", (q) => q.query(`UPDATE ${tableName} SET
           "activeObservations" = $1,
           "lastObservedAt" = $2,
           "lastObservedAtZ" = $3,
@@ -13596,7 +13738,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				nowStr,
 				nowStr,
 				input.id
-			])).rowCount === 0) throw new _mastra_core_error.MastraError({
+			]))).rowCount === 0) throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_ACTIVE_OBSERVATIONS", "NOT_FOUND"),
 				text: `Observational memory record not found: ${input.id}`,
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -13604,7 +13746,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				details: { id: input.id }
 			});
 		} catch (error) {
-			if (error instanceof _mastra_core_error.MastraError) throw error;
+			if (error instanceof _mastra_core_error.MastraError || (0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_ACTIVE_OBSERVATIONS", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -13624,8 +13766,9 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				const newer = await this.#getNewerOMGeneration(t, tableName, lookupKey, input.currentRecord.generationCount);
 				if (newer) return newer;
 				return this.#insertReflectionGeneration(t, tableName, lookupKey, input);
-			});
+			}, "createReflectionGeneration");
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "CREATE_REFLECTION_GENERATION", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -13985,7 +14128,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				extractionFailures: input.chunk.extractionFailures
 			};
 			const lastBufferedAtTime = input.lastBufferedAtTime ? input.lastBufferedAtTime.toISOString() : null;
-			if ((await this.#db.client.query(`UPDATE ${tableName} SET
+			if ((await this.#fenced(void 0, "updateBufferedObservations", (q) => q.query(`UPDATE ${tableName} SET
           "bufferedObservationChunks" = CASE
             WHEN EXISTS (
               SELECT 1
@@ -14004,7 +14147,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				nowStr,
 				nowStr,
 				input.id
-			])).rowCount === 0) throw new _mastra_core_error.MastraError({
+			]))).rowCount === 0) throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_BUFFERED_OBSERVATIONS", "NOT_FOUND"),
 				text: `Observational memory record not found: ${input.id}`,
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -14012,7 +14155,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				details: { id: input.id }
 			});
 		} catch (error) {
-			if (error instanceof _mastra_core_error.MastraError) throw error;
+			if (error instanceof _mastra_core_error.MastraError || (0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_BUFFERED_OBSERVATIONS", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -14094,7 +14237,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			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.#db.client.query(`UPDATE ${tableName} SET
+			if ((await this.#fenced(void 0, "swapBufferedToActive", (q) => q.query(`UPDATE ${tableName} SET
           "activeObservations" = CASE
             WHEN "activeObservations" IS NOT NULL AND "activeObservations" != ''
             THEN "activeObservations" || $10 || $1
@@ -14120,7 +14263,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				nowStr,
 				input.id,
 				boundary
-			])).rowCount === 0) return {
+			]))).rowCount === 0) return {
 				chunksActivated: 0,
 				messageTokensActivated: 0,
 				observationTokensActivated: 0,
@@ -14148,7 +14291,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				currentTask: latestChunkHints?.currentTask ?? void 0
 			};
 		} catch (error) {
-			if (error instanceof _mastra_core_error.MastraError) throw error;
+			if (error instanceof _mastra_core_error.MastraError || (0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "SWAP_BUFFERED_TO_ACTIVE", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -14164,7 +14307,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				schemaName: getSchemaName$3(this.#schema)
 			});
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			if ((await this.#db.client.query(`UPDATE ${tableName} SET
+			if ((await this.#fenced(void 0, "updateBufferedReflection", (q) => q.query(`UPDATE ${tableName} SET
           "bufferedReflection" = CASE 
             WHEN "bufferedReflection" IS NOT NULL AND "bufferedReflection" != '' 
             THEN "bufferedReflection" || E'\\n\\n' || $1
@@ -14183,7 +14326,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				nowStr,
 				nowStr,
 				input.id
-			])).rowCount === 0) throw new _mastra_core_error.MastraError({
+			]))).rowCount === 0) throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_BUFFERED_REFLECTION", "NOT_FOUND"),
 				text: `Observational memory record not found: ${input.id}`,
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -14191,7 +14334,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				details: { id: input.id }
 			});
 		} catch (error) {
-			if (error instanceof _mastra_core_error.MastraError) throw error;
+			if (error instanceof _mastra_core_error.MastraError || (0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_BUFFERED_REFLECTION", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -14248,9 +14391,9 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 					input.currentRecord.id
 				]);
 				return newRecord;
-			});
+			}, "swapBufferedReflectionToActive");
 		} catch (error) {
-			if (error instanceof _mastra_core_error.MastraError) throw error;
+			if (error instanceof _mastra_core_error.MastraError || (0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -21246,6 +21389,7 @@ var PromptBlocksPG = class PromptBlocksPG extends _mastra_core_storage.PromptBlo
 	}
 	async create(input) {
 		const { promptBlock } = input;
+		let draftInserted = false;
 		try {
 			const tableName = getTableName$5({
 				indexName: _mastra_core_storage.TABLE_PROMPT_BLOCKS,
@@ -21267,6 +21411,7 @@ var PromptBlocksPG = class PromptBlocksPG extends _mastra_core_storage.PromptBlo
 				nowIso,
 				nowIso
 			]);
+			draftInserted = true;
 			const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = promptBlock;
 			const versionId = crypto.randomUUID();
 			await this.createVersion({
@@ -21287,14 +21432,14 @@ var PromptBlocksPG = class PromptBlocksPG extends _mastra_core_storage.PromptBlo
 				updatedAt: now
 			};
 		} catch (error) {
-			if (error instanceof _mastra_core_error.MastraError) throw error;
-			try {
+			if (draftInserted) try {
 				const tableName = getTableName$5({
 					indexName: _mastra_core_storage.TABLE_PROMPT_BLOCKS,
 					schemaName: getSchemaName$5(this.#schema)
 				});
 				await this.#db.client.none(`DELETE FROM ${tableName} WHERE id = $1 AND status = 'draft' AND "activeVersionId" IS NULL`, [promptBlock.id]);
 			} catch {}
+			if (error instanceof _mastra_core_error.MastraError) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "CREATE_PROMPT_BLOCK", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -22190,6 +22335,7 @@ var ScorerDefinitionsPG = class ScorerDefinitionsPG extends _mastra_core_storage
 	}
 	async create(input) {
 		const { scorerDefinition } = input;
+		let draftInserted = false;
 		try {
 			const tableName = getTableName$5({
 				indexName: _mastra_core_storage.TABLE_SCORER_DEFINITIONS,
@@ -22213,6 +22359,7 @@ var ScorerDefinitionsPG = class ScorerDefinitionsPG extends _mastra_core_storage
 				nowIso,
 				nowIso
 			]);
+			draftInserted = true;
 			const { id: _id, authorId: _authorId, organizationId: _organizationId, projectId: _projectId, metadata: _metadata, ...snapshotConfig } = scorerDefinition;
 			const versionId = crypto.randomUUID();
 			await this.createVersion({
@@ -22235,7 +22382,7 @@ var ScorerDefinitionsPG = class ScorerDefinitionsPG extends _mastra_core_storage
 				updatedAt: now
 			};
 		} catch (error) {
-			try {
+			if (draftInserted) try {
 				const tableName = getTableName$5({
 					indexName: _mastra_core_storage.TABLE_SCORER_DEFINITIONS,
 					schemaName: getSchemaName$5(this.#schema)
@@ -23253,6 +23400,7 @@ var SkillsPG = class SkillsPG extends _mastra_core_storage.SkillsStorage {
 	}
 	async create(input) {
 		const { skill } = input;
+		let draftInserted = false;
 		try {
 			const tableName = getTableName$5({
 				indexName: _mastra_core_storage.TABLE_SKILLS,
@@ -23276,6 +23424,7 @@ var SkillsPG = class SkillsPG extends _mastra_core_storage.SkillsStorage {
 				nowIso,
 				nowIso
 			]);
+			draftInserted = true;
 			const { id: _id, authorId: _authorId, visibility: _visibility, ...snapshotConfig } = skill;
 			const versionId = crypto.randomUUID();
 			await this.createVersion({
@@ -23297,7 +23446,7 @@ var SkillsPG = class SkillsPG extends _mastra_core_storage.SkillsStorage {
 				updatedAt: now
 			};
 		} catch (error) {
-			try {
+			if (draftInserted) try {
 				const tableName = getTableName$5({
 					indexName: _mastra_core_storage.TABLE_SKILLS,
 					schemaName: getSchemaName$5(this.#schema)
@@ -24442,6 +24591,17 @@ function getTableName({ indexName, schemaName }) {
 	const quotedIndexName = `"${indexName}"`;
 	return schemaName ? `${schemaName}.${quotedIndexName}` : quotedIndexName;
 }
+const RUN_OWNER_COLUMNS = `generation, "ownerId", "leaseExpiresAt", ${DB_NOW_MS} AS "nowMs"`;
+function toRunOwnershipRecord(runId, row) {
+	const leaseExpiresAt = row.leaseExpiresAt === null ? null : Number(row.leaseExpiresAt);
+	return {
+		runId,
+		generation: Number(row.generation),
+		ownerId: row.ownerId,
+		leaseExpiresAt: leaseExpiresAt === null ? null : new Date(leaseExpiresAt),
+		live: leaseExpiresAt !== null && leaseExpiresAt > Number(row.nowMs)
+	};
+}
 /** Base name (before any schema prefix) of the expression index backing the status filter. */
 const WORKFLOW_SNAPSHOT_STATUS_INDEX = "mastra_workflow_snapshot_name_status_createdat_idx";
 /**
@@ -24526,12 +24686,24 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 	* Workflow run snapshots accumulate as runs execute. Anchored on the
 	* timezone-aware `updatedAtZ` mirror column (last activity) so suspended or
 	* long-running runs are not pruned by start age.
+	*
+	* Run ownership rows are anchored on `updatedAt` (epoch ms), which every
+	* claim, renewal and release refreshes, so a live execution's row is never
+	* older than its renew interval.
 	*/
-	static retentionTables = { workflowSnapshot: {
-		table: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
-		column: "updatedAtZ",
-		indexed: true
-	} };
+	static retentionTables = {
+		workflowSnapshot: {
+			table: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+			column: "updatedAtZ",
+			indexed: true
+		},
+		runOwnership: {
+			table: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			column: "updatedAt",
+			indexed: true,
+			anchorType: "epoch-ms"
+		}
+	};
 	constructor(config) {
 		super();
 		const { client, readClient, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
@@ -24588,6 +24760,12 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 		for (const idx of WorkflowsPG.getDefaultIndexDefs(schemaPrefix)) statements.push(generateIndexSQL(idx, schemaName));
 		statements.push(`${workflowSnapshotStatusIndexSQL(workflowSnapshotStatusIndexName(parsedSchema), schemaName)};`);
 		statements.push(`${workflowSnapshotThreadIdIndexSQL(workflowSnapshotThreadIdIndexName(parsedSchema), schemaName)};`);
+		statements.push(generateTableSQL({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS],
+			schemaName,
+			includeAllConstraints: true
+		}));
 		return statements;
 	}
 	/**
@@ -24631,6 +24809,10 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT],
 			ifNotExists: ["resourceId"]
 		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS]
+		});
 		await this.createDefaultIndexes();
 		await this.createCustomIndexes();
 	}
@@ -24658,13 +24840,13 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}
 		}
 	}
-	/** Delete workflow run snapshots older than the `workflowSnapshot` policy's `maxAge`, batched. */
+	/** Delete workflow run snapshots and run ownership rows older than their policy's `maxAge`, batched. */
 	async prune(policies, options) {
 		await this.ensureRetentionIndexes(policies);
 		const targets = resolveTargets({
 			policies,
 			descriptor: WorkflowsPG.retentionTables,
-			order: ["workflowSnapshot"]
+			order: ["workflowSnapshot", "runOwnership"]
 		});
 		return runPrune({
 			db: this.#db,
@@ -24686,10 +24868,126 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 	}
 	async dangerouslyClearAll() {
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS });
 	}
-	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state }) {
+	supportsRunFencing() {
+		return true;
+	}
+	#runOwnersTable() {
+		return getTableName({
+			indexName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			schemaName: getSchemaName(this.#schema)
+		});
+	}
+	async #readRunOwner(q, runId) {
+		const row = await q.oneOrNone(`SELECT ${RUN_OWNER_COLUMNS} FROM ${this.#runOwnersTable()} WHERE "runId" = $1`, [runId]);
+		return row ? toRunOwnershipRecord(runId, row) : null;
+	}
+	#ownershipError(operation, runId, error) {
+		return new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("PG", operation, "FAILED"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+			details: { runId }
+		}, error);
+	}
+	async claimRunOwnership({ runId, ownerId, leaseMs, force, expectedGeneration }) {
+		const table = this.#runOwnersTable();
+		try {
+			return await this.#db.client.tx(async (t) => {
+				if (!await t.oneOrNone(`SELECT 1 FROM ${table} WHERE "runId" = $1 FOR UPDATE`, [runId])) {
+					if (expectedGeneration !== void 0 && expectedGeneration !== 0) return {
+						acquired: false,
+						record: null
+					};
+					const inserted = await t.oneOrNone(`INSERT INTO ${table} ("runId", generation, "ownerId", "leaseExpiresAt", "updatedAt")
+             VALUES ($1, GREATEST(1, ${DB_NOW_MS}), $2, ${DB_NOW_MS} + $3, ${DB_NOW_MS})
+             ON CONFLICT ("runId") DO NOTHING
+             RETURNING ${RUN_OWNER_COLUMNS}`, [
+						runId,
+						ownerId,
+						leaseMs
+					]);
+					if (inserted) return {
+						acquired: true,
+						record: toRunOwnershipRecord(runId, inserted)
+					};
+				}
+				const claimed = await t.oneOrNone(`UPDATE ${table}
+           SET generation = generation + 1, "ownerId" = $2, "leaseExpiresAt" = ${DB_NOW_MS} + $3,
+               "updatedAt" = ${DB_NOW_MS}
+           WHERE "runId" = $1
+             AND ($4::bigint IS NULL OR generation = $4)
+             AND ($5::boolean OR "leaseExpiresAt" IS NULL OR "leaseExpiresAt" <= ${DB_NOW_MS})
+           RETURNING ${RUN_OWNER_COLUMNS}`, [
+					runId,
+					ownerId,
+					leaseMs,
+					expectedGeneration ?? null,
+					force === true
+				]);
+				if (claimed) return {
+					acquired: true,
+					record: toRunOwnershipRecord(runId, claimed)
+				};
+				return {
+					acquired: false,
+					record: await this.#readRunOwner(t, runId)
+				};
+			});
+		} catch (error) {
+			throw this.#ownershipError("CLAIM_RUN_OWNERSHIP", runId, error);
+		}
+	}
+	async renewRunOwnership({ leaseMs, ...fence }) {
+		try {
+			const renewed = await this.#db.client.oneOrNone(`UPDATE ${this.#runOwnersTable()}
+         SET "leaseExpiresAt" = ${DB_NOW_MS} + $4, "updatedAt" = ${DB_NOW_MS}
+         WHERE "runId" = $1 AND generation = $2 AND "ownerId" = $3 AND "leaseExpiresAt" IS NOT NULL
+         RETURNING ${RUN_OWNER_COLUMNS}`, [
+				fence.runId,
+				fence.generation,
+				fence.ownerId,
+				leaseMs
+			]);
+			if (renewed) return {
+				renewed: true,
+				record: toRunOwnershipRecord(fence.runId, renewed)
+			};
+			return {
+				renewed: false,
+				record: await this.#readRunOwner(this.#db.client, fence.runId)
+			};
+		} catch (error) {
+			throw this.#ownershipError("RENEW_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async releaseRunOwnership(fence) {
+		try {
+			return await this.#db.client.oneOrNone(`UPDATE ${this.#runOwnersTable()}
+         SET "leaseExpiresAt" = NULL, "updatedAt" = ${DB_NOW_MS}
+         WHERE "runId" = $1 AND generation = $2 AND "ownerId" = $3
+         RETURNING "runId"`, [
+				fence.runId,
+				fence.generation,
+				fence.ownerId
+			]) !== null;
+		} catch (error) {
+			throw this.#ownershipError("RELEASE_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async getRunOwnership({ runId }) {
+		try {
+			return await this.#readRunOwner(this.#db.client, runId);
+		} catch (error) {
+			throw this.#ownershipError("GET_RUN_OWNERSHIP", runId, error);
+		}
+	}
+	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state, fence: explicitFence }) {
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence, runId);
 		try {
 			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runOwnersTable(), fence, "updateWorkflowResults");
 				const tableName = getTableName({
 					indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 					schemaName: getSchemaName(this.#schema)
@@ -24739,6 +25037,7 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 				return snapshot.context;
 			});
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -24751,9 +25050,11 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}, error);
 		}
 	}
-	async updateWorkflowState({ workflowName, runId, opts }) {
+	async updateWorkflowState({ workflowName, runId, opts, fence: explicitFence }) {
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence, runId);
 		try {
 			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runOwnersTable(), fence, "updateWorkflowState");
 				const tableName = getTableName({
 					indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 					schemaName: getSchemaName(this.#schema)
@@ -24783,6 +25084,7 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 				return updatedSnapshot;
 			});
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "UPDATE_WORKFLOW_STATE", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -24794,13 +25096,13 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}, error);
 		}
 	}
-	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt }) {
+	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt, fence }) {
 		try {
 			const now = /* @__PURE__ */ new Date();
 			const createdAtValue = createdAt ? createdAt : now;
 			const updatedAtValue = updatedAt ? updatedAt : now;
 			const sanitizedSnapshot = toPgJson(snapshot);
-			await this.#db.client.none(`INSERT INTO ${getTableName({
+			await withRunFence(this.#db.client, this.#runOwnersTable(), (0, _mastra_core_storage.resolveRunFence)(this, fence, runId), "persistWorkflowSnapshot", (q) => q.none(`INSERT INTO ${getTableName({
 				indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 				schemaName: getSchemaName(this.#schema)
 			})} AS t
@@ -24816,8 +25118,9 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 				updatedAtValue,
 				createdAtValue,
 				updatedAtValue
-			]);
+			]));
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -24883,13 +25186,14 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}, error);
 		}
 	}
-	async deleteWorkflowRunById({ runId, workflowName }) {
+	async deleteWorkflowRunById({ runId, workflowName, fence }) {
 		try {
-			await this.#db.client.none(`DELETE FROM ${getTableName({
+			await withRunFence(this.#db.client, this.#runOwnersTable(), (0, _mastra_core_storage.resolveRunFence)(this, fence, runId), "deleteWorkflowRunById", (q) => q.none(`DELETE FROM ${getTableName({
 				indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 				schemaName: getSchemaName(this.#schema)
-			})} WHERE run_id = $1 AND workflow_name = $2`, [runId, workflowName]);
+			})} WHERE run_id = $1 AND workflow_name = $2`, [runId, workflowName]));
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -25101,6 +25405,7 @@ var WorkspacesPG = class WorkspacesPG extends _mastra_core_storage.WorkspacesSto
 	}
 	async create(input) {
 		const { workspace } = input;
+		let draftInserted = false;
 		try {
 			const tableName = getTableName$5({
 				indexName: _mastra_core_storage.TABLE_WORKSPACES,
@@ -25122,6 +25427,7 @@ var WorkspacesPG = class WorkspacesPG extends _mastra_core_storage.WorkspacesSto
 				nowIso,
 				nowIso
 			]);
+			draftInserted = true;
 			const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = workspace;
 			const versionId = crypto.randomUUID();
 			await this.createVersion({
@@ -25142,7 +25448,7 @@ var WorkspacesPG = class WorkspacesPG extends _mastra_core_storage.WorkspacesSto
 				updatedAt: now
 			};
 		} catch (error) {
-			try {
+			if (draftInserted) try {
 				const tableName = getTableName$5({
 					indexName: _mastra_core_storage.TABLE_WORKSPACES,
 					schemaName: getSchemaName$5(this.#schema)