@mastra/pg 1.35.0 → 1.36.0-alpha.1

package/dist/index.cjs

@@ -5242,13 +5242,13 @@ function cutoffFor(policy, anchorType, now = Date.now()) {
 	return anchorType === "epoch-ms" ? cutoffMs : new Date(cutoffMs);
 }
 const runBatchedDelete = _mastra_core_storage.runRetentionBatches;
-function runPrune({ db, domain, targets, options }) {
+function runPrune({ db, domain, targets, options, deleteBatch }) {
 	return (0, _mastra_core_storage.executeRetentionPrune)({
 		domain,
 		targets,
 		options,
 		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,
@@ -18337,6 +18337,11 @@ async function batchCreateFeedback(client, schema, args, partitioning) {
 	const rows = [...new Map(args.feedbacks.map((feedback) => [feedback.feedbackId, feedback])).values()].map(feedbackRecordToRow);
 	await insertRows(client, schema, TABLE_FEEDBACK_EVENTS, rows, partitioning, FEEDBACK_UPSERT_CLAUSE);
 }
+async function getFeedbackById(client, schema, feedbackId) {
+	const row = await client.oneOrNone(`SELECT ${FEEDBACK_SELECT_COLUMNS} FROM ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
+     WHERE "feedbackId" = $1 ORDER BY "cursorId" DESC LIMIT 1`, [feedbackId]);
+	return row ? rowToFeedbackRecord(row) : null;
+}
 async function updateFeedbackReviewStatus(client, schema, args) {
 	const { feedbackId, reviewStatus } = parseUpdateFeedbackReviewStatusArgs(args);
 	const row = await client.oneOrNone(`UPDATE ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
@@ -22172,6 +22177,9 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 	async getScoreById(scoreId) {
 		return this.#run("GET_SCORE_BY_ID", () => getScoreById(this.#readClient, this.#schema, scoreId), { scoreId });
 	}
+	async getFeedbackById(feedbackId) {
+		return this.#run("GET_FEEDBACK_BY_ID", () => getFeedbackById(this.#readClient, this.#schema, feedbackId), { feedbackId });
+	}
 	async listFeedback(args) {
 		return this.#run("LIST_FEEDBACK", () => listFeedback(this.#readClient, this.#schema, args));
 	}
@@ -25625,6 +25633,16 @@ function workflowSnapshotStatusIndexSQL(indexName, schemaName, concurrently = fa
 	});
 	return `CREATE INDEX ${concurrently ? "CONCURRENTLY " : ""}IF NOT EXISTS "${indexName}" ON ${tableName} (workflow_name, (snapshot ->> 'status'), "createdAt" DESC)`;
 }
+/**
+* Storage v2 index names share the long `<schema>_mastra_workflow_runs_` prefix, so a long
+* schema name would collapse them to one 63-byte identifier under plain truncation; hash instead.
+*/
+function runIndexName(schemaPrefix, baseName) {
+	return buildConstraintName({
+		baseName: `${schemaPrefix}${baseName}`,
+		hashWhenTruncated: true
+	});
+}
 /** Base name (before any schema prefix) of the expression index backing the threadId filter. */
 const WORKFLOW_SNAPSHOT_THREAD_ID_INDEX = "mastra_workflow_snapshot_threadid_idx";
 /**
@@ -25669,13 +25687,126 @@ function workflowSnapshotThreadIdIndexSQL(indexName, schemaName, concurrently =
 	});
 	return `CREATE INDEX ${concurrently ? "CONCURRENTLY " : ""}IF NOT EXISTS "${indexName}" ON ${tableName} ((${WORKFLOW_SNAPSHOT_THREAD_ID_EXPR}))`;
 }
+/** Base name (before any schema prefix) of the index finding the `state-base` entries built on a run. */
+const WORKFLOW_RUN_ENTRIES_STATE_BASE_INDEX = "mastra_workflow_run_entries_state_base_idx";
+/** The run a `state-base` entry builds on; `#detachStateChildren` must use these exact expressions. */
+const STATE_BASE_RUN_EXPR = `(payload ->> 'workflowName'), (payload ->> 'runId')`;
+/**
+* Partial expression index finding the `state-base` entries built on a run, so deleting a run whose
+* state others build on doesn't scan every entry. See {@link workflowSnapshotStatusIndexSQL} for
+* `concurrently`.
+*/
+function stateBaseIndexSQL(indexName, schemaName, concurrently = false) {
+	const tableName = getTableName({
+		indexName: _mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES,
+		schemaName: getSchemaName(schemaName)
+	});
+	return `CREATE INDEX ${concurrently ? "CONCURRENTLY " : ""}IF NOT EXISTS "${indexName}" ON ${tableName} (${STATE_BASE_RUN_EXPR}) WHERE kind = 'state-base'`;
+}
+/**
+* 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;
+}
+/**
+* Rows `e(elem, ord)` of the jsonb array parameter `param` of {@link EntryInput}, and the
+* entry columns they insert. `elem -> 'payload'` keeps a JSON null apart from an undefined
+* payload (dropped by `JSON.stringify`), which becomes SQL NULL.
+*/
+const entryRows = (param) => `jsonb_array_elements(${param}::jsonb) WITH ORDINALITY AS e(elem, ord)`;
+const ENTRY_VALUES = `e.elem ->> 'kind', e.elem ->> 'step_id', e.elem -> 'payload'`;
+/** The entries of {@link EntryRow} rows; 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
+				};
+			}
+		}
+	});
+}
 var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorage {
 	#db;
 	#schema;
 	#skipDefaultIndexes;
 	#indexes;
 	/** Tables managed by this domain */
-	static MANAGED_TABLES = [_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT];
+	static MANAGED_TABLES = [
+		_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+		_mastra_core_storage.TABLE_WORKFLOW_RUNS,
+		_mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES
+	];
 	/**
 	* Workflow run snapshots accumulate as runs execute. Anchored on the
 	* timezone-aware `updatedAtZ` mirror column (last activity) so suspended or
@@ -25738,11 +25869,43 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 		};
 	}
 	static getDefaultIndexDefs(schemaPrefix) {
-		return [{
-			name: `${schemaPrefix}mastra_workflow_snapshot_name_createdat_idx`,
-			table: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
-			columns: ["workflow_name", "createdAt DESC"]
-		}];
+		return [
+			{
+				name: `${schemaPrefix}mastra_workflow_snapshot_name_createdat_idx`,
+				table: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+				columns: ["workflow_name", "createdAt DESC"]
+			},
+			{
+				name: runIndexName(schemaPrefix, "mastra_workflow_runs_name_createdat_idx"),
+				table: _mastra_core_storage.TABLE_WORKFLOW_RUNS,
+				columns: ["workflow_name", "createdAt DESC"]
+			},
+			{
+				name: runIndexName(schemaPrefix, "mastra_workflow_runs_name_status_createdat_idx"),
+				table: _mastra_core_storage.TABLE_WORKFLOW_RUNS,
+				columns: [
+					"workflow_name",
+					"status",
+					"createdAt DESC"
+				]
+			},
+			{
+				name: runIndexName(schemaPrefix, "mastra_workflow_runs_threadid_idx"),
+				table: _mastra_core_storage.TABLE_WORKFLOW_RUNS,
+				columns: ["threadId"]
+			},
+			{
+				name: runIndexName(schemaPrefix, "mastra_workflow_run_entries_step_idx"),
+				table: _mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES,
+				columns: [
+					"workflow_name",
+					"run_id",
+					"kind",
+					"step_id",
+					"seq"
+				]
+			}
+		];
 	}
 	/**
 	* Returns all DDL statements for this domain: table with unique constraint.
@@ -25758,9 +25921,17 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			schemaName,
 			includeAllConstraints: true
 		}));
+		for (const [tableName, config] of Object.entries(_mastra_core_storage.WORKFLOW_RUN_JOURNAL_TABLE_CONFIGS)) statements.push(generateTableSQL({
+			tableName,
+			schema: config.columns,
+			schemaName,
+			compositePrimaryKey: config.compositePrimaryKey,
+			includeAllConstraints: true
+		}));
 		for (const idx of WorkflowsPG.getDefaultIndexDefs(schemaPrefix)) statements.push(generateIndexSQL(idx, schemaName));
 		statements.push(`${workflowSnapshotStatusIndexSQL(workflowSnapshotStatusIndexName(parsedSchema), schemaName)};`);
 		statements.push(`${workflowSnapshotThreadIdIndexSQL(workflowSnapshotThreadIdIndexName(parsedSchema), schemaName)};`);
+		statements.push(`${stateBaseIndexSQL(runIndexName(schemaPrefix, WORKFLOW_RUN_ENTRIES_STATE_BASE_INDEX), schemaName)};`);
 		statements.push(generateTableSQL({
 			tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
 			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS],
@@ -25786,6 +25957,12 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 		} catch (error) {
 			this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
 		}
+		const stateBaseIndexName = runIndexName(this.#schema !== "public" ? `${schemaNamePrefix(this.#schema)}_` : "", WORKFLOW_RUN_ENTRIES_STATE_BASE_INDEX);
+		try {
+			await this.#db.createIndexFromStatement(stateBaseIndexName, stateBaseIndexSQL(stateBaseIndexName, this.#schema, true));
+		} catch (error) {
+			this.logger?.warn?.(`Failed to create index ${stateBaseIndexName}:`, error);
+		}
 		if (await this.#db.getColumnType(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "snapshot") !== "jsonb") return;
 		const indexName = workflowSnapshotStatusIndexName(this.#schema);
 		try {
@@ -25814,6 +25991,11 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			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 this.createDefaultIndexes();
 		await this.createCustomIndexes();
 	}
@@ -25840,8 +26022,22 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 				this.logger?.warn?.(`Failed to create retention index for ${entry.table}:`, error);
 			}
 		}
+		if (!policies.workflowSnapshot) return;
+		try {
+			await this.#db.ensureIndex({
+				indexName: `${prefix}mastra_workflow_runs_retention_idx`,
+				tableName: _mastra_core_storage.TABLE_WORKFLOW_RUNS,
+				column: "updatedAtZ"
+			});
+		} catch (error) {
+			this.logger?.warn?.(`Failed to create retention index for ${_mastra_core_storage.TABLE_WORKFLOW_RUNS}:`, 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) {
 		await this.ensureRetentionIndexes(policies);
 		const targets = resolveTargets({
@@ -25849,11 +26045,40 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			descriptor: WorkflowsPG.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
+			options,
+			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, header and entries together, first detaching the
+	* runs whose state others build on (see `#detachStateChildren`).
+	*/
+	async #pruneRunsBatch(cutoff, limit) {
+		return this.#db.client.tx(async (t) => {
+			const doomed = await t.manyOrNone(`SELECT workflow_name, run_id, "stateShared" FROM ${this.#runsTable()}
+         WHERE "updatedAtZ" < $1
+         ORDER BY "updatedAtZ"
+         LIMIT $2
+         FOR UPDATE SKIP LOCKED`, [cutoff, limit]);
+			if (!doomed.length) return 0;
+			for (const run of doomed) if (run.stateShared) await this.#detachStateChildren(t, run.workflow_name, run.run_id);
+			return (await t.query(`WITH doomed AS (
+           SELECT * FROM unnest($1::text[], $2::text[]) AS d(workflow_name, run_id)
+         ), entries AS (
+           DELETE FROM ${this.#entriesTable()} e USING doomed d
+           WHERE e.workflow_name = d.workflow_name AND e.run_id = d.run_id
+         )
+         DELETE FROM ${this.#runsTable()} r USING doomed d
+         WHERE r.workflow_name = d.workflow_name AND r.run_id = d.run_id`, [doomed.map((run) => run.workflow_name), doomed.map((run) => run.run_id)])).rowCount ?? 0;
 		});
 	}
 	/**
@@ -25870,6 +26095,459 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 	async dangerouslyClearAll() {
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT });
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_RUNS });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES });
+	}
+	supportsRunJournal() {
+		return true;
+	}
+	#runsTable() {
+		return getTableName({
+			indexName: _mastra_core_storage.TABLE_WORKFLOW_RUNS,
+			schemaName: getSchemaName(this.#schema)
+		});
+	}
+	#entriesTable() {
+		return getTableName({
+			indexName: _mastra_core_storage.TABLE_WORKFLOW_RUN_ENTRIES,
+			schemaName: getSchemaName(this.#schema)
+		});
+	}
+	/**
+	* A jsonb array of {@link EntryRow} for the storage v2 run `alias` refers to: each step's
+	* latest entry, ordered by when each step was first written so `context` keys keep their write
+	* order, the step patches after it (in `seq` order, for `latestStepResults`), and the entries
+	* `materializeState` uses for the latest state: the latest full state or state base and every
+	* state patch after it, in `seq` order. Drafts are left out.
+	*
+	* With `summaryFieldsParam` (the parameter holding `STEP_RESULT_SUMMARY_FIELDS`), 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.
+	*/
+	#entriesSql(alias, { summaryFieldsParam } = {}) {
+		let payload = "x.payload";
+		if (summaryFieldsParam) {
+			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 = `CASE WHEN ${summarized} THEN (
+          SELECT COALESCE(jsonb_object_agg(f.key, f.value), '{}'::jsonb)
+          FROM jsonb_each(x.payload) f WHERE f.key = ANY(${summaryFieldsParam}::text[])
+        ) ELSE x.payload END, 'summarized', ${summarized}`;
+		}
+		return `(SELECT COALESCE(jsonb_agg(jsonb_build_object(
+          'seq', x.seq, 'kind', x.kind, 'step_id', x.step_id, 'absent', x.payload IS NULL, 'payload', ${payload}
+        ) ORDER BY CASE WHEN x.kind = 'step' THEN x.first_seq ELSE x.seq END), '[]'::jsonb)
+      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 ${this.#entriesTable()} 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 jsonb array of {@link EntryRow} with the entries `materializeState` uses for the state of the
+	* storage v2 run `alias` refers to as of a version: `seqParam` its `seq`, `draftParam` whether
+	* it is a draft. 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.
+	*/
+	#stateEntriesSql(alias, seqParam, draftParam) {
+		return `(SELECT COALESCE(jsonb_agg(jsonb_build_object(
+          'seq', x.seq, 'kind', x.kind, 'step_id', x.step_id, 'absent', x.payload IS NULL, 'payload', x.payload
+        ) ORDER BY x.seq), '[]'::jsonb)
+      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 ${this.#entriesTable()} 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 <= ${seqParam}::int
+      ) x
+      WHERE ${draftParam}::boolean OR (x.kind <> 'state-draft' AND (x.base_seq IS NULL OR x.seq >= x.base_seq)))`;
+	}
+	/**
+	* 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`).
+	*/
+	async #runsQuery({ v1Where, v2Where, v1Snapshot = "snapshot", summary, page = "" }) {
+		const branches = [];
+		if (v1Where !== null) {
+			const optional = {
+				resourceId: "text",
+				createdAtZ: "timestamptz",
+				updatedAtZ: "timestamptz"
+			};
+			const columns = {};
+			for (const [column, type] of Object.entries(optional)) columns[column] = await this.#db.getColumnType(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, column) !== null ? `"${column}"` : `NULL::${type} AS "${column}"`;
+			branches.push(`SELECT workflow_name, run_id, ${columns.resourceId}, ${v1Snapshot} AS snapshot, NULL::jsonb AS header,
+           "createdAt", ${columns.createdAtZ}, "updatedAt", ${columns.updatedAtZ}, 1 AS version
+         FROM ${getTableName({
+				indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+				schemaName: getSchemaName(this.#schema)
+			})} ${v1Where}`);
+		}
+		if (v2Where !== null) {
+			const columns = summary ? `jsonb_build_object('status', header -> 'status', 'timestamp', header -> 'timestamp') AS snapshot, NULL::jsonb AS header` : `NULL AS snapshot, header`;
+			branches.push(`SELECT workflow_name, run_id, "resourceId", ${columns},
+           "createdAt", "createdAtZ", "updatedAt", "updatedAtZ", 2 AS version
+         FROM ${this.#runsTable()} ${v2Where}`);
+		}
+		return `SELECT p.*${summary ? "" : `, CASE WHEN p.version = 2 THEN ${this.#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.oneOrNone(`SELECT ${this.#stateEntriesSql("r", "$3", "$4")} AS entries
+       FROM ${this.#runsTable()} r WHERE r.workflow_name = $1 AND r.run_id = $2`, [
+			workflowName,
+			runId,
+			at.seq,
+			at.draft === true
+		]);
+		if (!row) return null;
+		const entries = toEntries(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.manyOrNone(`SELECT workflow_name, run_id, seq, payload FROM ${this.#entriesTable()}
+       WHERE kind = 'state-base' AND (${STATE_BASE_RUN_EXPR}) = ($1, $2)`, [workflowName, runId]);
+		const states = /* @__PURE__ */ new Map();
+		for (const child of children) {
+			const version = `${child.payload.seq}:${child.payload.draft === true}`;
+			let state = states.get(version);
+			if (!state) {
+				state = (await this.#stateAt(q, workflowName, runId, child.payload))?.state ?? {};
+				states.set(version, state);
+			}
+			await q.none(`UPDATE ${this.#entriesTable()} SET kind = 'state', payload = $4::jsonb
+         WHERE workflow_name = $1 AND run_id = $2 AND seq = $3`, [
+				child.workflow_name,
+				child.run_id,
+				child.seq,
+				toPgJson(state)
+			]);
+		}
+	}
+	/** Rebuilds a storage v2 run's `WorkflowRunState` from its header and `#entriesSql` rows. */
+	async #materializeRun(client, header, rows) {
+		const entries = toEntries(rows);
+		return (0, _mastra_core_storage.materializeWorkflowRun)(header, entries, await this.#stateBase(client, entries));
+	}
+	/** Parses a row of `#runsQuery`. */
+	async #parseRun(client, row) {
+		if (row.version !== 2) return this.parseWorkflowRun(row);
+		const snapshot = row.entries ? await this.#materializeRun(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)("PG", operation, "FAILED"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+			details: {
+				workflowName,
+				runId
+			}
+		}, error);
+	}
+	async loadWorkflowRunHeader({ workflowName, runId }) {
+		try {
+			return await this.#db.client.oneOrNone(`SELECT header, "lastSeq", "startStateSeq", "runToken" FROM ${this.#runsTable()} WHERE workflow_name = $1 AND run_id = $2`, [workflowName, runId]);
+		} 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.#db.client.oneOrNone(`SELECT r.header, r."lastSeq", r."startStateSeq", r."runToken", ${this.#entriesSql("r", { summaryFieldsParam: summary ? "$3" : void 0 })} AS entries
+         FROM ${this.#runsTable()} r WHERE r.workflow_name = $1 AND r.run_id = $2`, summary ? [
+				workflowName,
+				runId,
+				_mastra_core_storage.STEP_RESULT_SUMMARY_FIELDS
+			] : [workflowName, runId]);
+			if (!run) return null;
+			const entries = toEntries(run.entries);
+			const summarizedInQuery = new Set(run.entries.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.#db.client, entries);
+			const { state, statePatchBytes } = (0, _mastra_core_storage.materializeState)(entries, { base });
+			return {
+				header: run.header,
+				lastSeq: run.lastSeq,
+				startStateSeq: 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.#db.client.oneOrNone(`SELECT r."lastSeq", r."runToken", (
+           SELECT COALESCE(jsonb_agg(jsonb_build_object(
+               'seq', x.seq, 'kind', x.kind, 'step_id', x.step_id, 'absent', x.payload IS NULL, 'payload', x.payload
+             ) ORDER BY x.seq), '[]'::jsonb)
+           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 ${this.#entriesTable()} 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 = ANY($3::text[])
+           ) x
+           WHERE x.seq >= x.step_seq
+         ) AS entries
+         FROM ${this.#runsTable()} r WHERE r.workflow_name = $1 AND r.run_id = $2`, [
+				workflowName,
+				runId,
+				stepIds
+			]);
+			if (!run) return null;
+			if (expectedLastSeq !== void 0 && run.lastSeq !== expectedLastSeq) return null;
+			if (expectedRunToken !== void 0 && run.runToken !== expectedRunToken) return null;
+			return Object.fromEntries((0, _mastra_core_storage.latestStepResults)(toEntries(run.entries)));
+		} catch (error) {
+			throw this.#runError("LOAD_WORKFLOW_RUN_STEPS", workflowName, runId, error);
+		}
+	}
+	async updateWorkflowRunHeader({ workflowName, runId, opts, fence: explicitFence }) {
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence, runId);
+		try {
+			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runOwnersTable(), fence, "updateWorkflowRunHeader");
+				const run = await t.oneOrNone(`SELECT header FROM ${this.#runsTable()} WHERE workflow_name = $1 AND run_id = $2 FOR UPDATE`, [workflowName, runId]);
+				if (!run) return void 0;
+				const { expectedStatus, ...patch } = opts;
+				if (!(0, _mastra_core_storage.matchesExpectedWorkflowStatus)(run.header.status, expectedStatus)) return void 0;
+				const header = {
+					...run.header,
+					...patch
+				};
+				const now = /* @__PURE__ */ new Date();
+				return await t.one(`UPDATE ${this.#runsTable()}
+           SET header = $3::jsonb, status = $4, "updatedAt" = $5, "updatedAtZ" = $6
+           WHERE workflow_name = $1 AND run_id = $2
+           RETURNING header, "lastSeq", "startStateSeq", "runToken"`, [
+					workflowName,
+					runId,
+					toPgJson(header),
+					header.status,
+					now,
+					now
+				]);
+			});
+		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
+			throw this.#runError("UPDATE_WORKFLOW_RUN_HEADER", workflowName, runId, error);
+		}
+	}
+	/**
+	* Upserts a storage v2 run's header from `$1`–`$12` ({@link #headerParams}), adds `$7` (the
+	* number of entries the write adds) to `lastSeq`, and returns the new `lastSeq`, `stateShared`
+	* and `runToken`. `$12` is the run token of a run the write creates; a stored run keeps its own.
+	* A checkpoint's state entries come last, so its `startStateSeq` is the new `lastSeq`; an append
+	* keeps the stored one unless given `$13`. The header's row lock is held
+	* until commit, so the writes to one run commit in `seq` order. With `expectedParam` (a text
+	* array of statuses), a stored run whose status isn't in it is left as is and nothing is returned.
+	*/
+	#upsertHeaderSql(checkpoint, expectedParam) {
+		const startStateSeq = checkpoint ? {
+			insert: "$7::int",
+			update: "r.\"lastSeq\" + EXCLUDED.\"lastSeq\""
+		} : {
+			insert: "COALESCE($13::int, 0)",
+			update: "COALESCE($13::int, r.\"startStateSeq\")"
+		};
+		return `INSERT INTO ${this.#runsTable()} AS r
+         (workflow_name, run_id, "resourceId", "threadId", status, header, "lastSeq", "startStateSeq", "stateShared",
+          "runToken", "createdAt", "updatedAt", "createdAtZ", "updatedAtZ")
+       VALUES ($1, $2, $3, $4, $5, $6::jsonb, $7::int, ${startStateSeq.insert}, false, $12, $8, $9, $10, $11)
+       ON CONFLICT (workflow_name, run_id) DO UPDATE
+       SET "resourceId" = COALESCE(EXCLUDED."resourceId", r."resourceId"), "threadId" = EXCLUDED."threadId",
+           status = EXCLUDED.status, header = EXCLUDED.header, "lastSeq" = r."lastSeq" + EXCLUDED."lastSeq",
+           "startStateSeq" = ${startStateSeq.update},
+           "updatedAt" = EXCLUDED."updatedAt", "updatedAtZ" = EXCLUDED."updatedAtZ"
+       ${expectedParam ? `WHERE r.status = ANY(${expectedParam}::text[])` : ""}
+       RETURNING "lastSeq", "stateShared", "runToken"`;
+	}
+	#headerParams(run, entryCount) {
+		const now = /* @__PURE__ */ new Date();
+		return [
+			run.workflowName,
+			run.runId,
+			run.resourceId,
+			run.threadId ?? null,
+			run.header.status,
+			toPgJson(run.header),
+			entryCount,
+			now,
+			now,
+			now,
+			now,
+			crypto.randomUUID()
+		];
+	}
+	async writeWorkflowRunCheckpoint({ fence: explicitFence, expectedStatus, steps, state, stateBase, statePatch, ...run }) {
+		const entries = journalEntries(steps, {
+			state,
+			stateBase,
+			statePatch
+		}, true);
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence, run.runId);
+		const expected = expectedStatus === void 0 ? [] : [[expectedStatus].flat()];
+		try {
+			return await this.#db.client.tx(async (t) => {
+				if (fence) await assertRunFence(t, this.#runOwnersTable(), fence, "writeWorkflowRunCheckpoint");
+				const base = state === void 0 ? stateBase : void 0;
+				let baseLastSeq;
+				if (base) baseLastSeq = (await t.oneOrNone(`SELECT "lastSeq" FROM ${this.#runsTable()} WHERE workflow_name = $1 AND run_id = $2 FOR KEY SHARE`, [base.workflowName, base.runId]))?.lastSeq;
+				const header = await t.oneOrNone(this.#upsertHeaderSql(true, expected.length ? "$13" : void 0), [...this.#headerParams(run, entries.length), ...expected]);
+				if (!header) return null;
+				if (base) {
+					await t.none(`UPDATE ${this.#runsTable()} SET "stateShared" = true
+             WHERE workflow_name = $1 AND run_id = $2 AND NOT "stateShared"`, [base.workflowName, base.runId]);
+					const { stored } = await t.one(`SELECT EXISTS (
+               SELECT 1 FROM ${this.#entriesTable()} WHERE workflow_name = $1 AND run_id = $2
+                 AND CASE WHEN $4::boolean THEN kind = 'state-draft' AND seq = $3::int
+                     ELSE kind IN ('state', 'state-base') AND seq <= $3::int END
+             ) AS stored`, [
+						base.workflowName,
+						base.runId,
+						base.seq,
+						base.draft === true
+					]);
+					if (!stored || baseLastSeq === void 0 || base.seq > baseLastSeq) throw new Error(`Workflow run ${run.workflowName}/${run.runId} builds on state version ${base.seq} of ${base.workflowName}/${base.runId}, which is not stored`);
+				}
+				const { lastSeq, stateShared, runToken } = header;
+				await t.none(`DELETE FROM ${this.#entriesTable()}
+           WHERE workflow_name = $1 AND run_id = $2${stateShared ? ` AND kind IN ('step', 'step-patch')` : ""}`, [run.workflowName, run.runId]);
+				await t.none(`INSERT INTO ${this.#entriesTable()} (workflow_name, run_id, seq, kind, step_id, payload)
+           SELECT $1, $2, $3::int - $4::int + e.ord, ${ENTRY_VALUES}
+           FROM ${entryRows("$5")}`, [
+					run.workflowName,
+					run.runId,
+					lastSeq,
+					entries.length,
+					toPgJson(entries)
+				]);
+				return {
+					lastSeq,
+					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 statement: the header upsert numbers the entries inserted after it. */
+	async appendWorkflowRunEntries({ fence, steps, stepPatches, state, statePatch, startStateSeq, expectedStatus, ...run }) {
+		const entries = journalEntries(steps, {
+			state,
+			statePatch
+		}, false, stepPatches);
+		const expected = expectedStatus === void 0 ? [] : [[expectedStatus].flat()];
+		try {
+			return await withRunFence(this.#db.client, this.#runOwnersTable(), (0, _mastra_core_storage.resolveRunFence)(this, fence, run.runId), "appendWorkflowRunEntries", (q) => q.oneOrNone(`WITH h AS (${this.#upsertHeaderSql(false, expected.length ? "$15" : void 0)}),
+             e AS (
+               INSERT INTO ${this.#entriesTable()} (workflow_name, run_id, seq, kind, step_id, payload)
+               SELECT $1, $2, h."lastSeq" - $7::int + e.ord, ${ENTRY_VALUES}
+               FROM h, ${entryRows("$14")}
+             )
+             SELECT "lastSeq", "runToken" FROM h`, [
+				...this.#headerParams(run, entries.length),
+				startStateSeq ?? null,
+				toPgJson(entries),
+				...expected
+			]));
+		} 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.#db.client, workflowName, runId, { seq }))?.state ?? null;
+		} catch (error) {
+			throw this.#runError("LOAD_WORKFLOW_RUN_STATE", workflowName, runId, error);
+		}
+	}
+	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 {
+			row = await withRunFence(this.#db.client, this.#runOwnersTable(), (0, _mastra_core_storage.resolveRunFence)(this, void 0, runId), "appendWorkflowRunStateDraft", (q) => q.oneOrNone(`WITH h AS (
+               UPDATE ${this.#runsTable()} SET "lastSeq" = "lastSeq" + 1, "stateShared" = true
+               WHERE workflow_name = $1 AND run_id = $2
+               RETURNING "lastSeq"
+             )
+             INSERT INTO ${this.#entriesTable()} (workflow_name, run_id, seq, kind, step_id, payload)
+             SELECT $1, $2, h."lastSeq", 'state-draft', NULL, $3::jsonb FROM h
+             RETURNING seq`, [
+				workflowName,
+				runId,
+				toPgJson(payload)
+			]));
+		} 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 row;
 	}
 	supportsRunFencing() {
 		return true;
@@ -25998,6 +26676,7 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 				});
 				const existingSnapshotResult = await t.oneOrNone(`SELECT snapshot FROM ${tableName} WHERE workflow_name = $1 AND run_id = $2 FOR UPDATE`, [workflowName, runId]);
 				if (!existingSnapshotResult) {
+					if (await t.oneOrNone(`SELECT 1 FROM ${this.#runsTable()} WHERE workflow_name = $1 AND run_id = $2`, [workflowName, runId])) throw new Error(`updateWorkflowResults does not support storage v2 runs (run ${runId})`);
 					(0, _mastra_core_storage.assertWorkflowStepGuard)({
 						snapshot: null,
 						stepId,
@@ -26070,11 +26749,36 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}, error);
 		}
 	}
-	async updateWorkflowState({ workflowName, runId, opts, fence: explicitFence }) {
+	async updateWorkflowState({ workflowName, runId, opts, fence: explicitFence, storageVersion }) {
 		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence, runId);
 		try {
 			return await this.#db.client.tx(async (t) => {
 				if (fence) await assertRunFence(t, this.#runOwnersTable(), fence, "updateWorkflowState");
+				if (storageVersion !== 1) {
+					const run = await t.oneOrNone(`SELECT header FROM ${this.#runsTable()} WHERE workflow_name = $1 AND run_id = $2 FOR UPDATE`, [workflowName, runId]);
+					if (run) {
+						const { expectedStatus, ...patch } = opts;
+						if (!(0, _mastra_core_storage.matchesExpectedWorkflowStatus)(run.header.status, expectedStatus)) return;
+						const header = {
+							...run.header,
+							...patch
+						};
+						const now = /* @__PURE__ */ new Date();
+						const { entries } = await t.one(`UPDATE ${this.#runsTable()} r
+               SET header = $3::jsonb, status = $4, "updatedAt" = $5, "updatedAtZ" = $6
+               WHERE r.workflow_name = $1 AND r.run_id = $2
+               RETURNING ${this.#entriesSql("r")} AS entries`, [
+							workflowName,
+							runId,
+							toPgJson(header),
+							header.status,
+							now,
+							now
+						]);
+						return this.#materializeRun(t, header, entries);
+					}
+					if (storageVersion === 2) return void 0;
+				}
 				const tableName = getTableName({
 					indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 					schemaName: getSchemaName(this.#schema)
@@ -26154,10 +26858,14 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 	async loadWorkflowRunStatus({ workflowName, runId }) {
 		try {
 			const statusExpr = await this.#statusExpression("snapshot");
-			return (await this.#db.client.oneOrNone(`SELECT ${statusExpr} AS status FROM ${getTableName({
+			return (await this.#db.client.oneOrNone(`SELECT COALESCE(
+           (SELECT status FROM ${this.#runsTable()} WHERE workflow_name = $1 AND run_id = $2),
+           (SELECT ${statusExpr} FROM ${getTableName({
 				indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 				schemaName: getSchemaName(this.#schema)
-			})} WHERE "workflow_name" = $1 AND "run_id" = $2 ORDER BY "createdAt" DESC LIMIT 1`, [workflowName, runId]))?.status ?? null;
+			})}
+            WHERE "workflow_name" = $1 AND "run_id" = $2 ORDER BY "createdAt" DESC LIMIT 1)
+         ) AS status`, [workflowName, runId]))?.status ?? null;
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "LOAD_WORKFLOW_RUN_STATUS", "FAILED"),
@@ -26170,8 +26878,14 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}, error);
 		}
 	}
-	async loadWorkflowSnapshot({ workflowName, runId }) {
+	async loadWorkflowSnapshot({ workflowName, runId, storageVersion }) {
 		try {
+			if (storageVersion !== 1) {
+				const run = await this.#db.client.oneOrNone(`SELECT r.header, ${this.#entriesSql("r")} AS entries
+           FROM ${this.#runsTable()} r WHERE r.workflow_name = $1 AND r.run_id = $2`, [workflowName, runId]);
+				if (run) return await this.#materializeRun(this.#db.client, run.header, run.entries);
+				if (storageVersion === 2) return null;
+			}
 			const result = await this.#db.load({
 				tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 				keys: {
@@ -26188,7 +26902,7 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}, error);
 		}
 	}
-	async getWorkflowRunById({ runId, workflowName }) {
+	async getWorkflowRunById({ runId, workflowName, storageVersion }) {
 		try {
 			const conditions = [];
 			const values = [];
@@ -26204,18 +26918,14 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 				paramIndex++;
 			}
 			const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-			const query = `
-          SELECT * FROM ${getTableName({
-				indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
-				schemaName: getSchemaName(this.#schema)
-			})}
-          ${whereClause}
-          ORDER BY "createdAt" DESC LIMIT 1
-        `;
-			const queryValues = values;
-			const result = await this.#db.readClient.oneOrNone(query, queryValues);
+			const query = await this.#runsQuery({
+				v1Where: storageVersion === 2 ? null : whereClause,
+				v2Where: storageVersion === 1 ? null : whereClause,
+				page: "LIMIT 1"
+			});
+			const result = await this.#db.readClient.oneOrNone(query, values);
 			if (!result) return null;
-			return this.parseWorkflowRun(result);
+			return await this.#parseRun(this.#db.readClient, result);
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
@@ -26228,12 +26938,28 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}, error);
 		}
 	}
-	async deleteWorkflowRunById({ runId, workflowName, fence }) {
+	async deleteWorkflowRunById({ runId, workflowName, storageVersion, fence }) {
+		const resolvedFence = (0, _mastra_core_storage.resolveRunFence)(this, fence, runId);
 		try {
-			await withRunFence(this.#db.client, this.#runOwnersTable(), (0, _mastra_core_storage.resolveRunFence)(this, fence, runId), "deleteWorkflowRunById", (q) => q.none(`DELETE FROM ${getTableName({
-				indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
-				schemaName: getSchemaName(this.#schema)
-			})} WHERE run_id = $1 AND workflow_name = $2`, [runId, workflowName]));
+			if (storageVersion === 1) {
+				await withRunFence(this.#db.client, this.#runOwnersTable(), resolvedFence, "deleteWorkflowRunById", (q) => q.none(`DELETE FROM ${getTableName({
+					indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+					schemaName: getSchemaName(this.#schema)
+				})} WHERE run_id = $1 AND workflow_name = $2`, [runId, workflowName]));
+				return;
+			}
+			await this.#db.client.tx(async (t) => {
+				if (resolvedFence) await assertRunFence(t, this.#runOwnersTable(), resolvedFence, "deleteWorkflowRunById");
+				if ((await t.oneOrNone(`SELECT "stateShared" FROM ${this.#runsTable()} WHERE workflow_name = $1 AND run_id = $2 FOR UPDATE`, [workflowName, runId]))?.stateShared) await this.#detachStateChildren(t, workflowName, runId);
+				for (const table of [
+					this.#runsTable(),
+					this.#entriesTable(),
+					...storageVersion === 2 ? [] : [getTableName({
+						indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+						schemaName: getSchemaName(this.#schema)
+					})]
+				]) await t.none(`DELETE FROM ${table} WHERE run_id = $1 AND workflow_name = $2`, [runId, workflowName]);
+			});
 		} catch (error) {
 			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
@@ -26250,77 +26976,84 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 	async listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId, threadId, status, summary } = {}) {
 		try {
 			const conditions = [];
+			const v2Conditions = [];
 			const values = [];
 			let paramIndex = 1;
 			if (workflowName) {
 				conditions.push(`workflow_name = $${paramIndex}`);
+				v2Conditions.push(`workflow_name = $${paramIndex}`);
 				values.push(workflowName);
 				paramIndex++;
 			}
 			if (status) {
 				const statusExpr = await this.#db.getColumnType(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "snapshot") === "jsonb" ? `snapshot ->> 'status'` : `regexp_replace(snapshot::text, '\\\\u(0000|[Dd][89A-Fa-f][0-9A-Fa-f]{2})', '', 'g')::jsonb ->> 'status'`;
 				conditions.push(`${statusExpr} = $${paramIndex}`);
+				v2Conditions.push(`status = $${paramIndex}`);
 				values.push(status);
 				paramIndex++;
 			}
 			if (resourceId) {
-				if (await this.#db.hasColumn(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId")) {
-					conditions.push(`"resourceId" = $${paramIndex}`);
-					values.push(resourceId);
-					paramIndex++;
-				} else this.logger?.warn?.(`[${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+				if (await this.#db.hasColumn(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId")) conditions.push(`"resourceId" = $${paramIndex}`);
+				else this.logger?.warn?.(`[${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+				v2Conditions.push(`"resourceId" = $${paramIndex}`);
+				values.push(resourceId);
+				paramIndex++;
 			}
 			if (threadId) {
-				if (await this.#db.getColumnType(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "snapshot") === "jsonb") {
-					conditions.push(`${WORKFLOW_SNAPSHOT_THREAD_ID_EXPR} = $${paramIndex}`);
-					values.push(threadId);
-					paramIndex++;
-				} else this.logger?.warn?.(`[${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT}] snapshot column is not jsonb. Skipping threadId filter.`);
+				if (await this.#db.getColumnType(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "snapshot") === "jsonb") conditions.push(`${WORKFLOW_SNAPSHOT_THREAD_ID_EXPR} = $${paramIndex}`);
+				else this.logger?.warn?.(`[${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT}] snapshot column is not jsonb. Skipping threadId filter.`);
+				v2Conditions.push(`"threadId" = $${paramIndex}`);
+				values.push(threadId);
+				paramIndex++;
 			}
 			if (fromDate) {
 				conditions.push(`"createdAt" >= $${paramIndex}`);
+				v2Conditions.push(`"createdAt" >= $${paramIndex}`);
 				values.push(fromDate);
 				paramIndex++;
 			}
 			if (toDate) {
 				conditions.push(`"createdAt" <= $${paramIndex}`);
+				v2Conditions.push(`"createdAt" <= $${paramIndex}`);
 				values.push(toDate);
 				paramIndex++;
 			}
 			const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-			let total = 0;
+			const v2WhereClause = v2Conditions.length > 0 ? `WHERE ${v2Conditions.join(" AND ")}` : "";
 			const usePagination = typeof perPage === "number" && typeof page === "number";
-			if (usePagination) {
-				const countResult = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${getTableName({
-					indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
-					schemaName: getSchemaName(this.#schema)
-				})} ${whereClause}`, values);
-				total = Number(countResult.count);
-			}
 			const normalizedPerPage = usePagination ? (0, _mastra_core_storage.normalizePerPage)(perPage, Number.MAX_SAFE_INTEGER) : 0;
-			const offset = usePagination ? page * normalizedPerPage : void 0;
-			let selectList = "*";
+			const offset = usePagination ? page * normalizedPerPage : 0;
+			let v1Snapshot = "snapshot";
 			if (summary) {
 				const snapshotJson = await this.#db.getColumnType(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "snapshot") === "jsonb" ? "snapshot" : `regexp_replace(snapshot::text, '\\\\u(0000|[Dd][89A-Fa-f][0-9A-Fa-f]{2})', '', 'g')::jsonb`;
-				selectList = `workflow_name, run_id, "resourceId", "createdAt", "createdAtZ", "updatedAt", "updatedAtZ", jsonb_build_object('status', ${snapshotJson} -> 'status', 'timestamp', ${snapshotJson} -> 'timestamp') AS snapshot`;
+				v1Snapshot = `jsonb_build_object('status', ${snapshotJson} -> 'status', 'timestamp', ${snapshotJson} -> 'timestamp')`;
 			}
-			const query = `
-          SELECT ${selectList} FROM ${getTableName({
-				indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
-				schemaName: getSchemaName(this.#schema)
-			})}
-          ${whereClause}
-          ORDER BY "createdAt" DESC
-          ${usePagination ? ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}` : ""}
-        `;
+			const query = await this.#runsQuery({
+				v1Where: whereClause,
+				v2Where: v2WhereClause,
+				v1Snapshot,
+				summary,
+				page: usePagination ? `LIMIT $${paramIndex} OFFSET $${paramIndex + 1}` : ""
+			});
 			const queryValues = usePagination ? [
 				...values,
 				normalizedPerPage,
 				offset
 			] : values;
-			const runs = (await this.#db.client.manyOrNone(query, queryValues) || []).map((row) => {
-				return this.parseWorkflowRun(row);
-			});
+			const result = await this.#db.client.manyOrNone(query, queryValues);
+			const runs = await Promise.all((result || []).map((row) => this.#parseRun(this.#db.client, row)));
+			let total = 0;
+			if (usePagination) {
+				total = offset + runs.length;
+				if (runs.length === normalizedPerPage || runs.length === 0 && offset > 0) {
+					const countResult = await this.#db.client.one(`SELECT (SELECT COUNT(*) FROM ${getTableName({
+						indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+						schemaName: getSchemaName(this.#schema)
+					})} ${whereClause})
+               + (SELECT COUNT(*) FROM ${this.#runsTable()} ${v2WhereClause}) AS count`, values);
+					total = Number(countResult.count);
+				}
+			}
 			return {
 				runs,
 				total: total || runs.length