@mastra/libsql 1.26.0-alpha.2 → 1.26.0-alpha.3

package/dist/index.cjs

@@ -4,15 +4,358 @@ let _mastra_core_error = require("@mastra/core/error");
 let _mastra_core_storage = require("@mastra/core/storage");
 let _mastra_core_utils = require("@mastra/core/utils");
 let _mastra_core_vector = require("@mastra/core/vector");
+let path = require("path");
+let async_hooks = require("async_hooks");
 let _mastra_core_vector_filter = require("@mastra/core/vector/filter");
 let fs_promises = require("fs/promises");
-let path = require("path");
 let _mastra_core_base = require("@mastra/core/base");
 let crypto$1 = require("crypto");
 let _mastra_core_features = require("@mastra/core/features");
 let _mastra_core_agent = require("@mastra/core/agent");
 let _mastra_core_evals = require("@mastra/core/evals");
 let _mastra_core_storage_domains_skills = require("@mastra/core/storage/domains/skills");
+//#region src/shared/file-transaction-gate.ts
+/** Interactive transactions open in this process, per database file. */
+const openTransactions = /* @__PURE__ */ new Map();
+/** The database file a local `file:` url points at, or `undefined` for anything else. */
+function localDatabaseFileKey(url) {
+	if (!url.startsWith("file:") || url.includes(":memory:")) return void 0;
+	const path$2 = url.slice(5).split("?")[0];
+	return path$2 ? (0, path.resolve)(path$2.replace(/^\/\/(?=\/)/, "")) : void 0;
+}
+/**
+* Wraps a local `file:` client so its calls wait for interactive transactions
+* that other clients in this process hold open on the same database file,
+* instead of blocking the thread.
+*
+* `@libsql/client` runs local statements synchronously. When one client holds
+* a write transaction open across an `await` and another client writes the same
+* file, SQLite's busy handler spins on the event loop's only thread for
+* `busy_timeout`, so the transaction holding the lock can't resume and the write
+* fails with `SQLITE_BUSY`. Waiting lets the transaction finish first.
+*
+* Only calls on other clients wait; a client already orders its own writes
+* behind its transactions (see `withClientWriteLock`). A call waits at most
+* `maxWaitMs` (the busy timeout), then goes ahead as it would without the gate,
+* so code that awaits another client from inside its own transaction can't hang.
+* Clients in other processes are unaffected and still rely on `busy_timeout`.
+*/
+function gateLocalFileClient(client, key, { maxWaitMs = 5e3 } = {}) {
+	let gated;
+	const othersOpen = () => [...openTransactions.get(key) ?? []].filter((open) => open.owner !== gated);
+	const waitForOthers = () => {
+		if (othersOpen().length === 0) return;
+		return (async () => {
+			let timer;
+			const gaveUp = new Promise((r) => timer = setTimeout(r, maxWaitMs, "timeout"));
+			try {
+				for (let open = othersOpen(); open.length > 0; open = othersOpen()) if (await Promise.race([Promise.all(open.map((o) => o.done)), gaveUp]) === "timeout") return false;
+				return true;
+			} finally {
+				clearTimeout(timer);
+			}
+		})();
+	};
+	const call = (run) => {
+		const waiting = waitForOthers();
+		return waiting ? waiting.then(run) : run();
+	};
+	const transaction = async (open, mode) => {
+		const deadline = Date.now() + maxWaitMs;
+		for (let waiting = waitForOthers(); waiting; waiting = Date.now() < deadline ? waitForOthers() : void 0) if (!await waiting) break;
+		let finish;
+		const entry = {
+			owner: gated,
+			done: new Promise((r) => finish = r)
+		};
+		let set = openTransactions.get(key);
+		if (!set) openTransactions.set(key, set = /* @__PURE__ */ new Set());
+		set.add(entry);
+		const end = () => {
+			if (!set.delete(entry)) return;
+			if (set.size === 0 && openTransactions.get(key) === set) openTransactions.delete(key);
+			finish();
+		};
+		let tx;
+		try {
+			tx = await open(mode);
+		} catch (error) {
+			end();
+			throw error;
+		}
+		return new Proxy(tx, { get(target, prop) {
+			switch (prop) {
+				case "execute":
+				case "batch":
+				case "executeMultiple": {
+					const method = Reflect.get(target, prop);
+					return async (...args) => {
+						try {
+							return await method.apply(target, args);
+						} finally {
+							if (target.closed) end();
+						}
+					};
+				}
+				case "commit":
+				case "rollback": {
+					const method = Reflect.get(target, prop);
+					return async () => {
+						try {
+							await method.call(target);
+						} finally {
+							end();
+						}
+					};
+				}
+				case "close": {
+					const method = Reflect.get(target, prop);
+					return () => {
+						try {
+							method.call(target);
+						} finally {
+							end();
+						}
+					};
+				}
+				default: {
+					const value = Reflect.get(target, prop);
+					return typeof value === "function" ? value.bind(target) : value;
+				}
+			}
+		} });
+	};
+	gated = new Proxy(client, { get(target, prop) {
+		switch (prop) {
+			case "transaction": {
+				const open = Reflect.get(target, prop);
+				return (mode) => transaction(open.bind(target), mode);
+			}
+			case "execute":
+			case "batch":
+			case "executeMultiple":
+			case "migrate": {
+				const method = Reflect.get(target, prop);
+				return (...args) => call(() => method.apply(target, args));
+			}
+			default: {
+				const value = Reflect.get(target, prop);
+				return typeof value === "function" ? value.bind(target) : value;
+			}
+		}
+	} });
+	return gated;
+}
+/** Applies {@link gateLocalFileClient} when `url` is a local database file; returns `client` otherwise. */
+function gateIfLocalFile(client, url, options) {
+	const key = localDatabaseFileKey(url);
+	return key ? gateLocalFileClient(client, key, options) : client;
+}
+//#endregion
+//#region src/shared/reset-after-busy-client.ts
+function isBusy(error) {
+	return error?.code === "SQLITE_BUSY";
+}
+function firstOpen(hold) {
+	while (hold && !hold.open) hold = hold.outer;
+	return hold;
+}
+/**
+* Wraps a pooled local `file:` client so a statement refused with `SQLITE_BUSY`
+* doesn't leave its connection unusable.
+*
+* libsql leaves a write statement whose run failed busy in progress until it is
+* garbage collected (tursodatabase/libsql-js#237). Until then no transaction on
+* that connection can commit ("cannot commit transaction - SQL statements in
+* progress"), and an autocommit write on it stays uncommitted while holding the
+* database's write lock. The pool hands the same connection out again, so
+* retrying the write doesn't help.
+*
+* After a busy failure the wrapper reopens the client's connections, which
+* finalizes the stuck statement. Reopening closes every connection, including
+* borrowed ones, so it waits until no call or transaction made through the
+* wrapper is in flight. New calls wait for the reset rather than join the calls
+* it waits for, so a client that is never idle still gets reset. A call made
+* while its caller holds an open transaction, or from inside another call,
+* doesn't wait: the reset waits for what its caller holds, so waiting would
+* deadlock. Reopened connections start from the pool's connection options,
+* so `afterReset` runs right after to restore any per-connection settings
+* applied after opening, and calls that waited for the reset go on once it
+* settles, even if it fails. A call waits at most `maxWaitMs` (default 5s, the
+* busy timeout) so a long-held transaction can't stall every later call; after
+* that it goes ahead on the current pool. A transaction SQLite rolled back on its
+* own is released as soon as the failing call returns. It must use the client it was given, not the
+* wrapper: calls through the wrapper would wait for the reset it is part of.
+* Every other member passes through untouched.
+*/
+function resetConnectionsAfterBusy(client, { afterReset, maxWaitMs = 5e3 } = {}) {
+	let inFlight = 0;
+	let pendingReset;
+	const holds = new async_hooks.AsyncLocalStorage();
+	const finishReset = () => {
+		const reset = pendingReset;
+		pendingReset = void 0;
+		reset?.finish();
+	};
+	const settle = () => {
+		inFlight--;
+		if (client.closed) return finishReset();
+		if (!pendingReset || inFlight > 0) return;
+		client.reconnect();
+		if (!afterReset) return finishReset();
+		const reset = pendingReset;
+		Promise.resolve().then(afterReset).catch(() => {}).finally(() => {
+			if (pendingReset === reset) finishReset();
+		});
+	};
+	const noteBusy = (error) => {
+		if (!isBusy(error) || pendingReset) return;
+		let finish;
+		pendingReset = {
+			done: new Promise((resolve) => finish = resolve),
+			finish
+		};
+	};
+	const enter = (callerHolds) => {
+		if (!pendingReset || callerHolds || client.closed) {
+			inFlight++;
+			return;
+		}
+		return (async () => {
+			let timer;
+			const gaveUp = new Promise((resolve) => timer = setTimeout(resolve, maxWaitMs, "timeout"));
+			try {
+				while (pendingReset && !client.closed) if (await Promise.race([pendingReset.done, gaveUp]) === "timeout") break;
+			} finally {
+				clearTimeout(timer);
+			}
+			inFlight++;
+		})();
+	};
+	const run = async (call) => {
+		const hold = {
+			open: true,
+			outer: firstOpen(holds.getStore())
+		};
+		const waiting = enter(hold.outer !== void 0);
+		if (waiting) await waiting;
+		try {
+			return await holds.run(hold, call);
+		} catch (error) {
+			noteBusy(error);
+			throw error;
+		} finally {
+			hold.open = false;
+			settle();
+		}
+	};
+	const transaction = (open, mode) => {
+		const hold = {
+			open: true,
+			outer: firstOpen(holds.getStore())
+		};
+		const waiting = enter(hold.outer !== void 0);
+		holds.enterWith(hold);
+		return openTransaction(open, mode, hold, waiting);
+	};
+	const openTransaction = async (open, mode, hold, waiting) => {
+		let tx;
+		try {
+			if (waiting) await waiting;
+			tx = await open(mode);
+		} catch (error) {
+			hold.open = false;
+			noteBusy(error);
+			settle();
+			throw error;
+		}
+		const end = () => {
+			if (!hold.open) return;
+			hold.open = false;
+			settle();
+		};
+		return new Proxy(tx, { get(target, prop) {
+			switch (prop) {
+				case "execute":
+				case "batch":
+				case "executeMultiple": {
+					const method = Reflect.get(target, prop);
+					return async (...args) => {
+						try {
+							return await method.apply(target, args);
+						} catch (error) {
+							noteBusy(error);
+							if (target.closed) try {
+								target.close();
+							} finally {
+								end();
+							}
+							throw error;
+						}
+					};
+				}
+				case "commit":
+				case "rollback": {
+					const method = Reflect.get(target, prop);
+					return async () => {
+						try {
+							await method.call(target);
+						} catch (error) {
+							noteBusy(error);
+							throw error;
+						} finally {
+							end();
+						}
+					};
+				}
+				case "close": {
+					const method = Reflect.get(target, prop);
+					return () => {
+						try {
+							method.call(target);
+						} finally {
+							end();
+						}
+					};
+				}
+				default: {
+					const value = Reflect.get(target, prop);
+					return typeof value === "function" ? value.bind(target) : value;
+				}
+			}
+		} });
+	};
+	return new Proxy(client, { get(target, prop) {
+		switch (prop) {
+			case "transaction": {
+				const open = Reflect.get(target, prop);
+				return (mode) => transaction(open.bind(target), mode);
+			}
+			case "execute":
+			case "batch":
+			case "executeMultiple":
+			case "migrate": {
+				const method = Reflect.get(target, prop);
+				return (...args) => run(() => method.apply(target, args));
+			}
+			case "close": {
+				const method = Reflect.get(target, prop);
+				return () => {
+					try {
+						method.call(target);
+					} finally {
+						finishReset();
+					}
+				};
+			}
+			default: {
+				const value = Reflect.get(target, prop);
+				return typeof value === "function" ? value.bind(target) : value;
+			}
+		}
+	} });
+}
+//#endregion
 //#region src/shared/single-connection-client.ts
 /**
 * Whether `@libsql/client` backs this database with exactly one connection.
@@ -521,7 +864,7 @@ var LibSQLVector = class extends _mastra_core_vector.MastraVector {
 		this.turso = isSingleConnectionDatabase({
 			url,
 			syncUrl
-		}) ? gateSingleConnectionClient(client) : client;
+		}) ? gateSingleConnectionClient(client) : isLocalDb ? gateIfLocalFile(resetConnectionsAfterBusy(client, { maxWaitMs: 5e3 }), url, { maxWaitMs: 5e3 }) : client;
 		this.maxRetries = maxRetries;
 		this.initialBackoffMs = initialBackoffMs;
 		if (!Number.isInteger(vectorTopKOverFetchMultiplier) || vectorTopKOverFetchMultiplier < 1) throw new Error("vectorTopKOverFetchMultiplier must be a positive integer");
@@ -1112,6 +1455,110 @@ var LibSQLVector = class extends _mastra_core_vector.MastraVector {
 	}
 };
 //#endregion
+//#region src/storage/db/write-lock.ts
+/**
+* Per-client write serialization.
+*
+* `@libsql/client` >= 0.18.0 pools connections for local `file:` databases, but
+* SQLite still admits one writer at a time: an interactive
+* `client.transaction('write')` holds `BEGIN` open across every
+* `await tx.execute(...)`, and any other write on the same database in that
+* window contends on the file lock and can fail with `SQLITE_BUSY` once
+* `busy_timeout` expires.
+*
+* This is dormant under the default engine but the evented engine runs many
+* concurrent workflow snapshot writes per agent run, so a write issued by an
+* unrelated domain (e.g. creating a dataset experiment) can fail spuriously.
+*
+* Serializing every write on a given client closes that window: writes — both
+* autocommit statements and full interactive transactions — run one at a time,
+* so none can interleave with an open transaction. Reads are intentionally not
+* gated; WAL readers never observe a partial write and must not queue behind a
+* long-running writer.
+*
+* `:memory:` databases and embedded replicas get a single pooled connection
+* instead; see `shared/single-connection-client.ts`, which gates *all* calls
+* (reads included) behind open transactions for those clients.
+*/
+const clientWriteChains = /* @__PURE__ */ new WeakMap();
+/**
+* Runs `fn` after every previously-enqueued write on `client` has settled, and
+* returns its result. The chain advances regardless of whether `fn` resolves or
+* rejects, so one failed write never wedges the queue.
+*/
+function withClientWriteLock(client, fn) {
+	const result = (clientWriteChains.get(client) ?? Promise.resolve()).then(fn, fn);
+	clientWriteChains.set(client, result.then(() => void 0, () => void 0));
+	return result;
+}
+//#endregion
+//#region src/storage/db/run-fencing.ts
+/**
+* Epoch milliseconds on the database clock. `julianday('now')` rather than
+* `unixepoch('subsec')`, which needs SQLite 3.42 on the server.
+*/
+const DB_NOW_MS = `CAST(ROUND((julianday('now') - 2440587.5) * 86400000) AS INTEGER)`;
+/**
+* Runs `fn` in a write transaction, behind every other write on `client`.
+* `'write'` opens the transaction with `BEGIN IMMEDIATE`, which takes the
+* database's write lock up front, so nothing written between a read and a
+* write inside `fn` can come from another connection.
+*/
+function inWriteTransaction(client, fn) {
+	return withClientWriteLock(client, async () => {
+		const tx = await client.transaction("write");
+		try {
+			const result = await fn(tx);
+			await tx.commit();
+			return result;
+		} catch (error) {
+			if (!tx.closed) await tx.rollback();
+			throw error;
+		} finally {
+			if (!tx.closed) tx.close();
+		}
+	});
+}
+/**
+* The check half of a fenced write; call it first inside the write's
+* transaction. The transaction already holds the database's write lock, so
+* a claim can't commit between this check and the write.
+*/
+async function assertRunFence(tx, { claimsTable, fence, operation }) {
+	const row = (await tx.execute({
+		sql: `SELECT generation, ownerId FROM ${claimsTable} WHERE runId = ?`,
+		args: [fence.runId]
+	})).rows[0];
+	if (!(0, _mastra_core_storage.matchesRunFence)(row ? {
+		generation: Number(row.generation),
+		ownerId: String(row.ownerId)
+	} : null, fence)) throw new _mastra_core_storage.RunFenceConflictError(fence, operation);
+}
+/**
+* Runs `write` behind the client's write lock: directly when there is no
+* fence to check, or in a write transaction behind the check when there is.
+* `write` must issue every statement through the writer it is given; on a
+* single-connection client, a call on the client itself would wait for the
+* open transaction forever.
+*/
+function withRunFence(client, check, write) {
+	if (!check) return withClientWriteLock(client, () => write({
+		execute: (statement) => client.execute(statement),
+		batch: (statements) => client.batch(statements, "write")
+	}));
+	return inWriteTransaction(client, async (tx) => {
+		await assertRunFence(tx, check);
+		return write({
+			execute: (statement) => tx.execute(statement),
+			batch: async (statements) => {
+				const results = [];
+				for (const statement of statements) results.push(await tx.execute(statement));
+				return results;
+			}
+		});
+	});
+}
+//#endregion
 //#region src/storage/db/utils.ts
 const MAX_DEPTH = 100;
 /**
@@ -1204,6 +1651,7 @@ function createExecuteWriteOperationWithRetry({ logger, maxRetries, initialBacko
 		while (attempts < maxRetries) try {
 			return await operationFn();
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			logger.debug(`LibSQLStore: Error caught in retry loop for ${operationDescription}`, {
 				errorType: error.constructor.name,
 				errorCode: error.code,
@@ -1364,43 +1812,6 @@ function transformFromSqlRow({ tableName, sqlRow }) {
 	return result;
 }
 //#endregion
-//#region src/storage/db/write-lock.ts
-/**
-* Per-client write serialization.
-*
-* `@libsql/client` >= 0.18.0 pools connections for local `file:` databases, but
-* SQLite still admits one writer at a time: an interactive
-* `client.transaction('write')` holds `BEGIN` open across every
-* `await tx.execute(...)`, and any other write on the same database in that
-* window contends on the file lock and can fail with `SQLITE_BUSY` once
-* `busy_timeout` expires.
-*
-* This is dormant under the default engine but the evented engine runs many
-* concurrent workflow snapshot writes per agent run, so a write issued by an
-* unrelated domain (e.g. creating a dataset experiment) can fail spuriously.
-*
-* Serializing every write on a given client closes that window: writes — both
-* autocommit statements and full interactive transactions — run one at a time,
-* so none can interleave with an open transaction. Reads are intentionally not
-* gated; WAL readers never observe a partial write and must not queue behind a
-* long-running writer.
-*
-* `:memory:` databases and embedded replicas get a single pooled connection
-* instead; see `shared/single-connection-client.ts`, which gates *all* calls
-* (reads included) behind open transactions for those clients.
-*/
-const clientWriteChains = /* @__PURE__ */ new WeakMap();
-/**
-* Runs `fn` after every previously-enqueued write on `client` has settled, and
-* returns its result. The chain advances regardless of whether `fn` resolves or
-* rejects, so one failed write never wedges the queue.
-*/
-function withClientWriteLock(client, fn) {
-	const result = (clientWriteChains.get(client) ?? Promise.resolve()).then(fn, fn);
-	clientWriteChains.set(client, result.then(() => void 0, () => void 0));
-	return result;
-}
-//#endregion
 //#region src/storage/db/index.ts
 /**
 * Default SQLite `busy_timeout` (ms) for local LibSQL connections. Chosen to
@@ -1501,10 +1912,10 @@ var LibSQLDB = class extends _mastra_core_base.MastraBase {
 	/**
 	* Internal insert implementation without retry logic.
 	*/
-	async doInsert({ tableName, record }) {
+	async doInsert({ tableName, record, check }) {
 		const filteredRecord = await this.filterRecordToKnownColumns(tableName, record);
 		if (Object.keys(filteredRecord).length === 0) return;
-		await withClientWriteLock(this.client, () => this.client.execute(prepareStatement({
+		await withRunFence(this.client, check, (writer) => writer.execute(prepareStatement({
 			tableName,
 			record: filteredRecord
 		})));
@@ -1515,6 +1926,7 @@ var LibSQLDB = class extends _mastra_core_base.MastraBase {
 	* @param args - The insert arguments
 	* @param args.tableName - The name of the table to insert into
 	* @param args.record - The record to insert (key-value pairs)
+	* @param args.check - The run fence the insert must carry, if any
 	*/
 	insert(args) {
 		return this.executeWriteOperationWithRetry(() => this.doInsert(args), `insert into table ${args.tableName}`);
@@ -8919,6 +9331,10 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	* Retention-eligible tables. `threads`, `messages`, and `resources` all anchor
 	* on `createdAt` and are indexed for fast batched deletes. Cascade order is
 	* enforced in `prune()` (children before threads), not here.
+	*
+	* 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: {
@@ -8935,6 +9351,12 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			table: _mastra_core_storage.TABLE_THREADS,
 			column: "createdAt",
 			indexed: true
+		},
+		runFences: {
+			table: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			column: "retiredAt",
+			indexed: true,
+			anchorType: "epoch-ms"
 		}
 	};
 	#client;
@@ -8957,6 +9379,13 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	#write(operation, fn) {
 		return this.#db.executeWriteOperationWithRetry(() => withClientWriteLock(this.#client, fn), operation);
 	}
+	/**
+	* `#write` for a write that may carry a run fence: with a check, it runs in a write
+	* transaction behind the check, and a retry reruns the whole transaction.
+	*/
+	#fencedWrite(operation, check, write) {
+		return this.#db.executeWriteOperationWithRetry(() => withRunFence(this.#client, check, write), operation);
+	}
 	async init() {
 		await this.#db.createTable({
 			tableName: _mastra_core_storage.TABLE_THREADS,
@@ -8970,6 +9399,10 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			tableName: _mastra_core_storage.TABLE_RESOURCES,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_RESOURCES]
 		});
+		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]
+		});
 		const omSchema = _mastra_core_storage.OBSERVATIONAL_MEMORY_TABLE_SCHEMA?.[OM_TABLE];
 		if (omSchema) {
 			await this.#db.createTable({
@@ -9021,6 +9454,70 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 		await this.#db.deleteData({ tableName: _mastra_core_storage.TABLE_THREADS });
 		await this.#db.deleteData({ tableName: _mastra_core_storage.TABLE_RESOURCES });
 		await this.#db.deleteData({ tableName: OM_TABLE });
+		await this.#db.deleteData({ tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES });
+	}
+	supportsRunFencing() {
+		return true;
+	}
+	async raiseRunFence(fence) {
+		try {
+			return await this.#db.executeWriteOperationWithRetry(() => inWriteTransaction(this.#client, async (tx) => {
+				const row = (await tx.execute({
+					sql: `SELECT generation, ownerId FROM ${_mastra_core_storage.TABLE_MEMORY_RUN_FENCES} WHERE runId = ?`,
+					args: [fence.runId]
+				})).rows[0];
+				const generation = row ? Number(row.generation) : void 0;
+				const raises = generation === void 0 || generation < fence.generation;
+				const reaffirms = generation === fence.generation && String(row.ownerId) === fence.ownerId;
+				if (!raises && !reaffirms) return false;
+				await tx.execute({
+					sql: `INSERT INTO ${_mastra_core_storage.TABLE_MEMORY_RUN_FENCES} (runId, generation, ownerId) VALUES (?, ?, ?)
+                ON CONFLICT(runId) DO UPDATE SET generation = excluded.generation, ownerId = excluded.ownerId, retiredAt = NULL`,
+					args: [
+						fence.runId,
+						fence.generation,
+						fence.ownerId
+					]
+				});
+				return true;
+			}), "raiseRunFence");
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "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.executeWriteOperationWithRetry(() => withClientWriteLock(this.#client, () => this.#client.execute({
+				sql: `UPDATE ${_mastra_core_storage.TABLE_MEMORY_RUN_FENCES} SET retiredAt = ${DB_NOW_MS}
+                WHERE runId = ? AND generation = ? AND ownerId = ?`,
+				args: [
+					fence.runId,
+					fence.generation,
+					fence.ownerId
+				]
+			})), "retireRunFence")).rowsAffected > 0;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "RETIRE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
+	}
+	/** The check a write must pass: its own fence, otherwise the one in scope. */
+	#runFenceCheck(fence, operation) {
+		const resolved = (0, _mastra_core_storage.resolveRunFence)(this, fence);
+		return resolved && {
+			claimsTable: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			fence: resolved,
+			operation
+		};
 	}
 	/**
 	* Delete rows older than each policy's `maxAge`, batched and cancellable.
@@ -9036,7 +9533,8 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			order: [
 				"messages",
 				"resources",
-				"threads"
+				"threads",
+				"runFences"
 			]
 		});
 		return runPrune({
@@ -9418,7 +9916,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			throw mastraError;
 		}
 	}
-	async saveMessages({ messages }) {
+	async saveMessages({ messages, fence }) {
 		if (messages.length === 0) return { messages };
 		try {
 			const threadId = messages[0]?.threadId;
@@ -9456,13 +9954,16 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			const BATCH_SIZE = 50;
 			const messageStatements = batchStatements.slice(0, -1);
 			const threadUpdateStatement = batchStatements[batchStatements.length - 1];
-			for (let i = 0; i < messageStatements.length; i += BATCH_SIZE) {
-				const batch = messageStatements.slice(i, i + BATCH_SIZE);
-				if (batch.length > 0) await this.#write("saveMessages", () => this.#client.batch(batch, "write"));
-			}
-			if (threadUpdateStatement) await this.#write("saveMessages", () => this.#client.execute(threadUpdateStatement));
+			await this.#fencedWrite("saveMessages", this.#runFenceCheck(fence, "saveMessages"), async (writer) => {
+				for (let i = 0; i < messageStatements.length; i += BATCH_SIZE) {
+					const batch = messageStatements.slice(i, i + BATCH_SIZE);
+					if (batch.length > 0) await writer.batch(batch);
+				}
+				if (threadUpdateStatement) await writer.execute(threadUpdateStatement);
+			});
 			return { messages: new _mastra_core_agent.MessageList().add(messages, "memory").get.all.db() };
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "SAVE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -9470,11 +9971,14 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			}, error);
 		}
 	}
-	async updateMessages({ messages }) {
+	async updateMessages({ messages, fence }) {
 		if (messages.length === 0) return [];
+		return this.#fencedWrite("updateMessages", this.#runFenceCheck(fence, "updateMessages"), (writer) => this.#updateMessages(writer, messages));
+	}
+	async #updateMessages(writer, messages) {
 		const messageIds = messages.map((m) => m.id);
 		const selectSql = `SELECT * FROM ${_mastra_core_storage.TABLE_MESSAGES} WHERE id IN (${messageIds.map(() => "?").join(",")})`;
-		const existingMessages = (await this.#client.execute({
+		const existingMessages = (await writer.execute({
 			sql: selectSql,
 			args: messageIds
 		})).rows.map((row) => this.parseRow(row));
@@ -9526,48 +10030,44 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			sql: `UPDATE ${_mastra_core_storage.TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
 			args: [now, threadId]
 		});
-		await this.#write("updateMessages", () => this.#client.batch(batchStatements, "write"));
-		return (await this.#client.execute({
+		await writer.batch(batchStatements);
+		return (await writer.execute({
 			sql: selectSql,
 			args: messageIds
 		})).rows.map((row) => this.parseRow(row));
 	}
-	async deleteMessages(messageIds) {
+	async deleteMessages(messageIds, options) {
 		if (!messageIds || messageIds.length === 0) return;
 		try {
 			const BATCH_SIZE = 100;
-			await this.#write("deleteMessages", async () => {
+			const check = this.#runFenceCheck(options?.fence, "deleteMessages");
+			await this.#db.executeWriteOperationWithRetry(() => inWriteTransaction(this.#client, async (tx) => {
+				if (check) await assertRunFence(tx, check);
 				const threadIds = /* @__PURE__ */ new Set();
-				const tx = await this.#client.transaction("write");
-				try {
-					for (let i = 0; i < messageIds.length; i += BATCH_SIZE) {
-						const batch = messageIds.slice(i, i + BATCH_SIZE);
-						const placeholders = batch.map(() => "?").join(",");
-						(await tx.execute({
-							sql: `SELECT DISTINCT thread_id FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
-							args: batch
-						})).rows?.forEach((row) => {
-							if (row.thread_id) threadIds.add(row.thread_id);
-						});
-						await tx.execute({
-							sql: `DELETE FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
-							args: batch
-						});
-					}
-					if (threadIds.size > 0) {
-						const now = (/* @__PURE__ */ new Date()).toISOString();
-						for (const threadId of threadIds) await tx.execute({
-							sql: `UPDATE "${_mastra_core_storage.TABLE_THREADS}" SET "updatedAt" = ? WHERE id = ?`,
-							args: [now, threadId]
-						});
-					}
-					await tx.commit();
-				} catch (error) {
-					await tx.rollback();
-					throw error;
+				for (let i = 0; i < messageIds.length; i += BATCH_SIZE) {
+					const batch = messageIds.slice(i, i + BATCH_SIZE);
+					const placeholders = batch.map(() => "?").join(",");
+					(await tx.execute({
+						sql: `SELECT DISTINCT thread_id FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
+						args: batch
+					})).rows?.forEach((row) => {
+						if (row.thread_id) threadIds.add(row.thread_id);
+					});
+					await tx.execute({
+						sql: `DELETE FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
+						args: batch
+					});
 				}
-			});
+				if (threadIds.size > 0) {
+					const now = (/* @__PURE__ */ new Date()).toISOString();
+					for (const threadId of threadIds) await tx.execute({
+						sql: `UPDATE "${_mastra_core_storage.TABLE_THREADS}" SET "updatedAt" = ? WHERE id = ?`,
+						args: [now, threadId]
+					});
+				}
+			}), "deleteMessages");
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "DELETE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -9591,13 +10091,18 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 		};
 	}
 	async saveResource({ resource }) {
+		return this.#insertResource(resource, void 0);
+	}
+	async #insertResource(resource, check) {
 		await this.#db.insert({
 			tableName: _mastra_core_storage.TABLE_RESOURCES,
-			record: { ...resource }
+			record: { ...resource },
+			check
 		});
 		return resource;
 	}
-	async updateResource({ resourceId, workingMemory, metadata }) {
+	async updateResource({ resourceId, workingMemory, metadata, fence }) {
+		const check = this.#runFenceCheck(fence, "updateResource");
 		const existingResource = await this.getResourceById({ resourceId });
 		if (!existingResource) {
 			const newResource = {
@@ -9607,7 +10112,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 				createdAt: /* @__PURE__ */ new Date(),
 				updatedAt: /* @__PURE__ */ new Date()
 			};
-			return this.saveResource({ resource: newResource });
+			return this.#insertResource(newResource, check);
 		}
 		const updatedResource = {
 			...existingResource,
@@ -9631,7 +10136,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 		updates.push("updatedAt = ?");
 		values.push(updatedResource.updatedAt.toISOString());
 		values.push(resourceId);
-		await this.#write("updateResource", () => this.#client.execute({
+		await this.#fencedWrite("updateResource", check, (writer) => writer.execute({
 			sql: `UPDATE ${_mastra_core_storage.TABLE_RESOURCES} SET ${updates.join(", ")} WHERE id = ?`,
 			args: values
 		}));
@@ -9835,14 +10340,16 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			throw mastraError;
 		}
 	}
-	async saveThread({ thread }) {
+	async saveThread({ thread, fence }) {
 		try {
 			await this.#db.insert({
 				tableName: _mastra_core_storage.TABLE_THREADS,
-				record: { ...thread }
+				record: { ...thread },
+				check: this.#runFenceCheck(fence, "saveThread")
 			});
 			return thread;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			const mastraError = new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "SAVE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -9854,7 +10361,8 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			throw mastraError;
 		}
 	}
-	async updateThread({ id, title, metadata }) {
+	async updateThread({ id, title, metadata, fence }) {
+		const check = this.#runFenceCheck(fence, "updateThread");
 		const thread = await this.getThreadById({ threadId: id });
 		if (!thread) throw new _mastra_core_error.MastraError({
 			id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "UPDATE_THREAD", "NOT_FOUND"),
@@ -9877,7 +10385,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			updatedAt: now
 		};
 		try {
-			await this.#write("updateThread", () => this.#client.execute({
+			await this.#fencedWrite("updateThread", check, (writer) => writer.execute({
 				sql: `UPDATE ${_mastra_core_storage.TABLE_THREADS} SET title = COALESCE(?, title), metadata = jsonb(?), updatedAt = ? WHERE id = ?`,
 				args: [
 					title ?? null,
@@ -9888,6 +10396,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			}));
 			return updatedThread;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "UPDATE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -10298,7 +10807,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 		try {
 			const now = /* @__PURE__ */ new Date();
 			const observedMessageIdsJson = input.observedMessageIds ? JSON.stringify(input.observedMessageIds) : null;
-			if ((await this.#write("updateActiveObservations", () => this.#client.execute({
+			if ((await this.#fencedWrite("updateActiveObservations", this.#runFenceCheck(void 0, "updateActiveObservations"), (writer) => writer.execute({
 				sql: `UPDATE "${OM_TABLE}" SET
             "activeObservations" = ?,
             "lastObservedAt" = ?,
@@ -10336,9 +10845,11 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async createReflectionGeneration(input) {
 		try {
+			const check = this.#runFenceCheck(void 0, "createReflectionGeneration");
 			return await this.#write("createReflectionGeneration", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
+					if (check) await assertRunFence(tx, check);
 					const record = await this.#insertReflectionGeneration(tx, input);
 					await tx.commit();
 					return record;
@@ -10675,9 +11186,11 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async updateBufferedObservations(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+			const check = this.#runFenceCheck(void 0, "updateBufferedObservations");
 			await this.#write("updateBufferedObservations", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
+					if (check) await assertRunFence(tx, check);
 					const current = await tx.execute({
 						sql: `SELECT "bufferedObservationChunks" FROM "${OM_TABLE}" WHERE id = ?`,
 						args: [input.id]
@@ -10756,9 +11269,11 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async swapBufferedToActive(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+			const check = this.#runFenceCheck(void 0, "swapBufferedToActive");
 			return await this.#write("swapBufferedToActive", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
+					if (check) await assertRunFence(tx, check);
 					const current = await tx.execute({
 						sql: `SELECT * FROM "${OM_TABLE}" WHERE id = ?`,
 						args: [input.id]
@@ -10905,7 +11420,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async updateBufferedReflection(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			if ((await this.#write("updateBufferedReflection", () => this.#client.execute({
+			if ((await this.#fencedWrite("updateBufferedReflection", this.#runFenceCheck(void 0, "updateBufferedReflection"), (writer) => writer.execute({
 				sql: `UPDATE "${OM_TABLE}" SET
             "bufferedReflection" = CASE
               WHEN "bufferedReflection" IS NOT NULL AND "bufferedReflection" != ''
@@ -10945,9 +11460,11 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async swapBufferedReflectionToActive(input) {
 		try {
+			const check = this.#runFenceCheck(void 0, "swapBufferedReflectionToActive");
 			return await this.#write("swapBufferedReflectionToActive", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
+					if (check) await assertRunFence(tx, check);
 					const current = await tx.execute({
 						sql: `SELECT * FROM "${OM_TABLE}" WHERE id = ?`,
 						args: [input.currentRecord.id]
@@ -14447,16 +14964,39 @@ var WorkflowDefinitionsLibSQL = class extends _mastra_core_storage.WorkflowDefin
 };
 //#endregion
 //#region src/storage/domains/workflows/index.ts
+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: String(row.ownerId),
+		leaseExpiresAt: leaseExpiresAt === null ? null : new Date(leaseExpiresAt),
+		live: leaseExpiresAt !== null && leaseExpiresAt > Number(row.nowMs)
+	};
+}
 var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.WorkflowsStorage {
 	/**
 	* Workflow run snapshots accumulate as runs execute. Anchored on `updatedAt`
 	* (last activity) so suspended/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: "updatedAt",
-		indexed: true
-	} };
+	static retentionTables = {
+		workflowSnapshot: {
+			table: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+			column: "updatedAt",
+			indexed: true
+		},
+		runOwnership: {
+			table: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			column: "updatedAt",
+			indexed: true,
+			anchorType: "epoch-ms"
+		}
+	};
 	#db;
 	#client;
 	executeWithRetry;
@@ -14508,16 +15048,132 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			schema,
 			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]
+		});
 	}
 	async dangerouslyClearAll() {
 		await this.#db.deleteData({ tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT });
+		await this.#db.deleteData({ tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS });
+	}
+	supportsRunFencing() {
+		return true;
+	}
+	#runFenceCheck(fence, runId, operation) {
+		const resolved = (0, _mastra_core_storage.resolveRunFence)(this, fence, runId);
+		return resolved && {
+			claimsTable: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			fence: resolved,
+			operation
+		};
 	}
-	/** Delete workflow snapshots older than the `workflowSnapshot` policy's `maxAge`, batched. */
+	async #readRunOwner(q, runId) {
+		const row = (await q.execute({
+			sql: `SELECT ${RUN_OWNER_COLUMNS} FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS} WHERE runId = ?`,
+			args: [runId]
+		})).rows[0];
+		return row ? toRunOwnershipRecord(runId, row) : null;
+	}
+	#ownershipError(operation, runId, error) {
+		return new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", operation, "FAILED"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+			details: { runId }
+		}, error);
+	}
+	async claimRunOwnership({ runId, ownerId, leaseMs, force, expectedGeneration }) {
+		try {
+			return await this.executeWithRetry(() => inWriteTransaction(this.#client, async (tx) => {
+				const current = await this.#readRunOwner(tx, runId);
+				const generation = current?.generation ?? 0;
+				if (expectedGeneration !== void 0 && expectedGeneration !== generation) return {
+					acquired: false,
+					record: current
+				};
+				if (current?.live && !force) return {
+					acquired: false,
+					record: current
+				};
+				await tx.execute({
+					sql: `INSERT INTO ${_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS} (runId, generation, ownerId, leaseExpiresAt, updatedAt)
+                VALUES (?, COALESCE(?, MAX(1, ${DB_NOW_MS})), ?, ${DB_NOW_MS} + ?, ${DB_NOW_MS})
+                ON CONFLICT(runId) DO UPDATE SET
+                  generation = excluded.generation,
+                  ownerId = excluded.ownerId,
+                  leaseExpiresAt = excluded.leaseExpiresAt,
+                  updatedAt = excluded.updatedAt`,
+					args: [
+						runId,
+						current ? generation + 1 : null,
+						ownerId,
+						leaseMs
+					]
+				});
+				return {
+					acquired: true,
+					record: await this.#readRunOwner(tx, runId)
+				};
+			}), "claimRunOwnership");
+		} catch (error) {
+			throw this.#ownershipError("CLAIM_RUN_OWNERSHIP", runId, error);
+		}
+	}
+	async renewRunOwnership({ leaseMs, ...fence }) {
+		try {
+			return await this.executeWithRetry(() => inWriteTransaction(this.#client, async (tx) => {
+				const renewed = await tx.execute({
+					sql: `UPDATE ${_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS} SET leaseExpiresAt = ${DB_NOW_MS} + ?, updatedAt = ${DB_NOW_MS}
+                WHERE runId = ? AND generation = ? AND ownerId = ? AND leaseExpiresAt IS NOT NULL`,
+					args: [
+						leaseMs,
+						fence.runId,
+						fence.generation,
+						fence.ownerId
+					]
+				});
+				const record = await this.#readRunOwner(tx, fence.runId);
+				return renewed.rowsAffected > 0 ? {
+					renewed: true,
+					record
+				} : {
+					renewed: false,
+					record
+				};
+			}), "renewRunOwnership");
+		} catch (error) {
+			throw this.#ownershipError("RENEW_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async releaseRunOwnership(fence) {
+		try {
+			return (await this.executeWithRetry(() => withClientWriteLock(this.#client, () => this.#client.execute({
+				sql: `UPDATE ${_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS} SET leaseExpiresAt = NULL, updatedAt = ${DB_NOW_MS}
+                WHERE runId = ? AND generation = ? AND ownerId = ?`,
+				args: [
+					fence.runId,
+					fence.generation,
+					fence.ownerId
+				]
+			})), "releaseRunOwnership")).rowsAffected > 0;
+		} catch (error) {
+			throw this.#ownershipError("RELEASE_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async getRunOwnership({ runId }) {
+		try {
+			return await this.#readRunOwner(this.#client, runId);
+		} catch (error) {
+			throw this.#ownershipError("GET_RUN_OWNERSHIP", runId, error);
+		}
+	}
+	/** Delete workflow run snapshots and run ownership rows older than their policy's `maxAge`, batched. */
 	async prune(policies, options) {
 		const targets = resolveTargets({
 			policies,
 			descriptor: WorkflowsLibSQL.retentionTables,
-			order: ["workflowSnapshot"]
+			order: ["workflowSnapshot", "runOwnership"]
 		});
 		return runPrune({
 			db: this.#db,
@@ -14547,10 +15203,12 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			this.logger.warn("LibSQL Workflows: Failed to set PRAGMA settings.", err);
 		}
 	}
-	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state }) {
+	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state, fence: explicitFence }) {
+		const check = this.#runFenceCheck(explicitFence, runId, "updateWorkflowResults");
 		return this.executeWithRetry(() => withClientWriteLock(this.#client, async () => {
 			const tx = await this.#client.transaction("write");
 			try {
+				if (check) await assertRunFence(tx, check);
 				const existingSnapshotResult = await tx.execute({
 					sql: `SELECT json(snapshot) as snapshot FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
 					args: [workflowName, runId]
@@ -14603,10 +15261,12 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			}
 		}), "updateWorkflowResults");
 	}
-	async updateWorkflowState({ workflowName, runId, opts }) {
+	async updateWorkflowState({ workflowName, runId, opts, fence: explicitFence }) {
+		const check = this.#runFenceCheck(explicitFence, runId, "updateWorkflowState");
 		return this.executeWithRetry(() => withClientWriteLock(this.#client, async () => {
 			const tx = await this.#client.transaction("write");
 			try {
+				if (check) await assertRunFence(tx, check);
 				const existingSnapshotResult = await tx.execute({
 					sql: `SELECT json(snapshot) as snapshot FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
 					args: [workflowName, runId]
@@ -14647,7 +15307,7 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			}
 		}), "updateWorkflowState");
 	}
-	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt }) {
+	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt, fence }) {
 		const now = /* @__PURE__ */ new Date();
 		const createdAtValue = (createdAt ?? now).toISOString();
 		const updatedAtValue = (updatedAt ?? now).toISOString();
@@ -14655,7 +15315,8 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			workflowName,
 			runId
 		});
-		await this.executeWithRetry(() => withClientWriteLock(this.#client, () => this.#client.execute({
+		const check = this.#runFenceCheck(fence, runId, "persistWorkflowSnapshot");
+		await this.executeWithRetry(() => withRunFence(this.#client, check, (writer) => writer.execute({
 			sql: `INSERT INTO ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} (workflow_name, run_id, resourceId, snapshot, createdAt, updatedAt)
                 VALUES (?, ?, ?, jsonb(?), ?, ?)
                 ON CONFLICT(workflow_name, run_id)
@@ -14711,14 +15372,16 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			}, error);
 		}
 	}
-	async deleteWorkflowRunById({ runId, workflowName }) {
+	async deleteWorkflowRunById({ runId, workflowName, fence }) {
+		const check = this.#runFenceCheck(fence, runId, "deleteWorkflowRunById");
 		return this.executeWithRetry(async () => {
 			try {
-				await this.#client.execute({
+				await withRunFence(this.#client, check, (writer) => writer.execute({
 					sql: `DELETE FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
 					args: [workflowName, runId]
-				});
+				}));
 			} catch (error) {
+				if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 				throw new _mastra_core_error.MastraError({
 					id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
 					domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -15588,7 +16251,7 @@ var LibSQLFactoryStorage = class extends _mastra_core_storage.FactoryStorage {
 			...config.authToken ? { authToken: config.authToken } : {},
 			...isLocalDb ? { timeout: DEFAULT_CONNECTION_TIMEOUT_MS } : {}
 		});
-		this.#client = isSingleConnectionDatabase(config) ? gateSingleConnectionClient(client) : client;
+		this.#client = isSingleConnectionDatabase(config) ? gateSingleConnectionClient(client) : isLocalDb ? gateIfLocalFile(resetConnectionsAfterBusy(client, { maxWaitMs: DEFAULT_CONNECTION_TIMEOUT_MS }), config.url, { maxWaitMs: DEFAULT_CONNECTION_TIMEOUT_MS }) : client;
 		this.ops = new LibSQLFactoryStorageOps(this.#client, this.#schemas, (fn) => withClientWriteLock(this.#client, fn));
 	}
 	getMastraStorage() {
@@ -15754,7 +16417,10 @@ var LibSQLStore = class extends _mastra_core_storage.MastraCompositeStore {
 				...config.syncInterval !== void 0 ? { syncInterval: config.syncInterval } : {},
 				...this.isLocalDb ? { timeout: this.connectionTimeoutMs } : {}
 			});
-			this.client = isSingleConnectionDatabase(config) ? gateSingleConnectionClient(client) : client;
+			this.client = isSingleConnectionDatabase(config) ? gateSingleConnectionClient(client) : this.isLocalDb ? gateIfLocalFile(resetConnectionsAfterBusy(client, {
+				afterReset: () => this.applyLocalPragmas(client),
+				maxWaitMs: this.connectionTimeoutMs
+			}), config.url, { maxWaitMs: this.connectionTimeoutMs }) : client;
 			this.pragmasReady = this.isLocalDb ? this.applyLocalPragmas() : Promise.resolve();
 		} else {
 			this.client = config.client;
@@ -15820,7 +16486,7 @@ var LibSQLStore = class extends _mastra_core_storage.MastraCompositeStore {
 			threadState
 		};
 	}
-	async applyLocalPragmas() {
+	async applyLocalPragmas(client = this.client) {
 		const pragmas = [
 			["journal_mode=WAL", "PRAGMA journal_mode=WAL;"],
 			[`busy_timeout=${this.connectionTimeoutMs}`, `PRAGMA busy_timeout=${this.connectionTimeoutMs};`],
@@ -15830,7 +16496,7 @@ var LibSQLStore = class extends _mastra_core_storage.MastraCompositeStore {
 			[`mmap_size=${this.localPragmas.mmapSize}`, `PRAGMA mmap_size=${this.localPragmas.mmapSize};`]
 		];
 		for (const [label, sql] of pragmas) try {
-			await this.client.execute(sql);
+			await client.execute(sql);
 			this.logger.debug(`LibSQLStore: PRAGMA ${label} set.`);
 		} catch (err) {
 			this.logger.warn(`LibSQLStore: Failed to set PRAGMA ${label}.`, err);