@mastra/libsql 0.0.0-knowledge-w2-20261007223745 → 0.0.0-knowledge-w2-20261008040304

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-libsql
 description: Documentation for @mastra/libsql. Use when working with @mastra/libsql APIs, configuration, or implementation.
 metadata:
   package: "@mastra/libsql"
-  version: "0.0.0-knowledge-w2-20261007223745"
+  version: "0.0.0-knowledge-w2-20261008040304"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.0-knowledge-w2-20261007223745",
+  "version": "0.0.0-knowledge-w2-20261008040304",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-agents-human-in-the-loop.md

@@ -125,7 +125,7 @@ import { agent } from './agent'
 
 const approvalClassifier = new Classifier({
   id: 'tool-approval-classifier',
-  model: typeSafeAi.evaluationModel('jev-latest'),
+  model: typeSafeAi.decisionModel('jev-latest'),
   questions: {
     requiresApproval: {
       type: 'boolean',
@@ -137,7 +137,7 @@ const approvalClassifier = new Classifier({
 
 const stream = await agent.stream('Clean up old records', {
   requireToolApproval: async ({ toolName, args }) => {
-    const result = await approvalClassifier.evaluate({
+    const result = await approvalClassifier.decide({
       state: {
         toolName,
         argumentNames: Object.keys(args),
@@ -149,7 +149,7 @@ const stream = await agent.stream('Clean up old records', {
 })
 ```
 
-The example sends argument names rather than values because the classifier forwards its state to the configured evaluation model. If the decision requires argument values, redact sensitive data first or use an evaluation model and provider that meet the protected tool's data-handling requirements.
+The example sends argument names rather than values because the classifier forwards its state to the configured decision model. If the decision requires argument values, redact sensitive data first or use a decision model and provider that meet the protected tool's data-handling requirements.
 
 Returning `true` pauses the tool call for human approval. It doesn't approve or decline the call automatically. Choose a threshold that matches the risk of the tools available to the agent. If this `requireToolApproval` function throws, it defaults to requiring approval.
 

package/dist/docs/references/docs-memory-memory-processors.md

@@ -99,7 +99,7 @@ import { Agent } from '@mastra/core/agent'
 import { Memory } from '@mastra/memory'
 import { LibSQLStore } from '@mastra/libsql'
 import { PineconeVector } from '@mastra/pinecone'
-import { OpenAIEmbedder } from '@mastra/openai'
+import { ModelRouterEmbeddingModel } from '@mastra/core/llm'
 import { openai } from '@ai-sdk/openai'
 
 const agent = new Agent({
@@ -115,10 +115,7 @@ const agent = new Agent({
       id: 'memory-vector',
       apiKey: process.env.PINECONE_API_KEY!,
     }),
-    embedder: new OpenAIEmbedder({
-      model: 'text-embedding-3-small',
-      apiKey: process.env.OPENAI_API_KEY!,
-    }),
+    embedder: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'),
     semanticRecall: { enabled: true }, // SemanticRecall processor automatically added
   }),
 })

package/dist/docs/references/docs-memory-semantic-recall.md

@@ -411,11 +411,11 @@ PostgreSQL supports both IVFFlat and HNSW indexes. By default, Mastra creates an
 
 ```typescript
 import { Memory } from '@mastra/memory'
-import { PgStore, PgVector } from '@mastra/pg'
+import { PostgresStore, PgVector } from '@mastra/pg'
 
 const agent = new Agent({
   memory: new Memory({
-    storage: new PgStore({
+    storage: new PostgresStore({
       id: 'agent-storage',
       connectionString: process.env.DATABASE_URL,
     }),

package/dist/docs/references/docs-memory-working-memory.md

@@ -272,6 +272,22 @@ Schema-based working memory uses **merge semantics**, meaning the agent only nee
 - **Set a field to `null` to delete it:** This explicitly removes the field from memory
 - **Arrays are replaced entirely:** When an array field is provided, it replaces the existing array (arrays aren't merged element-by-element)
 
+### Concurrent updates
+
+With `scope: 'resource'` and a storage adapter that supports atomic merges (currently `@mastra/pg`), each merge runs inside a row-locked database transaction. Concurrent updates to different fields from separate processes are all kept. Other adapters merge in the application, which only serializes writers inside a single process.
+
+To merge a partial update from your own code, call `memory.mergeWorkingMemory()`:
+
+```typescript
+await memory.mergeWorkingMemory({
+  threadId: 'thread-1',
+  resourceId: 'user-123',
+  workingMemory: { preferences: { tone: 'formal' } },
+})
+```
+
+It throws if working memory isn't schema-based and resource-scoped, or if the storage adapter doesn't support atomic merges. Check `await memory.supportsAtomicWorkingMemoryMerge()` first if you need to fall back.
+
 ## Choosing between template and schema
 
 - Use a **template** (Markdown) if you want the agent to maintain memory as a free-form text block, such as a user profile or scratchpad. Templates use **replace semantics**: the agent must provide the complete memory content on each update.

package/dist/docs/references/reference-memory-memory-class.md

@@ -101,14 +101,14 @@ export const agent = new Agent({
 import { Memory } from '@mastra/memory'
 import { Agent } from '@mastra/core/agent'
 import { ModelRouterEmbeddingModel } from '@mastra/core/llm'
-import { PgStore, PgVector } from '@mastra/pg'
+import { PostgresStore, PgVector } from '@mastra/pg'
 
 export const agent = new Agent({
   name: 'pg-agent',
   instructions: 'You are an agent with optimized PostgreSQL memory.',
   model: 'openai/gpt-5.6-sol',
   memory: new Memory({
-    storage: new PgStore({
+    storage: new PostgresStore({
       id: 'pg-agent-storage',
       connectionString: process.env.DATABASE_URL,
     }),

package/dist/index.cjs

@@ -6748,7 +6748,7 @@ var KnowledgeLibSQL = class extends _mastra_core_storage.KnowledgeStorage {
 		const { KnowledgeSchemaError } = await loadKnowledgeCore();
 		const existingTables = await this.#client.execute("SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'mastra_knowledge_%'");
 		const existingNames = new Set(existingTables.rows.map((row) => String(row.name)));
-		if (existingNames.size > 0 && !existingNames.has("mastra_knowledge_schema") && await this.#replaceEmptyPublishedV1()) existingNames.clear();
+		if (existingNames.size > 0 && !existingNames.has("mastra_knowledge_schema") && await this.#replacePublishedV1()) existingNames.clear();
 		if (existingNames.size > 0) {
 			if (!existingNames.has("mastra_knowledge_schema")) throw new KnowledgeSchemaError(`Knowledge schema reset required: the existing Knowledge schema has no completion marker. ${KNOWLEDGE_RESET_GUIDANCE}`);
 			const marker = await this.#client.execute(`SELECT version FROM ${TABLE_KNOWLEDGE_SCHEMA} WHERE id = 'canonical'`);
@@ -6834,7 +6834,7 @@ var KnowledgeLibSQL = class extends _mastra_core_storage.KnowledgeStorage {
 		});
 		await this.#client.batch([
 			{
-				sql: `CREATE INDEX IF NOT EXISTS idx_knowledge_nodes_name ON "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (name)`,
+				sql: `CREATE INDEX IF NOT EXISTS idx_knowledge_nodes_name ON "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (lower(name))`,
 				args: []
 			},
 			{
@@ -6892,12 +6892,12 @@ var KnowledgeLibSQL = class extends _mastra_core_storage.KnowledgeStorage {
 		});
 	}
 	/**
-	* Earlier releases created empty Knowledge tables for every app. When exactly that layout and its
-	* indexes are the only Knowledge objects, drop it so canonical storage can initialize; replacing it
-	* loses nothing. Rows, partial or unfamiliar tables, views, triggers, and extra indexes all leave the
-	* database untouched.
+	* Knowledge v1 was experimental and its data is not migrated. When exactly the published v1 tables
+	* and indexes are the only Knowledge objects, drop them, discarding any rows they hold, so canonical
+	* storage can initialize. Partial or unfamiliar tables, views, triggers, and extra indexes all leave
+	* the database untouched.
 	*/
-	async #replaceEmptyPublishedV1() {
+	async #replacePublishedV1() {
 		return this.#transaction(async (tx) => {
 			const objects = await tx.execute("SELECT type, name FROM sqlite_master WHERE name LIKE 'mastra\\_knowledge\\_%' ESCAPE '\\' OR tbl_name LIKE 'mastra\\_knowledge\\_%' ESCAPE '\\' OR sql LIKE '%mastra\\_knowledge\\_%' ESCAPE '\\'");
 			const tables = [];
@@ -6917,7 +6917,6 @@ var KnowledgeLibSQL = class extends _mastra_core_storage.KnowledgeStorage {
 				columnsByTable.set(table, columns.rows.map((row) => String(row.name)));
 			}
 			if (!isPublishedKnowledgeV1Layout(columnsByTable)) return false;
-			for (const table of tables) if ((await tx.execute(`SELECT 1 FROM "${table}" LIMIT 1`)).rows.length > 0) return false;
 			for (const table of tables) await tx.execute(`DROP TABLE "${table}"`);
 			return true;
 		});
@@ -7006,6 +7005,10 @@ var KnowledgeLibSQL = class extends _mastra_core_storage.KnowledgeStorage {
 						}) : void 0)?.rows.length) continue;
 						throw new Error(`Knowledge parent scope does not exist: ${parentAddress}`);
 					}
+					if ((await tx.execute({
+						sql: `SELECT 1 FROM "mastra_knowledge_node_scopes" WHERE nodeId=? AND scopeNodeId=?`,
+						args: [scopeNodeId, parentId]
+					})).rows.length) continue;
 					if ((await tx.execute({
 						sql: `SELECT n.id FROM "mastra_knowledge_node_scopes" ns JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" n ON n.id=ns.nodeId WHERE ns.scopeNodeId=? AND lower(n.name)=? AND n.deletedAt IS NULL AND n.id<>? LIMIT 1`,
 						args: [
@@ -9448,6 +9451,14 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			initialBackoffMs: config.initialBackoffMs
 		});
 	}
+	/**
+	* Runs a write behind the per-client write lock and retries it on transient SQLite lock
+	* errors (`SQLITE_BUSY`), like the shared `LibSQLDB` writes. Each retry re-queues on the lock.
+	* `fn` must be safe to rerun: a single statement, a batch, or a transaction that rolls back.
+	*/
+	#write(operation, fn) {
+		return this.#db.executeWriteOperationWithRetry(() => withClientWriteLock(this.#client, fn), operation);
+	}
 	async init() {
 		await this.#db.createTable({
 			tableName: _mastra_core_storage.TABLE_THREADS,
@@ -9947,13 +9958,11 @@ 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];
-			await withClientWriteLock(this.#client, async () => {
-				for (let i = 0; i < messageStatements.length; i += BATCH_SIZE) {
-					const batch = messageStatements.slice(i, i + BATCH_SIZE);
-					if (batch.length > 0) await this.#client.batch(batch, "write");
-				}
-				if (threadUpdateStatement) await this.#client.execute(threadUpdateStatement);
-			});
+			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));
 			return { messages: new _mastra_core_agent.MessageList().add(messages, "memory").get.all.db() };
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
@@ -10019,7 +10028,7 @@ 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.#client.batch(batchStatements, "write");
+		await this.#write("updateMessages", () => this.#client.batch(batchStatements, "write"));
 		return (await this.#client.execute({
 			sql: selectSql,
 			args: messageIds
@@ -10029,35 +10038,37 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 		if (!messageIds || messageIds.length === 0) return;
 		try {
 			const BATCH_SIZE = 100;
-			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 this.#write("deleteMessages", async () => {
+				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;
 				}
-				await tx.commit();
-			} catch (error) {
-				await tx.rollback();
-				throw error;
-			}
+			});
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "DELETE_MESSAGES", "FAILED"),
@@ -10122,10 +10133,10 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 		updates.push("updatedAt = ?");
 		values.push(updatedResource.updatedAt.toISOString());
 		values.push(resourceId);
-		await this.#client.execute({
+		await this.#write("updateResource", () => this.#client.execute({
 			sql: `UPDATE ${_mastra_core_storage.TABLE_RESOURCES} SET ${updates.join(", ")} WHERE id = ?`,
 			args: values
-		});
+		}));
 		return updatedResource;
 	}
 	async getThreadById({ threadId, resourceId }) {
@@ -10162,49 +10173,51 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	*/
 	async updateThreadResourceId({ threadId, resourceId }) {
 		try {
-			const tx = await this.#client.transaction("write");
-			try {
-				const row = (await tx.execute({
-					sql: `SELECT * FROM "${_mastra_core_storage.TABLE_THREADS}" WHERE id = ?`,
-					args: [threadId]
-				})).rows?.[0];
-				if (!row) throw new Error(`Thread "${threadId}" not found`);
-				const currentResourceId = row.resourceId;
-				const normalized = {
-					id: row.id,
-					resourceId: currentResourceId,
-					title: row.title,
-					metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
-					createdAt: new Date(row.createdAt),
-					updatedAt: new Date(row.updatedAt)
-				};
-				if (currentResourceId === resourceId) {
+			return await this.#write("updateThreadResourceId", async () => {
+				const tx = await this.#client.transaction("write");
+				try {
+					const row = (await tx.execute({
+						sql: `SELECT * FROM "${_mastra_core_storage.TABLE_THREADS}" WHERE id = ?`,
+						args: [threadId]
+					})).rows?.[0];
+					if (!row) throw new Error(`Thread "${threadId}" not found`);
+					const currentResourceId = row.resourceId;
+					const normalized = {
+						id: row.id,
+						resourceId: currentResourceId,
+						title: row.title,
+						metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
+						createdAt: new Date(row.createdAt),
+						updatedAt: new Date(row.updatedAt)
+					};
+					if (currentResourceId === resourceId) {
+						await tx.commit();
+						return normalized;
+					}
+					const now = /* @__PURE__ */ new Date();
+					await tx.execute({
+						sql: `UPDATE "${_mastra_core_storage.TABLE_THREADS}" SET "resourceId" = ?, "updatedAt" = ? WHERE id = ?`,
+						args: [
+							resourceId,
+							now.toISOString(),
+							threadId
+						]
+					});
+					await tx.execute({
+						sql: `UPDATE "${_mastra_core_storage.TABLE_MESSAGES}" SET "resourceId" = ? WHERE thread_id = ?`,
+						args: [resourceId, threadId]
+					});
 					await tx.commit();
-					return normalized;
-				}
-				const now = /* @__PURE__ */ new Date();
-				await tx.execute({
-					sql: `UPDATE "${_mastra_core_storage.TABLE_THREADS}" SET "resourceId" = ?, "updatedAt" = ? WHERE id = ?`,
-					args: [
+					return {
+						...normalized,
 						resourceId,
-						now.toISOString(),
-						threadId
-					]
-				});
-				await tx.execute({
-					sql: `UPDATE "${_mastra_core_storage.TABLE_MESSAGES}" SET "resourceId" = ? WHERE thread_id = ?`,
-					args: [resourceId, threadId]
-				});
-				await tx.commit();
-				return {
-					...normalized,
-					resourceId,
-					updatedAt: now
-				};
-			} catch (error) {
-				await tx.rollback();
-				throw error;
-			}
+						updatedAt: now
+					};
+				} catch (error) {
+					await tx.rollback();
+					throw error;
+				}
+			});
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "UPDATE_THREAD_RESOURCE_ID", "FAILED"),
@@ -10366,7 +10379,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			updatedAt: now
 		};
 		try {
-			await this.#client.execute({
+			await this.#write("updateThread", () => this.#client.execute({
 				sql: `UPDATE ${_mastra_core_storage.TABLE_THREADS} SET title = COALESCE(?, title), metadata = jsonb(?), updatedAt = ? WHERE id = ?`,
 				args: [
 					title ?? null,
@@ -10374,7 +10387,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 					now.toISOString(),
 					id
 				]
-			});
+			}));
 			return updatedThread;
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
@@ -10388,14 +10401,14 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async deleteThread({ threadId }) {
 		try {
-			await this.#client.execute({
+			await this.#write("deleteThread", () => this.#client.execute({
 				sql: `DELETE FROM ${_mastra_core_storage.TABLE_MESSAGES} WHERE thread_id = ?`,
 				args: [threadId]
-			});
-			await this.#client.execute({
+			}));
+			await this.#write("deleteThread", () => this.#client.execute({
 				sql: `DELETE FROM ${_mastra_core_storage.TABLE_THREADS} WHERE id = ?`,
 				args: [threadId]
-			});
+			}));
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "DELETE_THREAD", "FAILED"),
@@ -10468,48 +10481,50 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 				createdAt: now,
 				updatedAt: now
 			};
-			const tx = await this.#client.transaction("write");
-			try {
-				await tx.execute({
-					sql: `INSERT INTO "${_mastra_core_storage.TABLE_THREADS}" (id, "resourceId", title, metadata, "createdAt", "updatedAt")
-                VALUES (?, ?, ?, jsonb(?), ?, ?)`,
-					args: [
-						newThread.id,
-						newThread.resourceId,
-						newThread.title ?? "",
-						JSON.stringify(newThread.metadata),
-						nowStr,
-						nowStr
-					]
-				});
-				const messageIdMap = {};
-				const targetResourceId = resourceId || sourceThread.resourceId;
-				for (const sourceMsg of sourceMessages) {
-					const newMessageId = crypto.randomUUID();
-					const sourceMsgId = sourceMsg.id;
-					messageIdMap[sourceMsgId] = newMessageId;
-					const insertResult = await tx.execute({
-						sql: `INSERT INTO "${_mastra_core_storage.TABLE_MESSAGES}" (id, thread_id, content, role, type, "createdAt", "resourceId")
-                  SELECT ?, ?, content, role, type, "createdAt", ?
-                  FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id = ?`,
+			return await this.#write("copyThread", async () => {
+				const tx = await this.#client.transaction("write");
+				try {
+					await tx.execute({
+						sql: `INSERT INTO "${_mastra_core_storage.TABLE_THREADS}" (id, "resourceId", title, metadata, "createdAt", "updatedAt")
+                  VALUES (?, ?, ?, jsonb(?), ?, ?)`,
 						args: [
-							newMessageId,
-							newThreadId,
-							targetResourceId,
-							sourceMsgId
+							newThread.id,
+							newThread.resourceId,
+							newThread.title ?? "",
+							JSON.stringify(newThread.metadata),
+							nowStr,
+							nowStr
 						]
 					});
-					if (insertResult.rowsAffected !== 1) throw new Error(`Failed to copy message ${sourceMsgId}: expected 1 row copied but got ${insertResult.rowsAffected}`);
+					const messageIdMap = {};
+					const targetResourceId = resourceId || sourceThread.resourceId;
+					for (const sourceMsg of sourceMessages) {
+						const newMessageId = crypto.randomUUID();
+						const sourceMsgId = sourceMsg.id;
+						messageIdMap[sourceMsgId] = newMessageId;
+						const insertResult = await tx.execute({
+							sql: `INSERT INTO "${_mastra_core_storage.TABLE_MESSAGES}" (id, thread_id, content, role, type, "createdAt", "resourceId")
+                    SELECT ?, ?, content, role, type, "createdAt", ?
+                    FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id = ?`,
+							args: [
+								newMessageId,
+								newThreadId,
+								targetResourceId,
+								sourceMsgId
+							]
+						});
+						if (insertResult.rowsAffected !== 1) throw new Error(`Failed to copy message ${sourceMsgId}: expected 1 row copied but got ${insertResult.rowsAffected}`);
+					}
+					await tx.commit();
+					return {
+						thread: newThread,
+						messageIdMap
+					};
+				} catch (error) {
+					await tx.rollback();
+					throw error;
 				}
-				await tx.commit();
-				return {
-					thread: newThread,
-					messageIdMap
-				};
-			} catch (error) {
-				await tx.rollback();
-				throw error;
-			}
+			});
 		} catch (error) {
 			if (error instanceof _mastra_core_error.MastraError) throw error;
 			throw new _mastra_core_error.MastraError({
@@ -10669,7 +10684,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 				config: input.config,
 				observedTimezone: input.observedTimezone
 			};
-			await withClientWriteLock(this.#client, () => this.#client.execute({
+			await this.#write("initializeObservationalMemory", () => this.#client.execute({
 				sql: `INSERT INTO "${OM_TABLE}" (
             id, "lookupKey", scope, "resourceId", "threadId",
             "activeObservations", "activeObservationsPendingUpdate",
@@ -10721,7 +10736,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async insertObservationalMemoryRecord(record) {
 		try {
 			const lookupKey = this.getOMKey(record.threadId, record.resourceId);
-			await withClientWriteLock(this.#client, () => this.#client.execute({
+			await this.#write("insertObservationalMemoryRecord", () => this.#client.execute({
 				sql: `INSERT INTO "${OM_TABLE}" (
             id, "lookupKey", scope, "resourceId", "threadId",
             "activeObservations", "activeObservationsPendingUpdate",
@@ -10785,7 +10800,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 withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("updateActiveObservations", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET
             "activeObservations" = ?,
             "lastObservedAt" = ?,
@@ -10823,7 +10838,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async createReflectionGeneration(input) {
 		try {
-			return await withClientWriteLock(this.#client, async () => {
+			return await this.#write("createReflectionGeneration", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const record = await this.#insertReflectionGeneration(tx, input);
@@ -10919,7 +10934,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async setReflectingFlag(id, isReflecting) {
 		try {
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setReflectingFlag", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET "isReflecting" = ?, "updatedAt" = ? WHERE id = ?`,
 				args: [
 					isReflecting,
@@ -10951,7 +10966,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async setObservingFlag(id, isObserving) {
 		try {
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setObservingFlag", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET "isObserving" = ?, "updatedAt" = ? WHERE id = ?`,
 				args: [
 					isObserving,
@@ -11002,7 +11017,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 					id
 				];
 			}
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setBufferingObservationFlag", () => this.#client.execute({
 				sql,
 				args
 			}))).rowsAffected === 0) throw new _mastra_core_error.MastraError({
@@ -11032,7 +11047,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async setBufferingReflectionFlag(id, isBuffering) {
 		try {
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setBufferingReflectionFlag", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET "isBufferingReflection" = ?, "updatedAt" = ? WHERE id = ?`,
 				args: [
 					isBuffering,
@@ -11065,7 +11080,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async clearObservationalMemory(threadId, resourceId) {
 		try {
 			const lookupKey = this.getOMKey(threadId, resourceId);
-			await withClientWriteLock(this.#client, () => this.#client.execute({
+			await this.#write("clearObservationalMemory", () => this.#client.execute({
 				sql: `DELETE FROM "${OM_TABLE}" WHERE "lookupKey" = ?`,
 				args: [lookupKey]
 			}));
@@ -11083,7 +11098,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async setPendingMessageTokens(id, tokenCount) {
 		try {
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setPendingMessageTokens", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET 
             "pendingMessageTokens" = ?, 
             "updatedAt" = ? 
@@ -11118,7 +11133,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async updateObservationalMemoryConfig(input) {
 		try {
-			await withClientWriteLock(this.#client, async () => {
+			await this.#write("updateObservationalMemoryConfig", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const selectResult = await tx.execute({
@@ -11162,7 +11177,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async updateBufferedObservations(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			await withClientWriteLock(this.#client, async () => {
+			await this.#write("updateBufferedObservations", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const current = await tx.execute({
@@ -11243,7 +11258,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async swapBufferedToActive(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			return await withClientWriteLock(this.#client, async () => {
+			return await this.#write("swapBufferedToActive", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const current = await tx.execute({
@@ -11392,7 +11407,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async updateBufferedReflection(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("updateBufferedReflection", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET
             "bufferedReflection" = CASE
               WHEN "bufferedReflection" IS NOT NULL AND "bufferedReflection" != ''
@@ -11432,7 +11447,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async swapBufferedReflectionToActive(input) {
 		try {
-			return await withClientWriteLock(this.#client, async () => {
+			return await this.#write("swapBufferedReflectionToActive", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const current = await tx.execute({