@mastra/libsql 1.29.0-alpha.2 → 1.30.0-alpha.0

package/dist/index.cjs

@@ -1862,6 +1862,21 @@ function resolveClient(config) {
 function assertPositiveLimit(limit) {
 	if (!Number.isSafeInteger(limit) || limit <= 0) throw new Error(`prune limit must be a positive integer; received ${limit}`);
 }
+/**
+* Parses JSON object/array text in the table's `jsonb` columns only. A `text` column, such as a
+* span preview of `{}`, must read back as the stored string.
+*/
+function parseJsonColumns(tableName, row) {
+	const schema = _mastra_core_storage.TABLE_SCHEMAS[tableName];
+	return Object.fromEntries(Object.entries(row).map(([k, v]) => {
+		if (schema[k]?.type !== "jsonb" || typeof v !== "string" || !(v.startsWith("{") || v.startsWith("["))) return [k, v];
+		try {
+			return [k, JSON.parse(v)];
+		} catch {
+			return [k, v];
+		}
+	}));
+}
 var LibSQLDB = class extends _mastra_core_base.MastraBase {
 	client;
 	maxRetries;
@@ -2157,7 +2172,7 @@ var LibSQLDB = class extends _mastra_core_base.MastraBase {
 	/**
 	* Selects a single record from the specified table by key(s).
 	* Returns the most recently created record if multiple matches exist.
-	* Automatically parses JSON string values back to objects/arrays.
+	* Parses `jsonb` column values back to objects/arrays.
 	*
 	* @typeParam R - The expected return type of the record
 	* @param args - The select arguments
@@ -2175,14 +2190,7 @@ var LibSQLDB = class extends _mastra_core_base.MastraBase {
 			args: values
 		});
 		if (!result.rows || result.rows.length === 0) return null;
-		const row = result.rows[0];
-		return Object.fromEntries(Object.entries(row || {}).map(([k, v]) => {
-			try {
-				return [k, typeof v === "string" ? v.startsWith("{") || v.startsWith("[") ? JSON.parse(v) : v : v];
-			} catch {
-				return [k, v];
-			}
-		}));
+		return parseJsonColumns(tableName, result.rows[0] ?? {});
 	}
 	/**
 	* Selects multiple records from the specified table with optional filtering, ordering, and pagination.
@@ -2207,15 +2215,7 @@ var LibSQLDB = class extends _mastra_core_base.MastraBase {
 		return ((await this.client.execute({
 			sql: statement,
 			args: [...whereClause?.args ?? [], ...args ?? []]
-		})).rows ?? []).map((row) => {
-			return Object.fromEntries(Object.entries(row || {}).map(([k, v]) => {
-				try {
-					return [k, typeof v === "string" ? v.startsWith("{") || v.startsWith("[") ? JSON.parse(v) : v : v];
-				} catch {
-					return [k, v];
-				}
-			}));
-		});
+		})).rows ?? []).map((row) => parseJsonColumns(tableName, row ?? {}));
 	}
 	/**
 	* Returns the total count of records matching the optional WHERE clause.
@@ -3363,14 +3363,14 @@ function cutoffFor(policy, anchorType, now = Date.now()) {
 	return anchorType === "epoch-ms" ? cutoffMs : new Date(cutoffMs).toISOString();
 }
 const runBatchedDelete = _mastra_core_storage.runRetentionBatches;
-function runPrune({ db, domain, targets, options, logger }) {
+function runPrune({ db, domain, targets, options, logger, deleteBatch }) {
 	return (0, _mastra_core_storage.executeRetentionPrune)({
 		domain,
 		targets,
 		options,
 		beforeTarget: (target) => ensureAnchorIndex(db, target, logger),
 		cutoffFor: (target, now) => cutoffFor(target.policy, target.anchorType ?? "timestamp", now),
-		deleteBatch: (target, cutoff, limit) => db.pruneBatch({
+		deleteBatch: (target, cutoff, limit) => deleteBatch?.(target, cutoff, limit) ?? db.pruneBatch({
 			tableName: target.table,
 			column: target.column,
 			cutoff,
@@ -15136,6 +15136,228 @@ var WorkflowDefinitionsLibSQL = class extends _mastra_core_storage.WorkflowDefin
 };
 // src/storage/domains/workflows/index.ts
 const RUN_OWNER_COLUMNS = `generation, ownerId, leaseExpiresAt, ${DB_NOW_MS} AS nowMs`;
+/**
+* The entries a storage v2 write adds: one per step, in order, then one per step patch, then the
+* state or state base (a checkpoint with neither starts the state over at `{}`), then the state
+* patch unless a full state was given.
+*/
+function journalEntries(steps, { state, stateBase, statePatch }, checkpoint, stepPatches = {}) {
+	const entries = Object.entries(steps).map(([stepId, result]) => ({
+		kind: "step",
+		step_id: stepId,
+		payload: result
+	}));
+	for (const [stepId, ops] of Object.entries(stepPatches)) entries.push({
+		kind: "step-patch",
+		step_id: stepId,
+		payload: ops
+	});
+	if (state !== void 0) entries.push({
+		kind: "state",
+		step_id: null,
+		payload: state
+	});
+	else if (stateBase !== void 0) entries.push({
+		kind: "state-base",
+		step_id: null,
+		payload: stateBase
+	});
+	else if (checkpoint) entries.push({
+		kind: "state",
+		step_id: null,
+		payload: {}
+	});
+	if (state === void 0 && statePatch !== void 0) entries.push({
+		kind: "state-patch",
+		step_id: null,
+		payload: statePatch
+	});
+	return entries;
+}
+/**
+* Upserts a storage v2 run's header, adds `entryCount` (the number of entries the write adds) to
+* its `lastSeq`, for {@link insertEntries} to number them up to, and returns the new `lastSeq` and
+* the `runToken` (picked when the write creates the run, otherwise the stored one). A checkpoint's
+* state entries come last, so its `startStateSeq` is the new `lastSeq`; an append keeps the stored
+* one unless given `startStateSeq`.
+*/
+function upsertHeader(run, entryCount, write) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const startStateSeq = write.checkpoint ? {
+		insert: "?",
+		update: `${_mastra_core_storage.TABLE_WORKFLOW_RUNS}.lastSeq + excluded.lastSeq`,
+		args: [entryCount]
+	} : {
+		insert: "COALESCE(?, 0)",
+		update: `COALESCE(?, ${_mastra_core_storage.TABLE_WORKFLOW_RUNS}.startStateSeq)`,
+		args: [write.startStateSeq ?? null]
+	};
+	return {
+		sql: `INSERT INTO ${_mastra_core_storage.TABLE_WORKFLOW_RUNS}
+        (workflow_name, run_id, resourceId, threadId, status, header, lastSeq, startStateSeq, stateShared, runToken, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, jsonb(?), ?, ${startStateSeq.insert}, 0, ?, ?, ?)
+      ON CONFLICT(workflow_name, run_id) DO UPDATE SET
+        resourceId = COALESCE(excluded.resourceId, ${_mastra_core_storage.TABLE_WORKFLOW_RUNS}.resourceId), threadId = excluded.threadId,
+        status = excluded.status, header = excluded.header, lastSeq = ${_mastra_core_storage.TABLE_WORKFLOW_RUNS}.lastSeq + excluded.lastSeq,
+        startStateSeq = ${startStateSeq.update}, updatedAt = excluded.updatedAt
+      RETURNING lastSeq, runToken`,
+		args: [
+			run.workflowName,
+			run.runId,
+			run.resourceId ?? null,
+			run.threadId ?? null,
+			run.header.status,
+			safeStringify(run.header),
+			entryCount,
+			...startStateSeq.args,
+			crypto.randomUUID(),
+			now,
+			now,
+			...write.checkpoint ? [] : startStateSeq.args
+		]
+	};
+}
+/**
+* Inserts the entries in the JSON array parameter after the run's header has been bumped by
+* their count, numbering them up to the header's `lastSeq`. `-> '$.payload'` keeps a JSON null
+* apart from an undefined payload (dropped by `JSON.stringify`), which becomes SQL NULL.
+* Args: entry count, entries JSON, workflow name, run id.
+*/
+const INSERT_ENTRIES = `INSERT INTO ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} (workflow_name, run_id, seq, kind, step_id, payload)
+  SELECT h.workflow_name, h.run_id, h.lastSeq - ? + j.key + 1, j.value ->> '$.kind', j.value ->> '$.step_id', jsonb(j.value -> '$.payload')
+  FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} h, json_each(?) j
+  WHERE h.workflow_name = ? AND h.run_id = ?`;
+function insertEntries(run, entries) {
+	return {
+		sql: INSERT_ENTRIES,
+		args: [
+			entries.length,
+			safeStringify(entries),
+			run.workflowName,
+			run.runId
+		]
+	};
+}
+/**
+* The run a `state-base` entry's payload names: the expressions of the state base index, which
+* a lookup must repeat exactly to use it.
+*/
+const STATE_BASE_WORKFLOW_EXPR = `payload ->> '$.workflowName'`;
+const STATE_BASE_RUN_EXPR = `payload ->> '$.runId'`;
+/**
+* A JSON array of {@link EntryRow} for the storage v2 run `alias` refers to: each step's
+* latest entry, the step patches after it (for `latestStepResults`), and the entries
+* `materializeState` uses for the latest state: the latest full state or state base and every
+* state patch after it. Drafts are left out.
+*
+* With `summary`, successful steps other than `input` come back as their summary, built here
+* so their data is never sent, unless step patches follow it (the caller summarizes the patched
+* result instead). Like `summarizeStepResult`, it keeps a field that is JSON null
+* and leaves out one that is absent. It then takes one arg, `STEP_RESULT_SUMMARY_FIELDS` as
+* JSON, bound where this SQL sits in the statement.
+*/
+function entriesSql(alias, { summary } = {}) {
+	let payload = "json(x.payload)";
+	if (summary) {
+		const summarized = `(x.kind = 'step' AND x.step_id <> 'input' AND x.payload ->> '$.status' = 'success'
+      AND (x.patch_seq IS NULL OR x.patch_seq < x.seq))`;
+		payload = `json(CASE WHEN ${summarized} THEN (
+          SELECT json_group_object(f.key, json(x.payload -> f.fullkey))
+          FROM json_each(x.payload) f WHERE f.key IN (SELECT value FROM json_each(?))
+        ) ELSE x.payload END), 'summarized', ${summarized}`;
+	}
+	return `(SELECT json_group_array(json_object(
+        'seq', x.seq, 'ord', CASE WHEN x.kind = 'step' THEN x.first_seq ELSE x.seq END, 'kind', x.kind, 'step_id', x.step_id,
+        'absent', x.payload IS NULL, 'payload', ${payload}
+      ))
+    FROM (
+      SELECT e.seq, e.kind, e.step_id, e.payload,
+        ROW_NUMBER() OVER (PARTITION BY e.kind, e.step_id ORDER BY e.seq DESC) AS rn,
+        MIN(e.seq) OVER (PARTITION BY e.kind, e.step_id) AS first_seq,
+        MAX(CASE WHEN e.kind = 'step' THEN e.seq END) OVER (PARTITION BY e.step_id) AS step_seq,
+        MAX(CASE WHEN e.kind = 'step-patch' THEN e.seq END) OVER (PARTITION BY e.step_id) AS patch_seq,
+        MAX(CASE WHEN e.kind IN ('state', 'state-base') THEN e.seq END) OVER () AS base_seq
+      FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} e
+      WHERE e.workflow_name = ${alias}.workflow_name AND e.run_id = ${alias}.run_id AND e.kind <> 'state-draft'
+    ) x
+    WHERE CASE x.kind
+      WHEN 'step' THEN x.rn = 1
+      WHEN 'step-patch' THEN x.seq > x.step_seq
+      ELSE x.base_seq IS NULL OR x.seq >= x.base_seq
+    END)`;
+}
+/**
+* A JSON array of {@link EntryRow} with the entries `materializeState` uses for the state of the
+* storage v2 run `alias` refers to as of a version. For a draft, every state entry up to it, as
+* the drafts it is on can build on any earlier version; otherwise the latest full state or state
+* base up to it and the state patches after it. Takes two args, bound where this SQL sits in the
+* statement: the version's `seq`, then 1 when it is a draft, else 0.
+*/
+function stateEntriesSql(alias) {
+	return `(SELECT json_group_array(json_object(
+        'seq', x.seq, 'ord', x.seq, 'kind', x.kind, 'step_id', x.step_id, 'absent', x.payload IS NULL, 'payload', json(x.payload)
+      ))
+    FROM (
+      SELECT e.seq, e.kind, e.step_id, e.payload,
+        MAX(CASE WHEN e.kind IN ('state', 'state-base') THEN e.seq END) OVER () AS base_seq
+      FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} e
+      WHERE e.workflow_name = ${alias}.workflow_name AND e.run_id = ${alias}.run_id
+        AND e.kind NOT IN ('step', 'step-patch') AND e.seq <= ?
+    ) x
+    WHERE ? OR (x.kind <> 'state-draft' AND (x.base_seq IS NULL OR x.seq >= x.base_seq)))`;
+}
+/** `entriesSql`, `stateEntriesSql` or `loadWorkflowRunSteps` rows, in the order to apply them. */
+function entryRows(json) {
+	return JSON.parse(json).sort((a, b) => a.ord - b.ord);
+}
+/** The entries of {@link entryRows}; an undefined payload reads back as undefined, as in v1. */
+function toEntries(rows) {
+	return rows.map((row) => {
+		const payload = row.absent ? void 0 : row.payload;
+		switch (row.kind) {
+			case "step": return {
+				seq: row.seq,
+				kind: "step",
+				stepId: row.step_id,
+				result: payload
+			};
+			case "step-patch": return {
+				seq: row.seq,
+				kind: "step-patch",
+				stepId: row.step_id,
+				ops: payload
+			};
+			case "state": return {
+				seq: row.seq,
+				kind: "state",
+				state: payload
+			};
+			case "state-patch": return {
+				seq: row.seq,
+				kind: "state-patch",
+				ops: payload
+			};
+			case "state-base": return {
+				seq: row.seq,
+				kind: "state-base",
+				base: payload
+			};
+			case "state-draft": {
+				const draft = payload;
+				return "state" in draft ? {
+					seq: row.seq,
+					kind: "state-draft",
+					state: draft.state
+				} : {
+					seq: row.seq,
+					kind: "state-draft",
+					on: draft.on,
+					ops: draft.ops
+				};
+			}
+		}
+	});
+}
 function toRunOwnershipRecord(runId, row) {
 	const leaseExpiresAt = row.leaseExpiresAt === null ? null : Number(row.leaseExpiresAt);
 	return {
@@ -15226,14 +15448,36 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
 			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS]
 		});
+		for (const [tableName, config] of Object.entries(_mastra_core_storage.WORKFLOW_RUN_JOURNAL_TABLE_CONFIGS)) await this.#db.createTable({
+			tableName,
+			schema: config.columns,
+			compositePrimaryKey: config.compositePrimaryKey
+		});
+		await withClientWriteLock(this.#client, () => this.#client.batch([
+			`CREATE INDEX IF NOT EXISTS mastra_workflow_runs_name_createdat_idx ON ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} (workflow_name, createdAt DESC)`,
+			`CREATE INDEX IF NOT EXISTS mastra_workflow_runs_name_status_createdat_idx ON ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} (workflow_name, status, createdAt DESC)`,
+			`CREATE INDEX IF NOT EXISTS mastra_workflow_runs_threadid_idx ON ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} (threadId)`,
+			`CREATE INDEX IF NOT EXISTS mastra_workflow_run_entries_step_idx ON ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} (workflow_name, run_id, kind, step_id, seq)`,
+			`CREATE INDEX IF NOT EXISTS mastra_workflow_run_entries_state_base_idx ON ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES}
+            (${STATE_BASE_WORKFLOW_EXPR}, ${STATE_BASE_RUN_EXPR}) WHERE kind = 'state-base'`
+		].map((sql) => ({
+			sql,
+			args: []
+		})), "write"));
 	}
 	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 });
+		await this.#db.deleteData({ tableName: _mastra_core_storage.TABLE_WORKFLOW_RUNS });
+		await this.#db.deleteData({ tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES });
 	}
 	supportsRunFencing() {
 		return true;
 	}
+	/** @experimental */
+	supportsRunJournal() {
+		return true;
+	}
 	#runFenceCheck(fence, runId, operation) {
 		const resolved = (0, _mastra_core_storage.resolveRunFence)(this, fence, runId);
 		return resolved && {
@@ -15242,6 +15486,399 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			operation
 		};
 	}
+	/**
+	* Runs a storage v2 write's statements behind the run's fence. With `expectedStatus` or
+	* `stateBase`, in a write transaction that first reads the stored run: it writes nothing
+	* (resolving to null) when the run is stored and its status doesn't match `expectedStatus`, and
+	* throws when the state version `stateBase` names isn't stored.
+	*/
+	#writeRun(check, run, { expectedStatus, stateBase }, statements) {
+		if (expectedStatus === void 0 && stateBase === void 0) return withRunFence(this.#client, check, (writer) => writer.batch(statements));
+		return inWriteTransaction(this.#client, async (tx) => {
+			if (check) await assertRunFence(tx, check);
+			if (expectedStatus !== void 0) {
+				const { rows } = await tx.execute({
+					sql: `SELECT status FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?`,
+					args: [run.workflowName, run.runId]
+				});
+				if (rows[0] && !(0, _mastra_core_storage.matchesExpectedWorkflowStatus)(rows[0].status, expectedStatus)) return null;
+			}
+			if (stateBase !== void 0) {
+				const { rows } = await tx.execute({
+					sql: `SELECT 1 FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} WHERE workflow_name = ? AND run_id = ?
+            AND CASE WHEN ? THEN kind = 'state-draft' AND seq = ? ELSE kind IN ('state', 'state-base') AND seq <= ? END
+            AND ? <= (SELECT lastSeq FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?)
+            LIMIT 1`,
+					args: [
+						stateBase.workflowName,
+						stateBase.runId,
+						stateBase.draft ? 1 : 0,
+						stateBase.seq,
+						stateBase.seq,
+						stateBase.seq,
+						stateBase.workflowName,
+						stateBase.runId
+					]
+				});
+				if (!rows[0]) throw new Error(`Workflow run ${run.workflowName}/${run.runId} builds on state version ${stateBase.seq} of ${stateBase.workflowName}/${stateBase.runId}, which is not stored`);
+			}
+			const results = [];
+			for (const statement of statements) results.push(await tx.execute(statement));
+			return results;
+		});
+	}
+	/**
+	* Selects v1 snapshot rows and storage v2 runs as one result, newest first. Each version
+	* has its own WHERE clause; `null` leaves it out. Storage v2 rows carry their header and
+	* entries, or in summary mode only the summary snapshot. `page` is appended to the
+	* combined, ordered rows (e.g. `LIMIT 1`). Bind the v1 args, then the v2 args, then `page`'s.
+	*/
+	#runsSql({ v1Where, v2Where, summary, page = "" }) {
+		const branches = [];
+		if (v1Where !== null) {
+			const snapshot = summary ? `json_object('status', json_extract(snapshot, '$.status'), 'timestamp', json_extract(snapshot, '$.timestamp'))` : "json(snapshot)";
+			branches.push(`SELECT workflow_name, run_id, resourceId, ${snapshot} AS snapshot, NULL AS header, createdAt, updatedAt, 1 AS version
+         FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} ${v1Where}`);
+		}
+		if (v2Where !== null) {
+			const columns = summary ? `json_object('status', status, 'timestamp', json_extract(header, '$.timestamp')) AS snapshot, NULL AS header` : "NULL AS snapshot, json(header) AS header";
+			branches.push(`SELECT workflow_name, run_id, resourceId, ${columns}, createdAt, updatedAt, 2 AS version
+         FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} ${v2Where}`);
+		}
+		return `SELECT p.*${summary ? "" : `, CASE WHEN p.version = 2 THEN ${entriesSql("p")} END AS entries`}
+      FROM (${branches.join(" UNION ALL ")} ORDER BY createdAt DESC ${page}) p
+      ORDER BY p.createdAt DESC`;
+	}
+	/**
+	* The `base` that `materializeState` takes for a run's entries (as of `at`, or latest): the state
+	* version of another run it builds on (`stateBaseOf`), resolved recursively, else undefined. `{}`
+	* when that run isn't stored. One query per run in the chain.
+	*/
+	async #stateBase(q, entries, at) {
+		const ref = (0, _mastra_core_storage.stateBaseOf)(entries, at);
+		if (!ref) return void 0;
+		return (await this.#stateAt(q, ref.workflowName, ref.runId, ref))?.state ?? {};
+	}
+	/** A storage v2 run's state as of the version `at`, or null when the run isn't stored. */
+	async #stateAt(q, workflowName, runId, at) {
+		const row = (await q.execute({
+			sql: `SELECT ${stateEntriesSql("r")} AS entries
+        FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} r WHERE r.workflow_name = ? AND r.run_id = ?`,
+			args: [
+				at.seq,
+				at.draft === true ? 1 : 0,
+				workflowName,
+				runId
+			]
+		})).rows[0];
+		if (!row) return null;
+		const entries = toEntries(entryRows(row.entries));
+		return (0, _mastra_core_storage.materializeState)(entries, {
+			at,
+			base: await this.#stateBase(q, entries, at)
+		});
+	}
+	/**
+	* Before a run is deleted, stores the full state in place of every `state-base` entry built on
+	* it, so the runs built on it keep reading the same state. Runs inside the delete's transaction.
+	*/
+	async #detachStateChildren(q, workflowName, runId) {
+		const children = await q.execute({
+			sql: `SELECT workflow_name, run_id, seq, json(payload) AS payload FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES}
+        WHERE kind = 'state-base' AND ${STATE_BASE_WORKFLOW_EXPR} = ? AND ${STATE_BASE_RUN_EXPR} = ?`,
+			args: [workflowName, runId]
+		});
+		const states = /* @__PURE__ */ new Map();
+		for (const child of children.rows) {
+			const ref = JSON.parse(child.payload);
+			const version = `${ref.seq}:${ref.draft === true}`;
+			let state = states.get(version);
+			if (!state) {
+				state = (await this.#stateAt(q, workflowName, runId, ref))?.state ?? {};
+				states.set(version, state);
+			}
+			await q.execute({
+				sql: `UPDATE ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} SET kind = 'state', payload = jsonb(?)
+          WHERE workflow_name = ? AND run_id = ? AND seq = ?`,
+				args: [
+					safeStringify(state),
+					child.workflow_name,
+					child.run_id,
+					child.seq
+				]
+			});
+		}
+	}
+	/** Rebuilds a storage v2 run's `WorkflowRunState` from its header and `entriesSql` JSON. */
+	async #materializeRun(q, header, rows) {
+		const parsedHeader = typeof header === "string" ? JSON.parse(header) : header;
+		const entries = toEntries(entryRows(rows));
+		return (0, _mastra_core_storage.materializeWorkflowRun)(parsedHeader, entries, await this.#stateBase(q, entries));
+	}
+	/** Parses a row of `#runsSql`. */
+	async #parseRun(row) {
+		if (Number(row.version) !== 2) return this.parseWorkflowRun(row);
+		const snapshot = row.entries ? await this.#materializeRun(this.#client, row.header, row.entries) : row.snapshot;
+		return {
+			...this.parseWorkflowRun({
+				...row,
+				snapshot
+			}),
+			storageVersion: 2
+		};
+	}
+	#runError(operation, workflowName, 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: {
+				workflowName,
+				runId
+			}
+		}, error);
+	}
+	async loadWorkflowRunHeader({ workflowName, runId }) {
+		try {
+			const row = (await this.#client.execute({
+				sql: `SELECT json(header) AS header, lastSeq, startStateSeq, runToken FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?`,
+				args: [workflowName, runId]
+			})).rows[0];
+			return row ? {
+				header: JSON.parse(row.header),
+				lastSeq: Number(row.lastSeq),
+				startStateSeq: Number(row.startStateSeq),
+				runToken: row.runToken
+			} : null;
+		} catch (error) {
+			throw this.#runError("LOAD_WORKFLOW_RUN_HEADER", workflowName, runId, error);
+		}
+	}
+	async loadWorkflowRun({ workflowName, runId, successfulSteps }) {
+		try {
+			const summary = successfulSteps === "summary";
+			const run = (await this.#client.execute({
+				sql: `SELECT json(r.header) AS header, r.lastSeq, r.startStateSeq, r.runToken, ${entriesSql("r", { summary })} AS entries
+          FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} r WHERE r.workflow_name = ? AND r.run_id = ?`,
+				args: summary ? [
+					JSON.stringify(_mastra_core_storage.STEP_RESULT_SUMMARY_FIELDS),
+					workflowName,
+					runId
+				] : [workflowName, runId]
+			})).rows[0];
+			if (!run) return null;
+			const header = JSON.parse(run.header);
+			const rows = entryRows(run.entries);
+			const entries = toEntries(rows);
+			const summarizedInQuery = new Set(rows.filter((row) => row.summarized).map((row) => row.step_id));
+			const steps = {};
+			const summarizedStepIds = [];
+			for (const [stepId, result] of (0, _mastra_core_storage.latestStepResults)(entries)) {
+				steps[stepId] = result;
+				if (summary && stepId !== "input" && result?.status === "success") {
+					if (!summarizedInQuery.has(stepId)) steps[stepId] = (0, _mastra_core_storage.summarizeStepResult)(result);
+					summarizedStepIds.push(stepId);
+				}
+			}
+			const base = await this.#stateBase(this.#client, entries);
+			const { state, statePatchBytes } = (0, _mastra_core_storage.materializeState)(entries, { base });
+			return {
+				header,
+				lastSeq: Number(run.lastSeq),
+				startStateSeq: Number(run.startStateSeq),
+				runToken: run.runToken,
+				state,
+				statePatchBytes,
+				steps,
+				summarizedStepIds
+			};
+		} catch (error) {
+			throw this.#runError("LOAD_WORKFLOW_RUN", workflowName, runId, error);
+		}
+	}
+	async loadWorkflowRunSteps({ workflowName, runId, stepIds, expectedLastSeq, expectedRunToken }) {
+		try {
+			const run = (await this.#client.execute({
+				sql: `SELECT r.lastSeq, r.runToken, (SELECT json_group_array(json_object(
+              'seq', x.seq, 'ord', x.seq, 'kind', x.kind, 'step_id', x.step_id, 'absent', x.payload IS NULL, 'payload', json(x.payload)
+            ))
+            FROM (
+              SELECT e.seq, e.kind, e.step_id, e.payload,
+                MAX(CASE WHEN e.kind = 'step' THEN e.seq END) OVER (PARTITION BY e.step_id) AS step_seq
+              FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} e
+              WHERE e.workflow_name = r.workflow_name AND e.run_id = r.run_id AND e.kind IN ('step', 'step-patch')
+                AND e.step_id IN (SELECT value FROM json_each(?))
+            ) x
+            WHERE x.seq >= x.step_seq) AS entries
+          FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} r WHERE r.workflow_name = ? AND r.run_id = ?`,
+				args: [
+					JSON.stringify(stepIds),
+					workflowName,
+					runId
+				]
+			})).rows[0];
+			if (!run) return null;
+			if (expectedLastSeq !== void 0 && Number(run.lastSeq) !== expectedLastSeq) return null;
+			if (expectedRunToken !== void 0 && run.runToken !== expectedRunToken) return null;
+			return Object.fromEntries((0, _mastra_core_storage.latestStepResults)(toEntries(entryRows(run.entries))));
+		} catch (error) {
+			throw this.#runError("LOAD_WORKFLOW_RUN_STEPS", workflowName, runId, error);
+		}
+	}
+	async updateWorkflowRunHeader({ workflowName, runId, opts, fence }) {
+		const check = this.#runFenceCheck(fence, runId, "updateWorkflowRunHeader");
+		try {
+			return await this.executeWithRetry(() => inWriteTransaction(this.#client, async (tx) => {
+				if (check) await assertRunFence(tx, check);
+				const row = (await tx.execute({
+					sql: `SELECT json(header) AS header, lastSeq, startStateSeq, runToken FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?`,
+					args: [workflowName, runId]
+				})).rows[0];
+				if (!row) return void 0;
+				const current = JSON.parse(row.header);
+				const { expectedStatus, ...patch } = opts;
+				if (!(0, _mastra_core_storage.matchesExpectedWorkflowStatus)(current.status, expectedStatus)) return void 0;
+				const header = {
+					...current,
+					...patch
+				};
+				await tx.execute({
+					sql: `UPDATE ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} SET header = jsonb(?), status = ?, updatedAt = ? WHERE workflow_name = ? AND run_id = ?`,
+					args: [
+						safeStringify(header),
+						header.status,
+						(/* @__PURE__ */ new Date()).toISOString(),
+						workflowName,
+						runId
+					]
+				});
+				return {
+					header,
+					lastSeq: Number(row.lastSeq),
+					startStateSeq: Number(row.startStateSeq),
+					runToken: row.runToken
+				};
+			}), "updateWorkflowRunHeader");
+		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
+			throw this.#runError("UPDATE_WORKFLOW_RUN_HEADER", workflowName, runId, error);
+		}
+	}
+	/**
+	* One batch behind the write lock (see `#writeRun` for `expectedStatus` and `stateBase`): marking
+	* the run a state base builds on as shared, the header upsert, then the deletion of the run's
+	* entries (only its steps when another run builds on its state, see `stateShared`), then the new ones.
+	*/
+	async writeWorkflowRunCheckpoint({ fence, expectedStatus, steps, state, stateBase, statePatch, ...run }) {
+		const entries = journalEntries(steps, {
+			state,
+			stateBase,
+			statePatch
+		}, true);
+		const check = this.#runFenceCheck(fence, run.runId, "writeWorkflowRunCheckpoint");
+		try {
+			const base = state === void 0 ? stateBase : void 0;
+			const statements = [];
+			if (base) statements.push({
+				sql: `UPDATE ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} SET stateShared = 1 WHERE workflow_name = ? AND run_id = ? AND NOT stateShared`,
+				args: [base.workflowName, base.runId]
+			});
+			statements.push(upsertHeader(run, entries.length, { checkpoint: true }), {
+				sql: `DELETE FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} WHERE workflow_name = ? AND run_id = ?
+            AND (kind IN ('step', 'step-patch') OR NOT (SELECT stateShared FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?))`,
+				args: [
+					run.workflowName,
+					run.runId,
+					run.workflowName,
+					run.runId
+				]
+			}, insertEntries(run, entries));
+			const results = await this.executeWithRetry(() => this.#writeRun(check, run, {
+				expectedStatus,
+				stateBase: base
+			}, statements), "writeWorkflowRunCheckpoint");
+			if (!results) return null;
+			const header = results[statements.length - 3].rows[0];
+			return {
+				lastSeq: Number(header.lastSeq),
+				runToken: header.runToken
+			};
+		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
+			throw this.#runError("WRITE_WORKFLOW_RUN_CHECKPOINT", run.workflowName, run.runId, error);
+		}
+	}
+	/**
+	* One batch behind the write lock (see `#writeRun` for `expectedStatus`): the header upsert adds
+	* the entry count to `lastSeq`, and the insert numbers the entries up to it, so writes to one run
+	* never interleave.
+	*/
+	async appendWorkflowRunEntries({ fence, steps, stepPatches, state, statePatch, startStateSeq, expectedStatus, ...run }) {
+		const entries = journalEntries(steps, {
+			state,
+			statePatch
+		}, false, stepPatches);
+		const check = this.#runFenceCheck(fence, run.runId, "appendWorkflowRunEntries");
+		try {
+			const results = await this.executeWithRetry(() => this.#writeRun(check, run, { expectedStatus }, [upsertHeader(run, entries.length, {
+				checkpoint: false,
+				startStateSeq
+			}), insertEntries(run, entries)]), "appendWorkflowRunEntries");
+			if (!results) return null;
+			const header = results[0].rows[0];
+			return {
+				lastSeq: Number(header.lastSeq),
+				runToken: header.runToken
+			};
+		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
+			throw this.#runError("APPEND_WORKFLOW_RUN_ENTRIES", run.workflowName, run.runId, error);
+		}
+	}
+	async loadWorkflowRunState({ workflowName, runId, seq }) {
+		try {
+			return (await this.#stateAt(this.#client, workflowName, runId, { seq }))?.state ?? null;
+		} catch (error) {
+			throw this.#runError("LOAD_WORKFLOW_RUN_STATE", workflowName, runId, error);
+		}
+	}
+	/**
+	* One batch behind the write lock (or the run's fence): the header's `lastSeq` bump, then the
+	* draft numbered at it.
+	*/
+	async appendWorkflowRunStateDraft(args) {
+		const { workflowName, runId } = args;
+		const payload = "state" in args ? { state: args.state } : {
+			on: args.on.draft ? {
+				seq: args.on.seq,
+				draft: true
+			} : { seq: args.on.seq },
+			ops: args.ops
+		};
+		let row;
+		try {
+			const [header] = await this.executeWithRetry(() => withRunFence(this.#client, this.#runFenceCheck(void 0, runId, "appendWorkflowRunStateDraft"), (writer) => writer.batch([{
+				sql: `UPDATE ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} SET lastSeq = lastSeq + 1, stateShared = 1
+                  WHERE workflow_name = ? AND run_id = ? RETURNING lastSeq`,
+				args: [workflowName, runId]
+			}, {
+				sql: `INSERT INTO ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} (workflow_name, run_id, seq, kind, step_id, payload)
+                  SELECT workflow_name, run_id, lastSeq, 'state-draft', NULL, jsonb(?)
+                  FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?`,
+				args: [
+					safeStringify(payload),
+					workflowName,
+					runId
+				]
+			}])), "appendWorkflowRunStateDraft");
+			row = header.rows[0];
+		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
+			throw this.#runError("APPEND_WORKFLOW_RUN_STATE_DRAFT", workflowName, runId, error);
+		}
+		if (!row) throw new Error(`Storage v2 run ${workflowName}/${runId} is not stored`);
+		return { seq: Number(row.lastSeq) };
+	}
 	async #readRunOwner(q, runId) {
 		const row = (await q.execute({
 			sql: `SELECT ${RUN_OWNER_COLUMNS} FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS} WHERE runId = ?`,
@@ -15342,21 +15979,56 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			throw this.#ownershipError("GET_RUN_OWNERSHIP", runId, error);
 		}
 	}
-	/** Delete workflow run snapshots and run ownership rows older than their policy's `maxAge`, batched. */
+	/**
+	* Delete workflow runs and run ownership rows older than their policy's `maxAge`, batched.
+	* The `workflowSnapshot` policy covers both storage versions: storage v2 runs are pruned by
+	* their header's last write, together with their entries.
+	*/
 	async prune(policies, options) {
 		const targets = resolveTargets({
 			policies,
 			descriptor: WorkflowsLibSQL.retentionTables,
 			order: ["workflowSnapshot", "runOwnership"]
 		});
+		const snapshotTarget = targets.findIndex((target) => target.table === _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+		if (snapshotTarget !== -1) targets.splice(snapshotTarget + 1, 0, {
+			...targets[snapshotTarget],
+			table: _mastra_core_storage.TABLE_WORKFLOW_RUNS
+		});
 		return runPrune({
 			db: this.#db,
 			domain: "workflows",
 			targets,
 			options,
-			logger: this.logger
+			logger: this.logger,
+			deleteBatch: (target, cutoff, limit) => target.table === _mastra_core_storage.TABLE_WORKFLOW_RUNS ? this.#pruneRunsBatch(cutoff, limit) : void 0
 		});
 	}
+	/**
+	* Deletes up to `limit` aged storage v2 runs in one write transaction: detaches the runs built on
+	* their state, then deletes their entries and headers. Every statement selects the same runs, and
+	* the transaction holds the write lock, so they agree.
+	*/
+	async #pruneRunsBatch(cutoff, limit) {
+		const doomed = `SELECT workflow_name, run_id FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS}
+      WHERE updatedAt < ? ORDER BY updatedAt, workflow_name, run_id LIMIT ?`;
+		return this.executeWithRetry(() => inWriteTransaction(this.#client, async (tx) => {
+			const shared = await tx.execute({
+				sql: `SELECT d.workflow_name, d.run_id FROM (${doomed}) d
+              JOIN ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} r USING (workflow_name, run_id) WHERE r.stateShared`,
+				args: [cutoff, limit]
+			});
+			for (const run of shared.rows) await this.#detachStateChildren(tx, run.workflow_name, run.run_id);
+			await tx.execute({
+				sql: `DELETE FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES} WHERE (workflow_name, run_id) IN (${doomed})`,
+				args: [cutoff, limit]
+			});
+			return (await tx.execute({
+				sql: `DELETE FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE (workflow_name, run_id) IN (${doomed})`,
+				args: [cutoff, limit]
+			})).rowsAffected;
+		}), `prune ${_mastra_core_storage.TABLE_WORKFLOW_RUNS}`);
+	}
 	async setupPragmaSettings() {
 		try {
 			await this.#client.execute("PRAGMA busy_timeout = 10000;");
@@ -15388,6 +16060,10 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 					args: [workflowName, runId]
 				});
 				if (!existingSnapshotResult.rows?.[0]) {
+					if ((await tx.execute({
+						sql: `SELECT 1 FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?`,
+						args: [workflowName, runId]
+					})).rows.length > 0) throw new Error(`updateWorkflowResults does not support storage v2 runs (run ${runId})`);
 					await tx.rollback();
 					return {};
 				}
@@ -15422,12 +16098,51 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			}
 		}), "updateWorkflowResults");
 	}
-	async updateWorkflowState({ workflowName, runId, opts, fence: explicitFence }) {
+	async updateWorkflowState({ workflowName, runId, opts, fence: explicitFence, storageVersion }) {
 		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);
+				if (storageVersion !== 1) {
+					const row = (await tx.execute({
+						sql: `SELECT json(header) AS header FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?`,
+						args: [workflowName, runId]
+					})).rows[0];
+					if (row) {
+						const current = JSON.parse(row.header);
+						const { expectedStatus, ...patch } = opts;
+						if (!(0, _mastra_core_storage.matchesExpectedWorkflowStatus)(current.status, expectedStatus)) {
+							await tx.rollback();
+							return;
+						}
+						const header = {
+							...current,
+							...patch
+						};
+						await tx.execute({
+							sql: `UPDATE ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} SET header = jsonb(?), status = ?, updatedAt = ? WHERE workflow_name = ? AND run_id = ?`,
+							args: [
+								safeStringify(header),
+								header.status,
+								(/* @__PURE__ */ new Date()).toISOString(),
+								workflowName,
+								runId
+							]
+						});
+						const entries = await tx.execute({
+							sql: `SELECT ${entriesSql("r")} AS entries FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} r WHERE r.workflow_name = ? AND r.run_id = ?`,
+							args: [workflowName, runId]
+						});
+						const snapshot = await this.#materializeRun(tx, header, entries.rows[0].entries);
+						await tx.commit();
+						return snapshot;
+					}
+					if (storageVersion === 2) {
+						await tx.rollback();
+						return;
+					}
+				}
 				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]
@@ -15497,15 +16212,32 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 	}
 	async loadWorkflowRunStatus({ workflowName, runId }) {
 		return (await this.#client.execute({
-			sql: `SELECT json_extract(snapshot, '$.status') AS status FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
-			args: [workflowName, runId]
+			sql: `SELECT COALESCE(
+          (SELECT status FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?),
+          (SELECT json_extract(snapshot, '$.status') FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?)
+        ) AS status`,
+			args: [
+				workflowName,
+				runId,
+				workflowName,
+				runId
+			]
 		})).rows?.[0]?.status ?? null;
 	}
-	async loadWorkflowSnapshot({ workflowName, runId }) {
+	async loadWorkflowSnapshot({ workflowName, runId, storageVersion }) {
 		this.logger.debug("Loading workflow snapshot", {
 			workflowName,
 			runId
 		});
+		if (storageVersion !== 1) {
+			const row = (await this.#client.execute({
+				sql: `SELECT json(r.header) AS header, ${entriesSql("r")} AS entries
+          FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} r WHERE r.workflow_name = ? AND r.run_id = ?`,
+				args: [workflowName, runId]
+			})).rows[0];
+			if (row) return this.#materializeRun(this.#client, row.header, row.entries);
+			if (storageVersion === 2) return null;
+		}
 		const d = await this.#db.select({
 			tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			keys: {
@@ -15515,7 +16247,7 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 		});
 		return d ? d.snapshot : null;
 	}
-	async getWorkflowRunById({ runId, workflowName }) {
+	async getWorkflowRunById({ runId, workflowName, storageVersion }) {
 		const conditions = [];
 		const args = [];
 		if (runId) {
@@ -15529,11 +16261,15 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 		const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
 		try {
 			const result = await this.#client.execute({
-				sql: `SELECT workflow_name, run_id, resourceId, json(snapshot) as snapshot, createdAt, updatedAt FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC LIMIT 1`,
-				args
+				sql: this.#runsSql({
+					v1Where: storageVersion === 2 ? null : whereClause,
+					v2Where: storageVersion === 1 ? null : whereClause,
+					page: "LIMIT 1"
+				}),
+				args: [...storageVersion === 2 ? [] : args, ...storageVersion === 1 ? [] : args]
 			});
 			if (!result.rows?.[0]) return null;
-			return this.parseWorkflowRun(result.rows[0]);
+			return await this.#parseRun(result.rows[0]);
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
@@ -15542,14 +16278,33 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 			}, error);
 		}
 	}
-	async deleteWorkflowRunById({ runId, workflowName, fence }) {
+	async deleteWorkflowRunById({ runId, workflowName, storageVersion, fence }) {
 		const check = this.#runFenceCheck(fence, runId, "deleteWorkflowRunById");
 		return this.executeWithRetry(async () => {
 			try {
-				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]
-				}));
+				if (storageVersion === 1) {
+					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]
+					}));
+					return;
+				}
+				await inWriteTransaction(this.#client, async (tx) => {
+					if (check) await assertRunFence(tx, check);
+					const run = await tx.execute({
+						sql: `SELECT stateShared FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} WHERE workflow_name = ? AND run_id = ?`,
+						args: [workflowName, runId]
+					});
+					if (Number(run.rows[0]?.stateShared)) await this.#detachStateChildren(tx, workflowName, runId);
+					for (const table of [
+						_mastra_core_storage.TABLE_WORKFLOW_RUNS,
+						_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES,
+						...storageVersion === 2 ? [] : [_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT]
+					]) await tx.execute({
+						sql: `DELETE FROM ${table} 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({
@@ -15568,52 +16323,74 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends _mastra_core_storage.Workflo
 		try {
 			const conditions = [];
 			const args = [];
+			const v2Conditions = [];
+			const v2Args = [];
 			if (workflowName) {
 				conditions.push("workflow_name = ?");
 				args.push(workflowName);
+				v2Conditions.push("workflow_name = ?");
+				v2Args.push(workflowName);
 			}
 			if (status) {
 				conditions.push("json_extract(snapshot, '$.status') = ?");
 				args.push(status);
+				v2Conditions.push("status = ?");
+				v2Args.push(status);
 			}
 			if (fromDate) {
 				conditions.push("createdAt >= ?");
 				args.push(fromDate.toISOString());
+				v2Conditions.push("createdAt >= ?");
+				v2Args.push(fromDate.toISOString());
 			}
 			if (toDate) {
 				conditions.push("createdAt <= ?");
 				args.push(toDate.toISOString());
+				v2Conditions.push("createdAt <= ?");
+				v2Args.push(toDate.toISOString());
 			}
 			if (resourceId) {
 				if (await this.#db.hasColumn(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId")) {
 					conditions.push("resourceId = ?");
 					args.push(resourceId);
 				} else this.logger.warn(`[${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+				v2Conditions.push("resourceId = ?");
+				v2Args.push(resourceId);
 			}
 			if (threadId) {
 				conditions.push(`(EXISTS (SELECT 1 FROM json_each(snapshot, '$.context') AS je WHERE json_extract(je.value, '$.status') = 'suspended' AND json_extract(je.value, '$.suspendPayload.__streamState.messageList.memoryInfo.threadId') = ?) OR json_extract(snapshot, '$.context.input.messageListState.memoryInfo.threadId') = ?)`);
 				args.push(threadId, threadId);
+				v2Conditions.push("threadId = ?");
+				v2Args.push(threadId);
 			}
 			const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+			const v2WhereClause = v2Conditions.length > 0 ? `WHERE ${v2Conditions.join(" AND ")}` : "";
 			let total = 0;
 			const usePagination = typeof perPage === "number" && typeof page === "number";
 			if (usePagination) {
 				const countResult = await this.#client.execute({
-					sql: `SELECT COUNT(*) as count FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause}`,
-					args
+					sql: `SELECT (SELECT COUNT(*) FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause})
+            + (SELECT COUNT(*) FROM ${_mastra_core_storage.TABLE_WORKFLOW_RUNS} ${v2WhereClause}) AS count`,
+					args: [...args, ...v2Args]
 				});
 				total = Number(countResult.rows?.[0]?.count ?? 0);
 			}
 			const normalizedPerPage = usePagination ? (0, _mastra_core_storage.normalizePerPage)(perPage, Number.MAX_SAFE_INTEGER) : 0;
 			const offset = usePagination ? page * normalizedPerPage : 0;
-			const runs = ((await this.#client.execute({
-				sql: `SELECT workflow_name, run_id, resourceId, ${summary ? `json_object('status', json_extract(snapshot, '$.status'), 'timestamp', json_extract(snapshot, '$.timestamp'))` : "json(snapshot)"} as snapshot, createdAt, updatedAt FROM ${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC${usePagination ? ` LIMIT ? OFFSET ?` : ""}`,
-				args: usePagination ? [
+			const result = await this.#client.execute({
+				sql: this.#runsSql({
+					v1Where: whereClause,
+					v2Where: v2WhereClause,
+					summary,
+					page: usePagination ? "LIMIT ? OFFSET ?" : ""
+				}),
+				args: [
 					...args,
-					normalizedPerPage,
-					offset
-				] : args
-			})).rows || []).map((row) => this.parseWorkflowRun(row));
+					...v2Args,
+					...usePagination ? [normalizedPerPage, offset] : []
+				]
+			});
+			const runs = await Promise.all((result.rows || []).map((row) => this.#parseRun(row)));
 			return {
 				runs,
 				total: total || runs.length