@mastra/pg 1.33.0 → 1.34.0-alpha.1

package/dist/index.js

@@ -5,12 +5,13 @@ import { parseFieldKey, parseSqlIdentifier } from "@mastra/core/utils";
 import { MastraVector, validateTopK, validateUpsertInput } from "@mastra/core/vector";
 import { Mutex } from "async-mutex";
 import * as pg$1 from "pg";
-import pg, { Pool, defaults } from "pg";
+import pg, { Pool, defaults, escapeIdentifier } from "pg";
 import xxhash from "xxhash-wasm";
 import { parse } from "pg-connection-string";
 import { BaseFilterTranslator } from "@mastra/core/vector/filter";
 import { MastraBase } from "@mastra/core/base";
 import { createHash, randomUUID } from "crypto";
+import { setTimeout as setTimeout$1 } from "timers/promises";
 import { coreFeatures } from "@mastra/core/features";
 import { MessageList } from "@mastra/core/agent";
 import { saveScorePayloadSchema } from "@mastra/core/evals";
@@ -2253,6 +2254,9 @@ var PinnedClientAdapter = class {
 		this.#tail = next.catch(() => void 0);
 		return next;
 	}
+	async drain() {
+		await this.#tail;
+	}
 	connect() {
 		throw new Error("PinnedClientAdapter.connect() is not supported during PostgresStore.init(). All DDL must flow through the pinned client.");
 	}
@@ -2435,6 +2439,39 @@ function buildConstraintName({ baseName, schemaName, maxLength = 63, hashWhenTru
 	return truncateIdentifier(fullName, maxLength);
 }
 // src/storage/db/pg-errors.ts
+/**
+* Postgres error classifiers for concurrent DDL.
+*
+* `CREATE SCHEMA / TABLE / INDEX IF NOT EXISTS` checks aren't atomic against
+* concurrent backends. Two callers racing past the existence probe can both
+* reach the catalog insert; the loser sees a duplicate-object error. These
+* helpers identify the exact codes we treat as "already exists by the time we
+* look" so every other error surfaces normally.
+*/
+var IndexBuildError = class extends Error {
+	constructor(indexName, schemaName, state, cause) {
+		super(`Could not create index ${schemaName}.${indexName}: ${state}`, { cause });
+		this.name = "IndexBuildError";
+	}
+};
+function* causes(error) {
+	const seen = /* @__PURE__ */ new Set();
+	while (typeof error === "object" && error !== null && !seen.has(error)) {
+		seen.add(error);
+		yield error;
+		error = "cause" in error ? error.cause : void 0;
+	}
+}
+/** Index recovery owns its retry budget, even through an outer MastraError. */
+function isRetryableDeadlock(error) {
+	for (const cause of causes(error)) if (cause instanceof IndexBuildError) return false;
+	for (const cause of causes(error)) if ("code" in cause && cause.code === "40P01") return true;
+	return false;
+}
+async function backoffAfterDeadlock(attempt) {
+	const base = 50 * 2 ** (attempt - 1);
+	await new Promise((resolve) => setTimeout(resolve, base + Math.random() * base * 2));
+}
 function asPgError(error) {
 	return error ?? {};
 }
@@ -2462,6 +2499,99 @@ function isDuplicateSchemaError(error) {
 	if (code === "23505" && constraint === "pg_namespace_nspname_index") return true;
 	return /schema .* already exists/i.test(message);
 }
+// src/storage/db/index-build.ts
+/** A cold snapshot cannot arbitrate DDL submitted by independent processes. */
+async function buildIndex(client, schemaName, indexName, build, logger) {
+	const deadline = performance.now() + 3e4;
+	let attempts = 0;
+	let failure;
+	let state = "not built";
+	let repairFailures = 0;
+	const observe = (db = client) => db.oneOrNone(`SELECT c.oid, i.indrelid AS table_oid, t.relname AS table_name,
+              tn.nspname AS table_schema, i.indisvalid AS valid
+       FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+       LEFT JOIN pg_index i ON i.indexrelid = c.oid
+       LEFT JOIN pg_class t ON t.oid = i.indrelid
+       LEFT JOIN pg_namespace tn ON tn.oid = t.relnamespace
+      WHERE n.nspname = $1 AND c.relname = $2`, [schemaName, indexName]);
+	while (true) {
+		const relation = await observe();
+		if (relation?.valid) return true;
+		if (relation && relation.valid === null) throw new IndexBuildError(indexName, schemaName, "name belongs to a non-index relation", failure);
+		if (relation) {
+			if (await client.oneOrNone(`SELECT p.pid FROM pg_stat_progress_create_index p
+          WHERE p.datid = (SELECT oid FROM pg_database WHERE datname = current_database())
+            AND p.pid <> pg_backend_pid()
+            AND (p.index_relid = $1 OR ((p.index_relid IS NULL OR p.index_relid = 0) AND EXISTS (
+              SELECT 1 FROM pg_locks l WHERE l.pid = p.pid AND l.database = p.datid
+                AND l.locktype = 'relation' AND l.relation = $2 AND l.granted
+                AND l.mode IN ('ShareUpdateExclusiveLock', 'ShareLock')
+            )))
+          LIMIT 1`, [relation.oid, relation.table_oid])) {
+				logger.warn(`Index ${indexName} is being built by another session; skipping`);
+				return false;
+			}
+			if (performance.now() >= deadline && state === "table busy during invalid-index repair") {
+				logger.warn(`Index ${indexName} could not be repaired because its table is busy; skipping`);
+				return false;
+			}
+			if (attempts >= 3 || performance.now() >= deadline) break;
+			state = "abandoned invalid index";
+			attempts++;
+			let lockUnavailable = false;
+			try {
+				const result = await client.tx(async (tx) => {
+					const table = `${escapeIdentifier(relation.table_schema)}.${escapeIdentifier(relation.table_name)}`;
+					await tx.none(`SET LOCAL lock_timeout = '100ms'`);
+					try {
+						await tx.none(`LOCK TABLE ${table} IN ACCESS EXCLUSIVE MODE`);
+					} catch (error) {
+						lockUnavailable = typeof error === "object" && error !== null && "code" in error && error.code === "55P03";
+						throw error;
+					}
+					const current = await observe(tx);
+					if (current?.valid) return "valid";
+					const locked = await tx.one("SELECT to_regclass($1)::oid AS oid", [table]);
+					if (!current || current.oid !== relation.oid || current.table_oid !== locked.oid) return "changed";
+					logger.warn(`Dropping invalid index ${indexName} left by an interrupted build; rebuilding it`);
+					await tx.none(`DROP INDEX ${escapeIdentifier(schemaName)}.${escapeIdentifier(indexName)}`);
+					return "dropped";
+				});
+				if (result === "valid") return true;
+				if (result === "changed") {
+					attempts--;
+					if (performance.now() >= deadline) break;
+					continue;
+				}
+			} catch (error) {
+				attempts--;
+				if (lockUnavailable) {
+					state = "table busy during invalid-index repair";
+					failure ??= error;
+					await setTimeout$1(100);
+					continue;
+				}
+				if (!isDuplicateRelationError(error) && !isRetryableDeadlock(error) && !(typeof error === "object" && error !== null && "code" in error && error.code === "42P01")) throw error;
+				failure ??= error;
+				if (++repairFailures >= 3 || performance.now() >= deadline) break;
+				continue;
+			}
+		} else {
+			if (attempts >= 3 || performance.now() >= deadline) break;
+			attempts++;
+		}
+		try {
+			await build();
+		} catch (error) {
+			if (!isDuplicateRelationError(error) && !isRetryableDeadlock(error)) throw error;
+			failure ??= error;
+			const deadlock = isRetryableDeadlock(error);
+			state = deadlock ? "index build deadlock" : "competing index creation";
+			if (deadlock && attempts < 3 && performance.now() < deadline) await backoffAfterDeadlock(attempts);
+		}
+	}
+	throw new IndexBuildError(indexName, schemaName, state, failure);
+}
 // src/storage/db/sanitize-json.ts
 const repair = (value) => value.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "�").replaceAll("\0", "");
 function repairJson(value) {
@@ -2517,9 +2647,10 @@ async function loadSchemaSnapshot(client, schemaName) {
           AND c.relkind IN ('r', 'p')
           AND a.attnum > 0
           AND NOT a.attisdropped`, [schema]),
-		client.manyOrNone(`SELECT c.relname AS indexname, i.indisreplident AS is_replica_identity, i.indisprimary AS is_primary, i.indisvalid AS is_valid
+		client.manyOrNone(`SELECT c.relname AS indexname, t.relname AS table_name, i.indisreplident AS is_replica_identity, i.indisprimary AS is_primary, i.indisvalid AS is_valid
          FROM pg_catalog.pg_index i
          JOIN pg_catalog.pg_class c ON c.oid = i.indexrelid
+         JOIN pg_catalog.pg_class t ON t.oid = i.indrelid
          JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
         WHERE n.nspname = $1`, [schema])
 	]);
@@ -2550,13 +2681,11 @@ async function loadSchemaSnapshot(client, schemaName) {
 	}
 	const indexes = /* @__PURE__ */ new Set();
 	const replicaIdentityIndexes = /* @__PURE__ */ new Set();
-	const primaryKeyIndexes = /* @__PURE__ */ new Set();
-	const invalidIndexes = /* @__PURE__ */ new Set();
+	const primaryKeyIndexes = /* @__PURE__ */ new Map();
 	for (const row of indexRows) {
 		if (row.is_valid) indexes.add(row.indexname);
-		else invalidIndexes.add(row.indexname);
 		if (row.is_replica_identity) replicaIdentityIndexes.add(row.indexname);
-		if (row.is_primary) primaryKeyIndexes.add(row.indexname.toLowerCase());
+		if (row.is_primary) primaryKeyIndexes.set(row.indexname.toLowerCase(), row.table_name);
 	}
 	return {
 		schemaName: schema,
@@ -2566,8 +2695,7 @@ async function loadSchemaSnapshot(client, schemaName) {
 		notNullColumns,
 		indexes,
 		replicaIdentityIndexes,
-		primaryKeyIndexes,
-		invalidIndexes
+		primaryKeyIndexes
 	};
 }
 // src/storage/db/index.ts
@@ -3479,14 +3607,17 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			baseName: "mastra_ai_spans_traceid_spanid_pk",
 			schemaName: (this.schemaName ? schemaNamePrefix(this.schemaName) : "") || void 0
 		});
-		const schemaFilter = this.schemaName || "public";
+		const fullTableName = getTableName$6({
+			indexName: TABLE_SPANS,
+			schemaName: getSchemaName$6(this.schemaName)
+		});
 		const snapshot = this.schemaSnapshot;
-		if (snapshot) return snapshot.primaryKeyIndexes.has(constraintName.toLowerCase());
-		return this.spansPrimaryKeyExistsLive(constraintName, schemaFilter);
+		if (snapshot) return snapshot.primaryKeyIndexes.get(constraintName.toLowerCase()) === TABLE_SPANS;
+		return this.spansPrimaryKeyExistsLive(constraintName, fullTableName);
 	}
 	/** Live-catalog variant of {@link spansPrimaryKeyExists}, bypassing the snapshot. */
-	async spansPrimaryKeyExistsLive(constraintName, schemaFilter) {
-		return (await this.client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = lower($1) AND connamespace = (SELECT oid FROM pg_namespace WHERE nspname = $2)) as exists`, [constraintName, schemaFilter]))?.exists ?? false;
+	async spansPrimaryKeyExistsLive(constraintName, fullTableName) {
+		return (await this.client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = lower($1) AND contype = 'p' AND conrelid = to_regclass($2)) as exists`, [constraintName, fullTableName]))?.exists ?? false;
 	}
 	/**
 	* Adds the PRIMARY KEY constraint on (traceId, spanId) to the spans table.
@@ -3501,13 +3632,8 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			baseName: "mastra_ai_spans_traceid_spanid_pk",
 			schemaName: (this.schemaName ? schemaNamePrefix(this.schemaName) : "") || void 0
 		});
-		const schemaFilter = this.schemaName || "public";
 		try {
-			if ((await this.client.oneOrNone(`
-        SELECT EXISTS (
-          SELECT 1 FROM pg_constraint WHERE conname = lower($1) AND connamespace = (SELECT oid FROM pg_namespace WHERE nspname = $2)
-        ) as exists
-      `, [constraintName, schemaFilter]))?.exists) {
+			if (await this.spansPrimaryKeyExistsLive(constraintName, fullTableName)) {
 				this.logger?.debug?.(`PRIMARY KEY constraint ${constraintName} already exists on ${fullTableName}`);
 				return;
 			}
@@ -3516,12 +3642,13 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
         ADD CONSTRAINT ${constraintName}
         PRIMARY KEY ("traceId", "spanId")
       `);
-			this.schemaSnapshot?.primaryKeyIndexes.add(constraintName.toLowerCase());
+			this.schemaSnapshot?.primaryKeyIndexes.set(constraintName.toLowerCase(), TABLE_SPANS);
 			this.logger?.info?.(`Added PRIMARY KEY constraint ${constraintName} to ${fullTableName}`);
 		} catch (error) {
-			if (isDuplicateRelationError(error)) {
-				if (await this.spansPrimaryKeyExistsLive(constraintName, schemaFilter)) {
-					this.schemaSnapshot?.primaryKeyIndexes.add(constraintName.toLowerCase());
+			const primaryKeyRace = typeof error === "object" && error !== null && "code" in error && error.code === "42P16";
+			if (isDuplicateRelationError(error) || primaryKeyRace) {
+				if (await this.spansPrimaryKeyExistsLive(constraintName, fullTableName)) {
+					this.schemaSnapshot?.primaryKeyIndexes.set(constraintName.toLowerCase(), TABLE_SPANS);
 					this.logger?.debug?.(`PRIMARY KEY constraint ${constraintName} was created by another process`);
 					return;
 				}
@@ -3738,7 +3865,6 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			});
 			const snapshot = this.schemaSnapshot;
 			if (snapshot?.indexes.has(name)) return;
-			if (!await this.prepareIndexBuild(name, schemaName)) return;
 			const uniqueStr = unique ? "UNIQUE " : "";
 			const concurrentStr = concurrent ? "CONCURRENTLY " : "";
 			const methodStr = method !== "btree" ? `USING ${method} ` : "";
@@ -3756,9 +3882,8 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			const tablespaceStr = tablespace ? ` TABLESPACE ${tablespace}` : "";
 			let withStr = "";
 			if (storage && Object.keys(storage).length > 0) withStr = ` WITH (${Object.entries(storage).map(([key, value]) => `${key} = ${value}`).join(", ")})`;
-			const sql = `CREATE ${uniqueStr}INDEX ${concurrentStr}${`"${parseSqlIdentifier(name, "index name")}"`} ON ${fullTableName} ${methodStr}(${columnsStr})${withStr}${tablespaceStr}${whereStr}`;
-			await this.timedIndexBuild(name, sql);
-			snapshot?.indexes.add(name);
+			const sql = `CREATE ${uniqueStr}INDEX ${concurrentStr}IF NOT EXISTS ${`"${parseSqlIdentifier(name, "index name")}"`} ON ${fullTableName} ${methodStr}(${columnsStr})${withStr}${tablespaceStr}${whereStr}`;
+			if (await buildIndex(this.client, schemaName, name, () => this.timedIndexBuild(name, sql), this.logger)) snapshot?.indexes.add(name);
 		} catch (error) {
 			throw new MastraError({
 				id: createStorageErrorId("PG", "INDEX_CREATE", "FAILED"),
@@ -3783,36 +3908,7 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 	async createIndexFromStatement(indexName, sql) {
 		const snapshot = this.schemaSnapshot;
 		if (snapshot?.indexes.has(indexName)) return;
-		if (!await this.prepareIndexBuild(indexName, this.schemaName || "public")) return;
-		await this.timedIndexBuild(indexName, sql);
-		snapshot?.indexes.add(indexName);
-	}
-	/**
-	* Decides whether `indexName` still needs building. Returns false when a valid
-	* index already exists, or when another session is currently building it.
-	* An invalid index left by an interrupted `CREATE INDEX CONCURRENTLY` is
-	* dropped (concurrently) so the caller rebuilds it — `IF NOT EXISTS` would
-	* otherwise keep the broken index forever.
-	*/
-	async prepareIndexBuild(indexName, schemaName) {
-		const snapshot = this.schemaSnapshot;
-		if (snapshot && !snapshot.invalidIndexes.has(indexName)) return true;
-		const existing = await this.client.oneOrNone(`SELECT i.indisvalid AS is_valid,
-              EXISTS (SELECT 1 FROM pg_stat_progress_create_index p WHERE p.index_relid = c.oid) AS building
-         FROM pg_catalog.pg_index i
-         JOIN pg_catalog.pg_class c ON c.oid = i.indexrelid
-         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-        WHERE c.relname = $1 AND n.nspname = $2`, [indexName, schemaName]);
-		if (!existing) return true;
-		if (existing.is_valid) return false;
-		if (existing.building) {
-			this.logger.warn(`Index ${indexName} is being built by another session; skipping`);
-			return false;
-		}
-		this.logger.warn(`Dropping invalid index ${indexName} left by an interrupted build; rebuilding it`);
-		const quotedIndexName = `"${parseSqlIdentifier(indexName, "index name")}"`;
-		await this.client.none(`DROP INDEX CONCURRENTLY IF EXISTS ${getSchemaName$6(this.schemaName)}.${quotedIndexName}`);
-		return true;
+		if (await buildIndex(this.client, this.schemaName || "public", indexName, () => this.timedIndexBuild(indexName, sql), this.logger)) snapshot?.indexes.add(indexName);
 	}
 	async timedIndexBuild(indexName, sql) {
 		const startedAt = Date.now();
@@ -5166,6 +5262,7 @@ function rowToTask(row) {
 	const suspendedAt = row.suspendedAtZ || row.suspendedAt;
 	const completedAt = row.completedAtZ || row.completedAt;
 	const leaseExpiresAt = row.leaseExpiresAtZ || row.leaseExpiresAt;
+	const expiresAt = row.expiresAt != null ? row.expiresAtZ || row.expiresAt : void 0;
 	return {
 		id: row.id,
 		status: row.status,
@@ -5187,10 +5284,13 @@ function rowToTask(row) {
 		suspendedAt: suspendedAt ? suspendedAt instanceof Date ? suspendedAt : new Date(suspendedAt) : void 0,
 		completedAt: completedAt ? completedAt instanceof Date ? completedAt : new Date(completedAt) : void 0,
 		ownerId: row.ownerId ?? void 0,
-		leaseExpiresAt: leaseExpiresAt ? leaseExpiresAt instanceof Date ? leaseExpiresAt : new Date(leaseExpiresAt) : void 0
+		leaseExpiresAt: leaseExpiresAt ? leaseExpiresAt instanceof Date ? leaseExpiresAt : new Date(leaseExpiresAt) : void 0,
+		expiresAt: expiresAt ? expiresAt instanceof Date ? expiresAt : new Date(expiresAt) : void 0,
+		metadata: parseJson$2(row.metadata)
 	};
 }
 var BackgroundTasksPG = class BackgroundTasksPG extends BackgroundTasksStorage {
+	supportsTaskExpiry = true;
 	#db;
 	#schema;
 	#skipDefaultIndexes;
@@ -5231,7 +5331,9 @@ var BackgroundTasksPG = class BackgroundTasksPG extends BackgroundTasksStorage {
 				"suspend_payload",
 				"suspendedAt",
 				"ownerId",
-				"leaseExpiresAt"
+				"leaseExpiresAt",
+				"expiresAt",
+				"metadata"
 			]
 		});
 		await this.createDefaultIndexes();
@@ -5365,7 +5467,10 @@ var BackgroundTasksPG = class BackgroundTasksPG extends BackgroundTasksStorage {
 				completedAtZ: task.completedAt?.toISOString() ?? null,
 				ownerId: task.ownerId ?? null,
 				leaseExpiresAt: task.leaseExpiresAt?.toISOString() ?? null,
-				leaseExpiresAtZ: task.leaseExpiresAt?.toISOString() ?? null
+				leaseExpiresAtZ: task.leaseExpiresAt?.toISOString() ?? null,
+				expiresAt: task.expiresAt?.toISOString() ?? null,
+				expiresAtZ: task.expiresAt?.toISOString() ?? null,
+				metadata: serializeJson(task.metadata)
 			}
 		});
 	}
@@ -5421,6 +5526,16 @@ var BackgroundTasksPG = class BackgroundTasksPG extends BackgroundTasksStorage {
 			const val = update.leaseExpiresAt?.toISOString() ?? null;
 			params.push(val, val);
 		}
+		if ("expiresAt" in update) {
+			setClauses.push(`"expiresAt" = $${paramIdx++}`);
+			setClauses.push(`"expiresAtZ" = $${paramIdx++}`);
+			const val = update.expiresAt?.toISOString() ?? null;
+			params.push(val, val);
+		}
+		if ("metadata" in update) {
+			setClauses.push(`"metadata" = $${paramIdx++}`);
+			params.push(serializeJson(update.metadata));
+		}
 		if (setClauses.length === 0) return false;
 		const table = getTableName$4(getSchemaName$4(this.#schema));
 		params.push(taskId);
@@ -5443,6 +5558,13 @@ var BackgroundTasksPG = class BackgroundTasksPG extends BackgroundTasksStorage {
 				params.push(options.expectedLeaseExpiresAt.toISOString());
 			}
 		}
+		if (options?.expectedSuspendedAt !== void 0) {
+			if (options.expectedSuspendedAt === null) where += ` AND "suspendedAtZ" IS NULL`;
+			else {
+				where += ` AND "suspendedAtZ" = $${paramIdx++}`;
+				params.push(options.expectedSuspendedAt.toISOString());
+			}
+		}
 		return ((await this.#db.client.query(`UPDATE ${table} SET ${setClauses.join(", ")} WHERE ${where}`, params)).rowCount ?? 0) > 0;
 	}
 	async getTask(taskId) {
@@ -5485,7 +5607,9 @@ var BackgroundTasksPG = class BackgroundTasksPG extends BackgroundTasksStorage {
 			conditions.push(`"tool_call_id" = $${paramIdx++}`);
 			params.push(filter.toolCallId);
 		}
-		const dateCol = filter.dateFilterBy === "startedAt" ? "\"startedAt\"" : filter.dateFilterBy === "suspendedAt" ? "\"suspendedAt\"" : filter.dateFilterBy === "completedAt" ? "\"completedAt\"" : "\"createdAt\"";
+		const dateCol = filter.dateFilterBy === "startedAt" ? "\"startedAt\"" : filter.dateFilterBy === "suspendedAt" ? "\"suspendedAt\"" : filter.dateFilterBy === "completedAt" ? "\"completedAt\"" : filter.dateFilterBy === "expiresAt" ? "\"expiresAtZ\"" : "\"createdAt\"";
+		if (filter.hasExpiresAt !== void 0) conditions.push(filter.hasExpiresAt ? "\"expiresAt\" IS NOT NULL" : "\"expiresAt\" IS NULL");
+		if (filter.dateFilterBy === "expiresAt" && (filter.fromDate || filter.toDate)) conditions.push("\"expiresAt\" IS NOT NULL");
 		if (filter.fromDate) {
 			conditions.push(`${dateCol} >= $${paramIdx++}`);
 			params.push(filter.fromDate.toISOString());
@@ -5526,7 +5650,9 @@ var BackgroundTasksPG = class BackgroundTasksPG extends BackgroundTasksStorage {
 			conditions.push(`"status" IN (${placeholders.join(", ")})`);
 			params.push(...statuses);
 		}
-		const dateCol = filter.dateFilterBy === "startedAt" ? "\"startedAt\"" : filter.dateFilterBy === "suspendedAt" ? "\"suspendedAt\"" : filter.dateFilterBy === "completedAt" ? "\"completedAt\"" : "\"createdAt\"";
+		const dateCol = filter.dateFilterBy === "startedAt" ? "\"startedAt\"" : filter.dateFilterBy === "suspendedAt" ? "\"suspendedAt\"" : filter.dateFilterBy === "completedAt" ? "\"completedAt\"" : filter.dateFilterBy === "expiresAt" ? "\"expiresAtZ\"" : "\"createdAt\"";
+		if (filter.hasExpiresAt !== void 0) conditions.push(filter.hasExpiresAt ? "\"expiresAt\" IS NOT NULL" : "\"expiresAt\" IS NULL");
+		if (filter.dateFilterBy === "expiresAt" && (filter.fromDate || filter.toDate)) conditions.push("\"expiresAt\" IS NOT NULL");
 		if (filter.fromDate) {
 			conditions.push(`${dateCol} >= $${paramIdx++}`);
 			params.push(filter.fromDate.toISOString());
@@ -7142,6 +7268,19 @@ var DatasetsPG = class DatasetsPG extends DatasetsStorage {
 };
 // src/storage/domains/experiments/index.ts
 const DEFAULT_PRUNE_BATCH_SIZE = 1e3;
+/**
+* Column list for reading experiment rows. Each `timestamp` column comes back
+* twice: as itself, and as its `*Z` mirror derived in the query with
+* `AT TIME ZONE 'UTC'`. A plain `timestamp` otherwise round-trips through the
+* session timezone, and reading the stored `*Z` column instead would return the
+* insert time for rows written before the mirrors were filled in. Deriving it
+* here makes legacy rows read correctly with no backfill to run at startup.
+*/
+function selectWithMirrors(schema) {
+	return Object.entries(schema).flatMap(([name, definition]) => definition.type === "timestamp" ? [`"${name}"`, `"${name}" AT TIME ZONE 'UTC' AS "${name}Z"`] : [`"${name}"`]).join(", ");
+}
+const EXPERIMENT_COLUMNS = selectWithMirrors(EXPERIMENTS_SCHEMA);
+const EXPERIMENT_RESULT_COLUMNS = selectWithMirrors(EXPERIMENT_RESULTS_SCHEMA);
 var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 	#db;
 	#schema;
@@ -7150,9 +7289,9 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 	static MANAGED_TABLES = [TABLE_EXPERIMENTS, TABLE_EXPERIMENT_RESULTS];
 	/**
 	* Experiments prune as whole units: an aged experiment and its result rows go
-	* together, mirroring `deleteExperiment`. Anchored on `completedAt` (not the
-	* `completedAtZ` mirror, which carries a `DEFAULT NOW()` this domain never
-	* overrides — it holds insert time even for running rows). `completedAt` is
+	* together, mirroring `deleteExperiment`. Anchored on `completedAt` rather
+	* than its `completedAtZ` mirror: both are written together, but
+	* `completedAt` is the column the retention index covers. `completedAt` is
 	* written as a UTC ISO string and stays NULL while running, so
 	* `completedAt < cutoff` is false for in-flight experiments.
 	*/
@@ -7472,7 +7611,11 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 					startedAt: null,
 					completedAt: null,
 					createdAt: nowIso,
-					updatedAt: nowIso
+					updatedAt: nowIso,
+					startedAtZ: null,
+					completedAtZ: null,
+					createdAtZ: nowIso,
+					updatedAtZ: nowIso
 				}
 			});
 			return {
@@ -7561,12 +7704,14 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 				values.push(input.skippedCount);
 			}
 			if (input.startedAt !== void 0) {
-				setClauses.push(`"startedAt" = $${paramIndex++}`);
-				values.push(input.startedAt?.toISOString() ?? null);
+				const iso = input.startedAt?.toISOString() ?? null;
+				setClauses.push(`"startedAt" = $${paramIndex++}`, `"startedAtZ" = $${paramIndex++}`);
+				values.push(iso, iso);
 			}
 			if (input.completedAt !== void 0) {
-				setClauses.push(`"completedAt" = $${paramIndex++}`);
-				values.push(input.completedAt?.toISOString() ?? null);
+				const iso = input.completedAt?.toISOString() ?? null;
+				setClauses.push(`"completedAt" = $${paramIndex++}`, `"completedAtZ" = $${paramIndex++}`);
+				values.push(iso, iso);
 			}
 			values.push(input.id);
 			await this.#db.client.none(`UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE "id" = $${paramIndex}`, values);
@@ -7595,7 +7740,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 			});
 			const { conditions, params } = tenancyWhere(filters, 2);
 			const whereSql = ["\"id\" = $1", ...conditions].join(" AND ");
-			const result = await client.oneOrNone(`SELECT * FROM ${tableName} WHERE ${whereSql}`, [id, ...params]);
+			const result = await client.oneOrNone(`SELECT ${EXPERIMENT_COLUMNS} FROM ${tableName} WHERE ${whereSql}`, [id, ...params]);
 			return result ? this.transformExperimentRow(result) : null;
 		} catch (error) {
 			throw new MastraError({
@@ -7682,7 +7827,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 			const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
 			const limitValue = perPageInput === false ? total : perPage;
 			return {
-				experiments: (await this.#db.readClient.manyOrNone(`SELECT * FROM ${tableName} ${whereClause} ORDER BY "${orderBy.field}" ${orderBy.direction}, "id" ASC LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`, [
+				experiments: (await this.#db.readClient.manyOrNone(`SELECT ${EXPERIMENT_COLUMNS} FROM ${tableName} ${whereClause} ORDER BY "${orderBy.field}" ${orderBy.direction}, "id" ASC LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`, [
 					...queryParams,
 					limitValue,
 					offset
@@ -7760,9 +7905,11 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 				return t.one(`INSERT INTO ${resultsTable} (
             "id", "experimentId", "itemId", "itemDatasetVersion", "organizationId", "projectId",
             "input", "output", "groundTruth", "metadata", "error", "startedAt", "completedAt",
-            "retryCount", "attempt", "traceId", "status", "tags", "toolMockReport", "createdAt"
-          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20)
-          RETURNING *`, [
+            "retryCount", "attempt", "traceId", "status", "tags", "toolMockReport", "createdAt",
+            "startedAtZ", "completedAtZ", "createdAtZ"
+          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20,
+            $21, $22, $23)
+          RETURNING ${EXPERIMENT_RESULT_COLUMNS}`, [
 					id,
 					input.experimentId,
 					input.itemId,
@@ -7782,6 +7929,9 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 					input.status ?? null,
 					purgeMetadata || input.tags == null ? null : toPgJson(input.tags),
 					purgeMetadata || input.toolMockReport == null ? null : toPgJson(input.toolMockReport),
+					nowIso,
+					input.startedAt.toISOString(),
+					input.completedAt.toISOString(),
 					nowIso
 				]);
 			});
@@ -7808,6 +7958,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 			const row = await this.#db.client.tx(async (t) => {
 				const owner = await t.oneOrNone(`SELECT "datasetId" FROM ${experimentsTable} WHERE "id" = $1`, [input.experimentId]);
 				const purgeMetadata = await this.#resolvePurgeMetadata(t, owner?.datasetId, input.itemId);
+				const nowIso = (/* @__PURE__ */ new Date()).toISOString();
 				const existing = await t.oneOrNone(`SELECT "id" FROM ${tableName} WHERE "experimentId" = $1 AND "itemId" = $2 AND COALESCE("attempt", 0) = $3 FOR UPDATE`, [
 					input.experimentId,
 					input.itemId,
@@ -7818,9 +7969,11 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 					return t.one(`INSERT INTO ${tableName} (
               "id", "experimentId", "itemId", "itemDatasetVersion", "organizationId", "projectId",
               "input", "output", "groundTruth", "metadata", "error", "startedAt", "completedAt",
-              "retryCount", "attempt", "traceId", "status", "tags", "toolMockReport", "createdAt"
-            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20)
-            RETURNING *`, [
+              "retryCount", "attempt", "traceId", "status", "tags", "toolMockReport", "createdAt",
+              "startedAtZ", "completedAtZ", "createdAtZ"
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20,
+              $21, $22, $23)
+            RETURNING ${EXPERIMENT_RESULT_COLUMNS}`, [
 						id,
 						input.experimentId,
 						input.itemId,
@@ -7840,15 +7993,19 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 						input.status ?? null,
 						purgeMetadata || input.tags == null ? null : toPgJson(input.tags),
 						purgeMetadata || input.toolMockReport == null ? null : toPgJson(input.toolMockReport),
-						(/* @__PURE__ */ new Date()).toISOString()
+						nowIso,
+						input.startedAt.toISOString(),
+						input.completedAt.toISOString(),
+						nowIso
 					]);
 				}
 				return t.one(`UPDATE ${tableName} SET
             "itemDatasetVersion" = $2, "organizationId" = $3, "projectId" = $4,
             "input" = $5, "output" = $6, "groundTruth" = $7, "metadata" = $8, "error" = $9,
             "startedAt" = $10, "completedAt" = $11, "retryCount" = $12, "attempt" = $13,
-            "traceId" = $14, "status" = $15, "tags" = $16, "toolMockReport" = $17
-          WHERE "id" = $1 RETURNING *`, [
+            "traceId" = $14, "status" = $15, "tags" = $16, "toolMockReport" = $17,
+            "startedAtZ" = $18, "completedAtZ" = $19
+          WHERE "id" = $1 RETURNING ${EXPERIMENT_RESULT_COLUMNS}`, [
 					existing.id,
 					input.itemDatasetVersion ?? null,
 					input.organizationId ?? null,
@@ -7865,7 +8022,9 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 					input.traceId ?? null,
 					input.status ?? null,
 					purgeMetadata || input.tags == null ? null : toPgJson(input.tags),
-					purgeMetadata || input.toolMockReport == null ? null : toPgJson(input.toolMockReport)
+					purgeMetadata || input.toolMockReport == null ? null : toPgJson(input.toolMockReport),
+					input.startedAt.toISOString(),
+					input.completedAt.toISOString()
 				]);
 			});
 			return this.transformExperimentResultRow(row);
@@ -7899,7 +8058,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
                "tags" = CASE WHEN $4 THEN NULL WHEN $5 THEN $6::jsonb ELSE "tags" END,
                "comment" = CASE WHEN $4 THEN NULL WHEN $7 THEN $8 ELSE "comment" END
            WHERE "id" = $1${input.experimentId !== void 0 ? " AND \"experimentId\" = $9" : ""}
-           RETURNING *`, [
+           RETURNING ${EXPERIMENT_RESULT_COLUMNS}`, [
 					input.id,
 					input.status !== void 0,
 					input.status ?? null,
@@ -7942,7 +8101,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 			});
 			const { conditions, params } = tenancyWhere(filters, 2);
 			const whereSql = ["\"id\" = $1", ...conditions].join(" AND ");
-			const result = await client.oneOrNone(`SELECT * FROM ${tableName} WHERE ${whereSql}`, [id, ...params]);
+			const result = await client.oneOrNone(`SELECT ${EXPERIMENT_RESULT_COLUMNS} FROM ${tableName} WHERE ${whereSql}`, [id, ...params]);
 			return result ? this.transformExperimentResultRow(result) : null;
 		} catch (error) {
 			throw new MastraError({
@@ -8005,7 +8164,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 			const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
 			const limitValue = perPageInput === false ? total : perPage;
 			return {
-				results: (await this.#db.readClient.manyOrNone(`SELECT * FROM ${tableName} ${whereClause} ORDER BY "${orderBy.field}" ${orderBy.direction}, "id" ASC LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`, [
+				results: (await this.#db.readClient.manyOrNone(`SELECT ${EXPERIMENT_RESULT_COLUMNS} FROM ${tableName} ${whereClause} ORDER BY "${orderBy.field}" ${orderBy.direction}, "id" ASC LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`, [
 					...queryParams,
 					limitValue,
 					offset
@@ -17299,6 +17458,203 @@ function parseUpdateFeedbackReviewStatusArgs(args) {
 		reviewStatus: args.reviewStatus
 	};
 }
+// src/storage/domains/observability/v-next/partitioning.ts
+const DEFAULT_FUTURE_DAYS = 14;
+async function detectTimescale(client) {
+	const row = await client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'timescaledb') AS "exists"`);
+	return Boolean(row?.exists);
+}
+async function detectPartman(client) {
+	const row = await client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_partman') AS "exists"`);
+	return Boolean(row?.exists);
+}
+async function getPartmanVersion(client) {
+	return (await client.oneOrNone(`SELECT extversion FROM pg_extension WHERE extname = 'pg_partman'`))?.extversion ?? null;
+}
+function getPartmanMajor(version) {
+	if (!version) return null;
+	const match = /^(\d+)/.exec(version);
+	return match ? Number(match[1]) : null;
+}
+async function resolveMode(client, options = {}) {
+	if (options.mode && options.mode !== "auto") return options.mode;
+	if (await detectTimescale(client)) return "timescale";
+	if (await detectPartman(client)) return "partman";
+	return "native";
+}
+function dayBounds(d) {
+	const year = d.getUTCFullYear();
+	const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+	const day = String(d.getUTCDate()).padStart(2, "0");
+	const start = `${year}-${month}-${day} 00:00:00+00`;
+	const next = new Date(Date.UTC(year, d.getUTCMonth(), d.getUTCDate() + 1));
+	return {
+		start,
+		end: `${next.getUTCFullYear()}-${String(next.getUTCMonth() + 1).padStart(2, "0")}-${String(next.getUTCDate()).padStart(2, "0")} 00:00:00+00`,
+		suffix: `${year}${month}${day}`
+	};
+}
+function partitionName(table, suffix) {
+	return `${table}_p${suffix}`;
+}
+/**
+* Creates daily partition tables in [today - 1 day, today + futureDays].
+* Idempotent: uses CREATE TABLE IF NOT EXISTS.
+*/
+async function ensureNativePartitions(client, schema, options = {}) {
+	const windowDays = partitionWindow(options);
+	for (const table of ALL_SIGNAL_TABLES) await ensureDayPartitions(client, schema, table, windowDays);
+}
+/** The UTC days init() pre-creates: yesterday (optional) through today + futureDays. */
+function partitionWindow(options = {}, nowMs = Date.now()) {
+	const futureDays = options.futureDays ?? DEFAULT_FUTURE_DAYS;
+	const start = options.includeYesterday ?? true ? -1 : 0;
+	const days = [];
+	for (let i = start; i <= futureDays; i++) days.push(new Date(nowMs + i * 864e5));
+	return days;
+}
+/**
+* Keeps only the days inside the current partition window. The write path
+* creates partitions on demand within that window only, so a row with a
+* client-supplied timestamp far in the past or future cannot make the
+* database grow a table per day it names.
+*/
+function withinPartitionWindow(days, options = {}) {
+	const allowed = new Set(partitionWindow(options).map((d) => dayBounds(d).suffix));
+	return days.filter((d) => allowed.has(dayBounds(d).suffix));
+}
+/**
+* Creates and attaches a partition of `schema.table` for each UTC day in
+* `days` that has none. Each day is a `CREATE TABLE (LIKE parent)` followed by
+* `ATTACH PARTITION`, in one transaction, so a failed attach leaves no
+* detached child behind. When either step fails, the catalog is read again: a
+* day that a concurrent caller attached meanwhile counts as done, and any
+* other failure is rethrown.
+*/
+async function ensureDayPartitions(client, schema, table, days) {
+	const parent = qualifiedTable(schema, table);
+	const attached = await attachedPartitionNames(client, schema, table);
+	for (const d of days) {
+		const { start: partStart, end: partEnd, suffix } = dayBounds(d);
+		const childName = partitionName(table, suffix);
+		if (attached.has(childName)) continue;
+		const child = qualifiedName(schema, childName);
+		try {
+			await client.tx(async (t) => {
+				await t.none(`CREATE TABLE IF NOT EXISTS ${child} (LIKE ${parent} INCLUDING ALL)`);
+				await t.none(`ALTER TABLE ${parent} ATTACH PARTITION ${child}
+           FOR VALUES FROM ('${partStart}') TO ('${partEnd}')`);
+			});
+		} catch (error) {
+			if (!(await attachedPartitionNames(client, schema, table)).has(childName)) throw error;
+		}
+	}
+}
+/** Names of the children attached to `schema.table`, read from the catalog so no search_path can shadow it. */
+async function attachedPartitionNames(client, schema, table) {
+	const rows = await client.manyOrNone(`SELECT c.relname
+     FROM pg_catalog.pg_inherits i
+     JOIN pg_catalog.pg_class c ON c.oid = i.inhrelid
+     WHERE i.inhparent = (
+       SELECT p.oid
+       FROM pg_catalog.pg_class p
+       JOIN pg_catalog.pg_namespace n ON n.oid = p.relnamespace
+       WHERE n.nspname = $1 AND p.relname = $2
+     )`, [schema, table]);
+	return new Set(rows.map((r) => r.relname));
+}
+/**
+* `23514` raised by `ExecFindPartition`: the row's day has no attached
+* partition. The message is matched as a fallback only, because Postgres
+* translates it when `lc_messages` is not English.
+*/
+function isMissingPartitionError(error) {
+	const { code, routine, message = "" } = error ?? {};
+	return code === "23514" && (routine === "ExecFindPartition" || /no partition of relation/i.test(message));
+}
+/**
+* Calls `create_hypertable()` for each signal table.
+*
+* Postgres declarative partitioning and Timescale hypertables are mutually
+* exclusive, so the base DDL must have been generated with TableDDLMode
+* 'timescale' (no `PARTITION BY` clause). `if_not_exists` makes this
+* idempotent across re-inits.
+*/
+async function ensureTimescaleHypertables(client, schema) {
+	for (const table of ALL_SIGNAL_TABLES) {
+		const tableExpr = qualifiedTable(schema, table);
+		const timeColumn = SIGNAL_TIME_COLUMN[table].replace(/'/g, "''");
+		await client.none(`SELECT create_hypertable($1::regclass, '${timeColumn}', chunk_time_interval => INTERVAL '1 day', if_not_exists => true)`, [tableExpr]);
+	}
+}
+/**
+* Registers each signal table with pg_partman as a daily-interval parent and
+* lets partman create the child partitions.
+*
+* Retention is intentionally NOT configured here — it stays opt-in via the
+* future Mastra CLI surface.
+*
+* Prefers the pg_partman 5.x+ declarative API (`p_type := 'range'`) and keeps
+* a 4.x fallback (`p_type := 'native'`) for older installs. That lets the
+* adapter run against current arm64-friendly images without breaking existing
+* 4.x deployments.
+*/
+async function partmanParentRegistered(client, schema, table) {
+	const row = await client.oneOrNone(`SELECT EXISTS (
+       SELECT 1 FROM partman.part_config
+       WHERE parent_table = format('%I.%I', $1::text, $2::text)
+     ) AS "exists"`, [schema, table]);
+	return Boolean(row?.exists);
+}
+async function ensurePartmanHypertables(client, schema) {
+	const partmanMajor = getPartmanMajor(await getPartmanVersion(client));
+	for (const table of ALL_SIGNAL_TABLES) {
+		if (await partmanParentRegistered(client, schema, table)) continue;
+		for (let attempt = 0; attempt < 3; attempt++) try {
+			if (partmanMajor != null && partmanMajor >= 5) await client.none(`SELECT partman.create_parent(
+               p_parent_table := format('%I.%I', $1::text, $2::text),
+               p_control := $3,
+               p_interval := '1 day',
+               p_type := 'range'
+             )`, [
+				schema,
+				table,
+				SIGNAL_TIME_COLUMN[table]
+			]);
+			else await client.none(`SELECT partman.create_parent(
+               p_parent_table := format('%I.%I', $1::text, $2::text),
+               p_control := $3,
+               p_type := 'native',
+               p_interval := '1 day'
+             )`, [
+				schema,
+				table,
+				SIGNAL_TIME_COLUMN[table]
+			]);
+			break;
+		} catch (error) {
+			const message = error?.message ?? "";
+			if (error?.code === "23505" || /already managed by pg_partman/i.test(message) || /relation .* already exists/i.test(message)) break;
+			if (!/deadlock detected/i.test(message)) throw error;
+			if (await partmanParentRegistered(client, schema, table)) break;
+			if (attempt === 2) throw error;
+			await new Promise((resolve) => setTimeout(resolve, 25));
+		}
+	}
+}
+async function setupPartitioning(client, schema, options = {}) {
+	switch (await resolveMode(client, options)) {
+		case "timescale":
+			await ensureTimescaleHypertables(client, schema);
+			return "timescale";
+		case "partman":
+			await ensurePartmanHypertables(client, schema);
+			return "partman";
+		case "native":
+			await ensureNativePartitions(client, schema, options);
+			return "native";
+	}
+}
 // src/storage/domains/observability/v-next/sql.ts
 /**
 * SQL helpers for the v-next Postgres observability domain.
@@ -17379,6 +17735,54 @@ ${onConflict}`,
 		values
 	};
 }
+/**
+* Insert into a signal table. In native partition mode, a row whose day is
+* inside the partition window but has no partition yet gets one created, then
+* the insert runs once more. TimescaleDB and pg_partman own their partitions,
+* so in those modes the original error propagates untouched. The mode is the
+* one the store resolved; a store that never ran init() (`disableInit`)
+* detects it here, after the failed insert, so the hot path stays one query.
+*/
+async function insertRows(client, schema, table, records, partitioning, onConflict) {
+	const insert = buildInsert(schema, table, records, onConflict);
+	if (!insert) return;
+	try {
+		await client.query(insert.text, insert.values);
+	} catch (error) {
+		if (!isMissingPartitionError(error) || await resolveMode(client, partitioning) !== "native") throw error;
+		const days = withinPartitionWindow(recordDays(records, SIGNAL_TIME_COLUMN[table]), partitioning);
+		if (days.length === 0) throw error;
+		for (const day of days) await ensureDayPartitions(client, schema, table, [day]).catch((cause) => {
+			if (!isInsufficientPrivilegeError(cause)) throw cause;
+			throw new Error(partitionCreateFailure({
+				table,
+				day,
+				cause
+			}), { cause });
+		});
+		await client.query(insert.text, insert.values);
+	}
+}
+/** `42501`: the role may not create the child, or does not own the parent it must attach to. */
+function isInsufficientPrivilegeError(error) {
+	return error?.code === "42501";
+}
+function partitionCreateFailure({ table, day, cause }) {
+	const reason = cause instanceof Error ? cause.message : String(cause);
+	return `Could not create the ${table} partition for ${day.toISOString().slice(0, 10)} (UTC): ${reason}. Create the partitions with a role that can create tables in the schema and owns the observability tables, for example by calling ensurePartitions() on a schedule.`;
+}
+function recordDays(records, timeColumn) {
+	const days = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const value = record[timeColumn];
+		if (value == null) continue;
+		const d = new Date(value);
+		if (isNaN(d.getTime())) continue;
+		const day = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+		days.set(day.toISOString(), day);
+	}
+	return [...days.values()];
+}
 /** Primary key of the span table; also the conflict target for span upserts. */
 const SPAN_KEY_COLUMNS = [
 	"traceId",
@@ -18289,16 +18693,14 @@ function pushFeedbackIdentity(acc, feedbackType, feedbackSource) {
 	}
 	acc.conditions.push(`"valueNumber" IS NOT NULL`);
 }
-async function createFeedback(client, schema, args) {
+async function createFeedback(client, schema, args, partitioning) {
 	const row = feedbackRecordToRow(args.feedback);
-	const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, [row], FEEDBACK_UPSERT_CLAUSE);
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_FEEDBACK_EVENTS, [row], partitioning, FEEDBACK_UPSERT_CLAUSE);
 }
-async function batchCreateFeedback(client, schema, args) {
+async function batchCreateFeedback(client, schema, args, partitioning) {
 	if (args.feedbacks.length === 0) return;
 	const rows = [...new Map(args.feedbacks.map((feedback) => [feedback.feedbackId, feedback])).values()].map(feedbackRecordToRow);
-	const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, rows, FEEDBACK_UPSERT_CLAUSE);
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_FEEDBACK_EVENTS, rows, partitioning, FEEDBACK_UPSERT_CLAUSE);
 }
 async function updateFeedbackReviewStatus(client, schema, args) {
 	const { feedbackId, reviewStatus } = parseUpdateFeedbackReviewStatusArgs(args);
@@ -18496,11 +18898,10 @@ function applyLogFilters(acc, filters) {
 	applyCommonFilters(acc, filters);
 	applySingleOrArrayFilter(acc, "level", filters?.level);
 }
-async function batchCreateLogs(client, schema, args) {
+async function batchCreateLogs(client, schema, args, partitioning) {
 	if (args.logs.length === 0) return;
 	const rows = args.logs.map(logRecordToRow);
-	const insert = buildInsert(schema, TABLE_LOG_EVENTS, rows);
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_LOG_EVENTS, rows, partitioning);
 }
 async function listLogs(client, schema, args) {
 	const { mode, filters, pagination, orderBy, after, limit } = listLogsArgsSchema.parse(args);
@@ -18571,11 +18972,10 @@ function pushMetricNameFilter(acc, names) {
 	acc.conditions.push(`"name" IN (${placeholders})`);
 	acc.params.push(...names);
 }
-async function batchCreateMetrics(client, schema, args) {
+async function batchCreateMetrics(client, schema, args, partitioning) {
 	if (args.metrics.length === 0) return;
 	const rows = args.metrics.map(metricRecordToRow);
-	const insert = buildInsert(schema, TABLE_METRIC_EVENTS, rows);
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_METRIC_EVENTS, rows, partitioning);
 }
 async function listMetrics(client, schema, args) {
 	const { mode, filters, pagination, orderBy, after, limit } = listMetricsArgsSchema.parse(args);
@@ -18777,165 +19177,6 @@ async function getMetricPercentiles(client, schema, args) {
   `;
 	return { series: percentileSeriesFromRows(await client.manyOrNone(sql, acc.params), args.percentiles) };
 }
-// src/storage/domains/observability/v-next/partitioning.ts
-const DEFAULT_FUTURE_DAYS = 14;
-async function detectTimescale(client) {
-	const row = await client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'timescaledb') AS "exists"`);
-	return Boolean(row?.exists);
-}
-async function detectPartman(client) {
-	const row = await client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_partman') AS "exists"`);
-	return Boolean(row?.exists);
-}
-async function getPartmanVersion(client) {
-	return (await client.oneOrNone(`SELECT extversion FROM pg_extension WHERE extname = 'pg_partman'`))?.extversion ?? null;
-}
-function getPartmanMajor(version) {
-	if (!version) return null;
-	const match = /^(\d+)/.exec(version);
-	return match ? Number(match[1]) : null;
-}
-async function resolveMode(client, options = {}) {
-	if (options.mode && options.mode !== "auto") return options.mode;
-	if (await detectTimescale(client)) return "timescale";
-	if (await detectPartman(client)) return "partman";
-	return "native";
-}
-function dayBounds(d) {
-	const year = d.getUTCFullYear();
-	const month = String(d.getUTCMonth() + 1).padStart(2, "0");
-	const day = String(d.getUTCDate()).padStart(2, "0");
-	const start = `${year}-${month}-${day} 00:00:00+00`;
-	const next = new Date(Date.UTC(year, d.getUTCMonth(), d.getUTCDate() + 1));
-	return {
-		start,
-		end: `${next.getUTCFullYear()}-${String(next.getUTCMonth() + 1).padStart(2, "0")}-${String(next.getUTCDate()).padStart(2, "0")} 00:00:00+00`,
-		suffix: `${year}${month}${day}`
-	};
-}
-function partitionName(table, suffix) {
-	return `${table}_p${suffix}`;
-}
-/**
-* Creates daily partition tables in [today - 1 day, today + futureDays].
-* Idempotent: uses CREATE TABLE IF NOT EXISTS.
-*/
-async function ensureNativePartitions(client, schema, options = {}) {
-	const futureDays = options.futureDays ?? DEFAULT_FUTURE_DAYS;
-	const start = options.includeYesterday ?? true ? -1 : 0;
-	const baseNowMs = Date.now();
-	for (const table of ALL_SIGNAL_TABLES) for (let i = start; i <= futureDays; i++) {
-		const { start: partStart, end: partEnd, suffix } = dayBounds(new Date(baseNowMs + i * 864e5));
-		const child = qualifiedName(schema, partitionName(table, suffix));
-		const parent = qualifiedTable(schema, table);
-		try {
-			await client.none(`CREATE TABLE IF NOT EXISTS ${child} (LIKE ${parent} INCLUDING ALL)`);
-		} catch (error) {
-			if (!isDuplicateRelationError(error)) throw error;
-		}
-		try {
-			await client.none(`ALTER TABLE ${parent} ATTACH PARTITION ${child}
-           FOR VALUES FROM ('${partStart}') TO ('${partEnd}')`);
-		} catch (error) {
-			if (!isAlreadyAttachedError(error)) throw error;
-		}
-	}
-}
-/**
-* `ALTER TABLE ATTACH PARTITION` fails with `42P17 invalid_object_definition`
-* when the target table is already a partition of *any* parent (including
-* the one we want). On older PG it can also surface as 42710 or a generic
-* message. We err on the side of treating any "already a partition" wording
-* as success so concurrent inits converge cleanly.
-*/
-function isAlreadyAttachedError(error) {
-	const code = error?.code;
-	const message = error?.message ?? "";
-	if (code === "42P17" || code === "42710") return /is already a partition/i.test(message) || /already a partition/i.test(message);
-	return /is already a partition/i.test(message);
-}
-/**
-* Calls `create_hypertable()` for each signal table.
-*
-* Postgres declarative partitioning and Timescale hypertables are mutually
-* exclusive, so the base DDL must have been generated with TableDDLMode
-* 'timescale' (no `PARTITION BY` clause). `if_not_exists` makes this
-* idempotent across re-inits.
-*/
-async function ensureTimescaleHypertables(client, schema) {
-	for (const table of ALL_SIGNAL_TABLES) {
-		const tableExpr = qualifiedTable(schema, table);
-		const timeColumn = SIGNAL_TIME_COLUMN[table].replace(/'/g, "''");
-		await client.none(`SELECT create_hypertable($1::regclass, '${timeColumn}', chunk_time_interval => INTERVAL '1 day', if_not_exists => true)`, [tableExpr]);
-	}
-}
-/**
-* Registers each signal table with pg_partman as a daily-interval parent and
-* lets partman create the child partitions.
-*
-* Retention is intentionally NOT configured here — it stays opt-in via the
-* future Mastra CLI surface.
-*
-* Prefers the pg_partman 5.x+ declarative API (`p_type := 'range'`) and keeps
-* a 4.x fallback (`p_type := 'native'`) for older installs. That lets the
-* adapter run against current arm64-friendly images without breaking existing
-* 4.x deployments.
-*/
-async function ensurePartmanHypertables(client, schema) {
-	const partmanMajor = getPartmanMajor(await getPartmanVersion(client));
-	for (const table of ALL_SIGNAL_TABLES) {
-		if ((await client.oneOrNone(`SELECT EXISTS (
-         SELECT 1 FROM partman.part_config
-         WHERE parent_table = format('%I.%I', $1::text, $2::text)
-       ) AS "exists"`, [schema, table]))?.exists) continue;
-		for (let attempt = 0; attempt < 3; attempt++) try {
-			if (partmanMajor != null && partmanMajor >= 5) await client.none(`SELECT partman.create_parent(
-               p_parent_table := format('%I.%I', $1::text, $2::text),
-               p_control := $3,
-               p_interval := '1 day',
-               p_type := 'range'
-             )`, [
-				schema,
-				table,
-				SIGNAL_TIME_COLUMN[table]
-			]);
-			else await client.none(`SELECT partman.create_parent(
-               p_parent_table := format('%I.%I', $1::text, $2::text),
-               p_control := $3,
-               p_type := 'native',
-               p_interval := '1 day'
-             )`, [
-				schema,
-				table,
-				SIGNAL_TIME_COLUMN[table]
-			]);
-			break;
-		} catch (error) {
-			const message = error?.message ?? "";
-			if (error?.code === "23505" || /already managed by pg_partman/i.test(message) || /relation .* already exists/i.test(message)) break;
-			if (!/deadlock detected/i.test(message)) throw error;
-			if ((await client.oneOrNone(`SELECT EXISTS (
-             SELECT 1 FROM partman.part_config
-             WHERE parent_table = format('%I.%I', $1::text, $2::text)
-           ) AS "exists"`, [schema, table]))?.exists) break;
-			if (attempt === 2) throw error;
-			await new Promise((resolve) => setTimeout(resolve, 25));
-		}
-	}
-}
-async function setupPartitioning(client, schema, options = {}) {
-	switch (await resolveMode(client, options)) {
-		case "timescale":
-			await ensureTimescaleHypertables(client, schema);
-			return "timescale";
-		case "partman":
-			await ensurePartmanHypertables(client, schema);
-			return "partman";
-		case "native":
-			await ensureNativePartitions(client, schema, options);
-			return "native";
-	}
-}
 // src/storage/domains/observability/v-next/retention.ts
 /**
 * Age-based retention for the v-next Postgres observability domain.
@@ -19101,16 +19342,14 @@ function collapseExactScoreConflicts(rows) {
 	}
 	return [...records.values()];
 }
-async function createScore(client, schema, args) {
+async function createScore(client, schema, args, partitioning) {
 	const row = scoreRecordToRow(args.score);
-	const insert = buildInsert(schema, TABLE_SCORE_EVENTS, [row], scoreRewriteConflict(row));
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_SCORE_EVENTS, [row], partitioning, scoreRewriteConflict(row));
 }
-async function batchCreateScores(client, schema, args) {
+async function batchCreateScores(client, schema, args, partitioning) {
 	if (args.scores.length === 0) return;
 	const rows = collapseExactScoreConflicts(args.scores.map(scoreRecordToRow));
-	const insert = buildInsert(schema, TABLE_SCORE_EVENTS, rows, scoreRewriteConflict(rows[0]));
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_SCORE_EVENTS, rows, partitioning, scoreRewriteConflict(rows[0]));
 }
 /**
 * Delete score events by scoreId. Optional `organizationId` and `resourceId`
@@ -19341,7 +19580,22 @@ const TRACE_STATUS_SQL = `CASE WHEN r."error" IS NOT NULL THEN 'error' ELSE 'suc
 const timeToFirstChunkSupported = "timeToFirstChunkMs" in coreStorage.TRACE_QUERY_FIELD_REGISTRY.trace;
 /** Core before the sort rejects `orderBy` on the field, so the sort is only declared when core plans it. */
 const timeToFirstChunkSortSupported = coreStorage.TRACE_QUERY_ORDER_FIELDS?.includes("timeToFirstChunkMs") === true;
-const timeToFirstChunkFeatures = [...timeToFirstChunkSupported ? ["trace-query-time-to-first-chunk"] : [], ...timeToFirstChunkSortSupported ? ["trace-query-time-to-first-chunk-sort"] : []];
+/** Same rule for time to first token: returned and sorted only when core knows the field. */
+const timeToFirstTokenSupported = "timeToFirstTokenMs" in coreStorage.TRACE_QUERY_FIELD_REGISTRY.trace;
+const timeToFirstTokenSortSupported = coreStorage.TRACE_QUERY_ORDER_FIELDS?.includes("timeToFirstTokenMs") === true;
+/**
+* Outcome fields follow the same rule: core before them rejects their predicates and strict rows,
+* so they are only returned and declared when core knows them.
+*/
+const spanQueryOutcomeFieldsSupported = "outcome" in (coreStorage.SPAN_QUERY_FIELD_REGISTRY ?? {});
+const traceQueryOutcomeFieldsSupported = "outcome" in (coreStorage.TRACE_QUERY_FIELD_REGISTRY?.trace ?? {});
+const outcomeFeatures = [...spanQueryOutcomeFieldsSupported ? ["span-query-outcome-fields"] : [], ...traceQueryOutcomeFieldsSupported ? ["trace-query-outcome-fields"] : []];
+const timingFeatures = [
+	...timeToFirstChunkSupported ? ["trace-query-time-to-first-chunk"] : [],
+	...timeToFirstChunkSortSupported ? ["trace-query-time-to-first-chunk-sort"] : [],
+	...timeToFirstTokenSupported ? ["trace-query-time-to-first-token"] : [],
+	...timeToFirstTokenSortSupported ? ["trace-query-time-to-first-token-sort"] : []
+];
 /**
 * Keyset bounds for a cursor's sort value: terms for rows strictly past it in `direction`, and the
 * condition for rows level with it. Empty values sort last in both directions, so they are past
@@ -19374,6 +19628,7 @@ const TRACE_FIELDS = {
 	endedAt: "r.\"endedAt\"",
 	durationMs: durationMsSql("r.\"startedAt\"", "r.\"endedAt\""),
 	timeToFirstChunkMs: "r.\"timeToFirstChunkMs\"",
+	timeToFirstTokenMs: "r.\"timeToFirstTokenMs\"",
 	entityId: "r.\"entityId\"",
 	entityName: "r.\"entityName\"",
 	entityType: "r.\"entityType\"",
@@ -19381,6 +19636,8 @@ const TRACE_FIELDS = {
 	spanType: "r.\"spanType\"",
 	environment: "r.\"environment\"",
 	status: TRACE_STATUS_SQL,
+	outcome: "r.\"outcome\"",
+	stopReason: "r.\"stopReason\"",
 	tags: "r.\"tags\""
 };
 const SPAN_FIELDS = {
@@ -19392,7 +19649,10 @@ const SPAN_FIELDS = {
 	endedAt: "s.\"endedAt\"",
 	durationMs: "s.\"durationMs\"",
 	timeToFirstChunkMs: "s.\"timeToFirstChunkMs\"",
+	timeToFirstTokenMs: "s.\"timeToFirstTokenMs\"",
 	status: "s.\"status\"",
+	outcome: "s.\"outcome\"",
+	stopReason: "s.\"stopReason\"",
 	error: "s.\"error\"",
 	entityType: "s.\"entityType\"",
 	entityId: "s.\"entityId\"",
@@ -19462,10 +19722,14 @@ const TRACE_SELECT = `
   r."startedAt" AS "startedAt",
   r."endedAt" AS "endedAt",
   r."timeToFirstChunkMs" AS "timeToFirstChunkMs",
+  r."timeToFirstTokenMs" AS "timeToFirstTokenMs",
   r."entityName" AS "entityName",
   r."entityType" AS "entityType",
   r."environment" AS "environment",
-  ${TRACE_STATUS_SQL} AS "status"`;
+  ${TRACE_STATUS_SQL} AS "status",
+  r."outcome" AS "outcome",
+  r."stopReason" AS "stopReason",
+  r."stopReasonContext" AS "stopReasonContext"`;
 function fieldSql(registry, field) {
 	const sql = registry[field];
 	if (sql === void 0) throw new Error(`Unsupported trusted trace-query field: ${field}`);
@@ -19822,8 +20086,8 @@ function compilePostgresTraceScope(schema, selection, relationCollections, scope
       s."traceId",
       s."name",
       s."spanType",
-      CASE WHEN jsonb_typeof(s."attributes" -> 'model') = 'string' THEN s."attributes" ->> 'model' END AS "model",
-      CASE WHEN jsonb_typeof(s."attributes" -> 'provider') = 'string' THEN s."attributes" ->> 'provider' END AS "provider",
+      COALESCE(s."model", CASE WHEN jsonb_typeof(s."attributes" -> 'model') = 'string' THEN s."attributes" ->> 'model' END) AS "model",
+      COALESCE(s."provider", CASE WHEN jsonb_typeof(s."attributes" -> 'provider') = 'string' THEN s."attributes" ->> 'provider' END) AS "provider",
       s."startedAt",
       CASE WHEN s."isPending" THEN NULL ELSE s."endedAt" END AS "endedAt",
       CASE
@@ -19831,7 +20095,10 @@ function compilePostgresTraceScope(schema, selection, relationCollections, scope
         ELSE ${durationMsSql("s.\"startedAt\"", "s.\"endedAt\"")}
       END AS "durationMs",
       s."timeToFirstChunkMs",
+      s."timeToFirstTokenMs",
       CASE WHEN s."error" IS NOT NULL THEN 'error' ELSE 'success' END AS "status",
+      s."outcome",
+      s."stopReason",
       s."error",
       s."entityType",
       s."entityId",
@@ -20205,10 +20472,16 @@ function traceRowToResult(row) {
 		startedAt: asIsoTimestamp$1(row.startedAt),
 		endedAt: asIsoTimestamp$1(row.endedAt),
 		...timeToFirstChunkSupported && { timeToFirstChunkMs: row.timeToFirstChunkMs == null ? null : Number(row.timeToFirstChunkMs) },
+		...timeToFirstTokenSupported && { timeToFirstTokenMs: row.timeToFirstTokenMs == null ? null : Number(row.timeToFirstTokenMs) },
 		entityName: row.entityName == null ? null : String(row.entityName),
 		entityType: row.entityType == null ? null : String(row.entityType),
 		environment: row.environment == null ? null : String(row.environment),
-		status: row.status
+		status: row.status,
+		...traceQueryOutcomeFieldsSupported && {
+			outcome: row.outcome == null ? null : String(row.outcome),
+			stopReason: row.stopReason == null ? null : String(row.stopReason),
+			stopReasonContext: row.stopReasonContext ?? null
+		}
 	};
 }
 async function queryTraces(client, schema, plan, timeoutMs) {
@@ -20360,7 +20633,10 @@ const fields = [
 	"experimentId",
 	"environment",
 	"executionSource",
-	"timeToFirstChunkMs"
+	"timeToFirstChunkMs",
+	"timeToFirstTokenMs",
+	"outcome",
+	"stopReason"
 ];
 const identities = identityFields.map((field) => `"${field}"`).join(", ");
 const identityOrder = identityFields.map((field) => `"${field}" COLLATE "C" ASC NULLS LAST`).join(", ");
@@ -20410,8 +20686,6 @@ function compilePostgresSpanSelection(schema, plan) {
 	};
 	values.push(...predicate.values);
 	const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
-	const legacyModelFields = coreStorage.SPAN_QUERY_FIELD_REGISTRY ? "" : `CASE WHEN jsonb_typeof(attributes -> 'model') = 'string' THEN attributes ->> 'model' END AS model,
-       CASE WHEN jsonb_typeof(attributes -> 'provider') = 'string' THEN attributes ->> 'provider' END AS provider,`;
 	return {
 		ctes: [
 			`candidate_ids AS MATERIALIZED (
@@ -20422,7 +20696,7 @@ function compilePostgresSpanSelection(schema, plan) {
 			`current_spans AS MATERIALIZED (
     SELECT DISTINCT ON (${identities})
       ${fields.map((field) => `"${field}"`).join(", ")}, "startedAt", "endedAt", "cursorId"::text AS version,
-      ${legacyModelFields}
+      "model", "provider",
       (EXTRACT(EPOCH FROM ("endedAt" - "startedAt")) * 1000)::float8 AS "durationMs",
       CASE WHEN error IS NULL THEN 'success' ELSE 'error' END AS status,
       error IS NOT NULL AS "hasError"
@@ -20492,9 +20766,14 @@ async function querySpans(client, schema, plan, timeoutMs) {
 	return runWithPostgresTraceQueryTimeout(client, timeoutMs, async (tx) => {
 		const query = compilePostgresSpanQuery(schema, plan);
 		const rows = await tx.any(query.text, query.values);
-		const selected = rows.map(({ version: _version, startedAt, endedAt, timeToFirstChunkMs, ...row }) => ({
+		const selected = rows.map(({ version: _version, startedAt, endedAt, timeToFirstChunkMs, timeToFirstTokenMs, outcome, stopReason, ...row }) => ({
 			...row,
 			...timeToFirstChunkSupported && { timeToFirstChunkMs },
+			...timeToFirstTokenSupported && { timeToFirstTokenMs },
+			...spanQueryOutcomeFieldsSupported && {
+				outcome,
+				stopReason
+			},
 			startedAt: startedAt.toISOString(),
 			endedAt: endedAt.toISOString()
 		}));
@@ -20512,18 +20791,22 @@ async function querySpans(client, schema, plan, timeoutMs) {
 			payloadValues.push(row.version);
 			return `(${key} AND "cursorId" = $${payloadValues.length}::bigint)`;
 		}).join(" OR ");
-		const payloadRows = await tx.any(`SELECT ${identities},
-      CASE WHEN jsonb_typeof(attributes -> 'model') = 'string' THEN attributes ->> 'model' END AS model,
-      CASE WHEN jsonb_typeof(attributes -> 'provider') = 'string' THEN attributes ->> 'provider' END AS provider,
+		const payloadRows = await tx.any(`SELECT ${identities}, "stopReasonContext",
+      COALESCE("model", CASE WHEN jsonb_typeof(attributes -> 'model') = 'string' THEN attributes ->> 'model' END) AS model,
+      COALESCE("provider", CASE WHEN jsonb_typeof(attributes -> 'provider') = 'string' THEN attributes ->> 'provider' END) AS provider,
       ${PREVIEW_PAYLOADS$1.map(([preview, payload]) => `"${preview}", CASE WHEN ${missingPreviewSql(`"${preview}"`)} THEN "${payload}" END AS "${payload}"`).join(",\n      ")}
       FROM ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} WHERE ${payloadWhere}`, payloadValues);
 		const payloads = payloadRows.map(toSpanQueryPayload);
 		const metadata = new Map(payloadRows.map((row) => [coreStorage.spanQueryIdentityKey(row), row]));
-		const hydrated = selected.map((row) => ({
-			...row,
-			model: metadata.get(coreStorage.spanQueryIdentityKey(row))?.model ?? null,
-			provider: metadata.get(coreStorage.spanQueryIdentityKey(row))?.provider ?? null
-		}));
+		const hydrated = selected.map((row) => {
+			const stored = metadata.get(coreStorage.spanQueryIdentityKey(row));
+			return {
+				...row,
+				model: stored?.model ?? null,
+				provider: stored?.provider ?? null,
+				...spanQueryOutcomeFieldsSupported && { stopReasonContext: stored?.stopReasonContext ?? null }
+			};
+		});
 		let metrics = [];
 		if (!coreStorage.SPAN_QUERY_FIELD_REGISTRY) {
 			await remaining();
@@ -20626,7 +20909,11 @@ function compilePostgresThreadRowsQuery(schema, plan, strategy = "full") {
 	}
 	const qualify = plan.timeRange.mode === "traces" ? "s.\"inWindow\"" : `s."${plan.timeRange.field}" >= $1 AND s."${plan.timeRange.field}" < $2`;
 	const filtered = predicateFields(plan.where);
-	const firstContext = [...contextFields, "timeToFirstChunkMs"].filter((field) => field === "resourceId" || filtered.has(field));
+	const firstContext = [
+		...contextFields,
+		"timeToFirstChunkMs",
+		"timeToFirstTokenMs"
+	].filter((field) => field === "resourceId" || filtered.has(field));
 	const lastFields = [
 		"traceId",
 		"spanId",
@@ -20640,7 +20927,7 @@ function compilePostgresThreadRowsQuery(schema, plan, strategy = "full") {
 		text: `WITH ${scopedRoots}, ${strategy === "candidates" ? `${candidates}, ` : ""}current_roots AS (
     SELECT DISTINCT ON ("organizationId", "traceId")
       "organizationId", "threadId", "traceId", "spanId", "cursorId", "startedAt", "endedAt", "isPending",
-      ${firstContext.map((field) => field === "timeToFirstChunkMs" ? `CASE WHEN "spanType" = 'agent_run' THEN "timeToFirstChunkMs" END AS "timeToFirstChunkMs"` : `"${field}"`).join(", ")}
+      ${firstContext.map((field) => field === "timeToFirstChunkMs" || field === "timeToFirstTokenMs" ? `CASE WHEN "spanType" = 'agent_run' THEN "${field}" END AS "${field}"` : `"${field}"`).join(", ")}
       ${filtered.has("status") ? ", CASE WHEN error IS NULL THEN 'success' ELSE 'error' END AS status" : ""}
     FROM scoped_roots ${strategy === "candidates" ? `WHERE (${identity("traceId")}) IN (SELECT ${identity("traceId")} FROM candidate_traces)` : ""}
     ORDER BY "organizationId", "traceId", "startedAt" ASC, "spanId" COLLATE "C", "cursorId" DESC
@@ -20706,6 +20993,7 @@ async function queryThreadRows(client, schema, plan, timeoutMs, strategy = "auto
 	}));
 	const payloads = await run(`SELECT "organizationId", "traceId", "cursorId", ${contextFields.map((field) => `"${field}"`).join(", ")},
     CASE WHEN "spanType" = 'agent_run' THEN "timeToFirstChunkMs" END AS "timeToFirstChunkMs",
+    CASE WHEN "spanType" = 'agent_run' THEN "timeToFirstTokenMs" END AS "timeToFirstTokenMs",
     CASE WHEN error IS NULL THEN 'success' ELSE 'error' END AS status,
     ${[
 		"input",
@@ -20734,6 +21022,7 @@ async function queryThreadRows(client, schema, plan, timeoutMs, strategy = "auto
 			endedAt: row.endedAt.toISOString(),
 			traceCount: Number(row.traceCount),
 			timeToFirstChunkMs: first.timeToFirstChunkMs,
+			...timeToFirstTokenSupported && { timeToFirstTokenMs: first.timeToFirstTokenMs },
 			inputPreview: readPreview(first.inputPreview, first.input),
 			outputPreview: readPreview(last.outputPreview, last.output),
 			errorPreview: readPreview(last.errorPreview, last.error)
@@ -20759,6 +21048,8 @@ const DIMENSION_SQL = {
 	entityId: "r.\"entityId\"",
 	environment: "r.\"environment\"",
 	status: TRACE_STATUS_SQL,
+	outcome: "r.\"outcome\"",
+	stopReason: "r.\"stopReason\"",
 	serviceName: "r.\"serviceName\"",
 	executionSource: "r.\"executionSource\"",
 	threadId: "r.\"threadId\"",
@@ -20781,6 +21072,8 @@ const SPAN_DIMENSION_SQL = Object.fromEntries([
 	"rootEntityName",
 	"environment",
 	"status",
+	"outcome",
+	"stopReason",
 	"serviceName",
 	"executionSource",
 	"threadId",
@@ -20788,7 +21081,9 @@ const SPAN_DIMENSION_SQL = Object.fromEntries([
 	"userId",
 	"sessionId",
 	"organizationId",
-	"experimentId"
+	"experimentId",
+	"model",
+	"provider"
 ].map((field) => [field, `r."${field}"`]));
 const PERCENTILES = {
 	"duration.p50": .5,
@@ -21690,10 +21985,9 @@ async function readBranchesStreamHeadCursor(client, span, filters) {
 	return encodeDeltaCursor(await readSafeXactHorizon(client), 0);
 }
 // src/storage/domains/observability/v-next/tracing.ts
-async function writeSpanRows(client, schema, rows) {
+async function writeSpanRows(client, schema, rows, partitioning) {
 	const deduped = dedupeSpanRows(rows);
-	const insert = buildInsert(schema, TABLE_SPAN_EVENTS, deduped, spanConflictClause(Object.keys(deduped[0] ?? {})));
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_SPAN_EVENTS, deduped, partitioning, spanConflictClause(Object.keys(deduped[0] ?? {})));
 }
 /**
 * Collapse rows that share a primary key within a single batch. Postgres
@@ -21713,12 +22007,12 @@ function dedupeSpanRows(rows) {
 	}
 	return [...byKey.values()];
 }
-async function createSpan(client, schema, args) {
-	await writeSpanRows(client, schema, [spanRecordToRow(args.span)]);
+async function createSpan(client, schema, args, partitioning) {
+	await writeSpanRows(client, schema, [spanRecordToRow(args.span)], partitioning);
 }
-async function batchCreateSpans(client, schema, args) {
+async function batchCreateSpans(client, schema, args, partitioning) {
 	if (args.records.length === 0) return;
-	await writeSpanRows(client, schema, args.records.map(spanRecordToRow));
+	await writeSpanRows(client, schema, args.records.map(spanRecordToRow), partitioning);
 }
 async function getSpans(client, schema, args) {
 	if (args.spanIds.length === 0) return {
@@ -21842,8 +22136,12 @@ async function dangerouslyClearTracing(client, schema) {
 * application database — observability writes will degrade app performance.
 * Use it through `MastraCompositeStore` with a dedicated Postgres connection.
 */
-const spanQueryFeatures = typeof coreStorage.planSpanQuery === "function" ? ["span-query", "span-query-context-fields"] : [];
-const spanAggregateFeatures = typeof coreStorage.planSpanAggregate === "function" ? ["span-aggregate"] : [];
+const spanQueryFeatures = typeof coreStorage.planSpanQuery === "function" ? [
+	"span-query",
+	"span-query-context-fields",
+	..."model" in (coreStorage.SPAN_QUERY_FIELD_REGISTRY ?? {}) ? ["span-query-model-fields"] : []
+] : [];
+const spanAggregateFeatures = typeof coreStorage.planSpanAggregate === "function" ? ["span-aggregate", ..."model" in (coreStorage.SPAN_AGGREGATE_DIMENSION_REGISTRY ?? {}) ? ["span-aggregate-model-dimensions"] : []] : [];
 function wrapError(op, error, details) {
 	if (error instanceof MastraError || error instanceof coreStorage.TraceQueryCursorError || error instanceof coreStorage.TraceQueryExecutionError || error instanceof coreStorage.TraceQueryResourceLimitError) throw error;
 	throw new MastraError({
@@ -21939,6 +22237,18 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 		return this.#partitionMode;
 	}
 	/**
+	* Create any missing day partitions from yesterday through today +
+	* `futureDays`, without the rest of init(). For apps whose runtime role
+	* cannot run DDL: call it on a schedule with a role that owns the
+	* observability tables. Safe to call repeatedly on one instance. Does
+	* nothing with TimescaleDB or pg_partman, which create their own partitions.
+	*/
+	async ensurePartitions() {
+		return this.#run("VNEXT_ENSURE_PARTITIONS", async () => {
+			if ((this.#partitionMode ??= await resolveMode(this.#client, this.#partitioning)) === "native") await ensureNativePartitions(this.#client, this.#schema, this.#partitioning);
+		});
+	}
+	/**
 	* All five signal tables are insert-only growth tables. The anchor column is
 	* each table's partition / chunk key, so age-based expiry drops whole day
 	* partitions instead of deleting rows (see `./retention.ts`). `indexed: true`
@@ -22042,7 +22352,8 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 			"trace-query-tenant-scope",
 			"feedback",
 			"trace-query-context-ids",
-			...timeToFirstChunkFeatures,
+			...timingFeatures,
+			...outcomeFeatures,
 			"trace-query-root-span-fields",
 			"trace-query-root-entity-id"
 		];
@@ -22067,11 +22378,24 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 			"trace-query-tenant-scope",
 			"feedback",
 			"trace-query-context-ids",
-			...timeToFirstChunkFeatures,
+			...timingFeatures,
+			...outcomeFeatures,
 			"trace-query-root-span-fields",
 			"trace-query-root-entity-id"
 		];
 	}
+	/**
+	* Partitioning options for the write path, with `mode` fixed to the mode
+	* this store resolved (in init(), or lazily in prune()) so the write path
+	* does not detect it again. Until then the configured mode stands in and
+	* the write path resolves it itself when a partition is missing.
+	*/
+	#writePartitioning() {
+		return {
+			...this.#partitioning,
+			mode: this.#partitionMode ?? this.#partitioning.mode
+		};
+	}
 	async #run(op, fn, details) {
 		try {
 			return await fn();
@@ -22080,13 +22404,13 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 		}
 	}
 	async createSpan(args) {
-		await this.#run("CREATE_SPAN", () => createSpan(this.#client, this.#schema, args), {
+		await this.#run("CREATE_SPAN", () => createSpan(this.#client, this.#schema, args, this.#writePartitioning()), {
 			traceId: args.span.traceId,
 			spanId: args.span.spanId
 		});
 	}
 	async batchCreateSpans(args) {
-		await this.#run("BATCH_CREATE_SPANS", () => batchCreateSpans(this.#client, this.#schema, args), { count: args.records.length });
+		await this.#run("BATCH_CREATE_SPANS", () => batchCreateSpans(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.records.length });
 	}
 	async getSpan(args) {
 		return this.#run("GET_SPAN", () => getSpan(this.#readClient, this.#schema, args), {
@@ -22140,22 +22464,22 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 		return this.#run("LIST_BRANCHES", () => listBranches(this.#readClient, this.#schema, args));
 	}
 	async batchCreateLogs(args) {
-		await this.#run("BATCH_CREATE_LOGS", () => batchCreateLogs(this.#client, this.#schema, args), { count: args.logs.length });
+		await this.#run("BATCH_CREATE_LOGS", () => batchCreateLogs(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.logs.length });
 	}
 	async batchCreateMetrics(args) {
-		await this.#run("BATCH_CREATE_METRICS", () => batchCreateMetrics(this.#client, this.#schema, args), { count: args.metrics.length });
+		await this.#run("BATCH_CREATE_METRICS", () => batchCreateMetrics(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.metrics.length });
 	}
 	async createScore(args) {
-		await this.#run("CREATE_SCORE", () => createScore(this.#client, this.#schema, args));
+		await this.#run("CREATE_SCORE", () => createScore(this.#client, this.#schema, args, this.#writePartitioning()));
 	}
 	async batchCreateScores(args) {
-		await this.#run("BATCH_CREATE_SCORES", () => batchCreateScores(this.#client, this.#schema, args), { count: args.scores.length });
+		await this.#run("BATCH_CREATE_SCORES", () => batchCreateScores(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.scores.length });
 	}
 	async createFeedback(args) {
-		await this.#run("CREATE_FEEDBACK", () => createFeedback(this.#client, this.#schema, args));
+		await this.#run("CREATE_FEEDBACK", () => createFeedback(this.#client, this.#schema, args, this.#writePartitioning()));
 	}
 	async batchCreateFeedback(args) {
-		await this.#run("BATCH_CREATE_FEEDBACK", () => batchCreateFeedback(this.#client, this.#schema, args), { count: args.feedbacks.length });
+		await this.#run("BATCH_CREATE_FEEDBACK", () => batchCreateFeedback(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.feedbacks.length });
 	}
 	async deleteScores(args) {
 		await this.#run("DELETE_SCORES", () => deleteScores(this.#client, this.#schema, args), { count: args.scoreIds.length });
@@ -27565,12 +27889,20 @@ var PostgresStore = class extends MastraCompositeStore {
 	}
 	async #runPinnedInit() {
 		let pinnedClient;
+		let pinned;
 		try {
 			pinnedClient = await this.#writePool.connect();
-			const pinned = new PinnedClientAdapter(this.#writePool, pinnedClient);
+			pinned = new PinnedClientAdapter(this.#writePool, pinnedClient);
 			this.#db.pin(pinned);
-			this.#db.setSchemaSnapshot(await loadSchemaSnapshot(pinned, this.schema));
-			await Promise.all(Object.entries(this.stores).filter(([name, store]) => name !== "knowledge" && store).map(([, store]) => store.init()));
+			for (let attempt = 1; attempt <= 3; attempt++) {
+				this.#db.setSchemaSnapshot(await loadSchemaSnapshot(pinned, this.schema));
+				const failures = (await Promise.allSettled(Object.entries(this.stores).filter(([name, store]) => name !== "knowledge" && store).map(([, store]) => Promise.resolve().then(() => store.init())))).filter((result) => result.status === "rejected");
+				if (failures.length === 0) break;
+				const terminal = failures.find((result) => !isRetryableDeadlock(result.reason));
+				if (terminal || attempt === 3) throw (terminal ?? failures[0]).reason;
+				this.#db.setSchemaSnapshot(null);
+				await backoffAfterDeadlock(attempt);
+			}
 			this.isInitialized = true;
 		} catch (error) {
 			this.#initPromise = null;
@@ -27581,6 +27913,7 @@ var PostgresStore = class extends MastraCompositeStore {
 				category: ErrorCategory.THIRD_PARTY
 			}, error);
 		} finally {
+			await pinned?.drain();
 			this.#db.setSchemaSnapshot(null);
 			if (pinnedClient) {
 				this.#db.unpin();
@@ -27735,6 +28068,10 @@ var PostgresStoreVNext = class extends PostgresStore {
 			owned: true
 		};
 	}
+	/** See {@link ObservabilityStoragePostgresVNext.ensurePartitions}. */
+	async ensurePartitions() {
+		await this.stores.observability.ensurePartitions();
+	}
 	/**
 	* Closes both the primary pool (when owned) and the observability pool
 	* (when this store created it). Safe to call multiple times.