@mastra/clickhouse 1.23.0-alpha.1 → 1.23.0-alpha.2

package/dist/index.cjs

@@ -279,6 +279,35 @@ const TABLE_ENGINES = {
 	[_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY]: `ReplacingMergeTree()`,
 	[_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX]: `ReplacingMergeTree()`
 };
+/**
+* Bloom-filter skip indexes for lookups on columns outside the sort key.
+*
+* These tables are keyed `(createdAt, id)` (or `(createdAt, run_id, ...)` for
+* workflow snapshots), so every lookup by id, thread, resource or run would
+* otherwise scan every granule. Added idempotently at init; existing parts are
+* covered as merges and retention rewrite them (or via `MATERIALIZE INDEX`).
+*/
+const TABLE_SKIP_INDEXES = {
+	[_mastra_core_storage.TABLE_MESSAGES]: [
+		"id",
+		"thread_id",
+		"resourceId"
+	],
+	[_mastra_core_storage.TABLE_THREADS]: ["id", "resourceId"],
+	[_mastra_core_storage.TABLE_RESOURCES]: ["id"],
+	[_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT]: ["run_id"],
+	[_mastra_core_storage.TABLE_SCORERS]: [
+		"id",
+		"runId",
+		"scorerId",
+		"entityId",
+		"traceId"
+	]
+};
+/** Name of the skip index {@link TABLE_SKIP_INDEXES} declares for `column`. */
+function skipIndexName(column) {
+	return `idx_${column}`;
+}
 const COLUMN_TYPES = {
 	text: "String",
 	timestamp: "DateTime64(3)",
@@ -391,10 +420,39 @@ var ClickhouseDB = class extends _mastra_core_base.MastraBase {
 		return filtered;
 	}
 	async hasColumn(table, column) {
-		return (await (await this.client.query({
-			query: `DESCRIBE TABLE ${table}`,
-			format: "JSONEachRow"
-		})).json()).some((c) => c.name === column);
+		return (await this.getTableColumns(table)).has(column);
+	}
+	/**
+	* Adds the bloom-filter skip indexes declared in {@link TABLE_SKIP_INDEXES}
+	* for `tableName`. Call after createTable/alterTable so optional columns
+	* exist. Indexes (or columns) already present are skipped: on Replicated
+	* tables every issued ALTER bumps the metadata version even with
+	* `IF NOT EXISTS`.
+	*/
+	async ensureSkipIndexes(tableName) {
+		const columns = TABLE_SKIP_INDEXES[tableName];
+		if (!columns?.length) return;
+		try {
+			const existingColumns = await this.getTableColumns(tableName);
+			const result = await this.client.query({
+				query: `SELECT name FROM system.data_skipping_indices WHERE database = currentDatabase() AND table = {table:String}`,
+				query_params: { table: tableName },
+				format: "JSONEachRow"
+			});
+			const existingIndexes = new Set((await result.json()).map((row) => row.name));
+			for (const column of columns) {
+				const name = skipIndexName(column);
+				if (existingIndexes.has(name) || !existingColumns.has(column)) continue;
+				await this.client.command({ query: addOnClusterToDDL(`ALTER TABLE ${tableName} ADD INDEX IF NOT EXISTS ${name} "${column}" TYPE bloom_filter(0.01) GRANULARITY 1`, this.replication) });
+			}
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLICKHOUSE", "ENSURE_SKIP_INDEXES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
 	}
 	/**
 	* Checks if a table exists in the database.
@@ -787,7 +845,8 @@ var ClickhouseDB = class extends _mastra_core_base.MastraBase {
 					date_time_input_format: "best_effort",
 					date_time_output_format: "iso",
 					use_client_time_zone: 1,
-					output_format_json_quote_64bit_integers: 0
+					output_format_json_quote_64bit_integers: 0,
+					...tableName === _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT ? { use_skip_indexes_if_final: 1 } : {}
 				}
 			});
 			if (!result) return null;
@@ -884,6 +943,9 @@ var MemoryStorageClickhouse = class extends _mastra_core_storage.MemoryStorage {
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_MESSAGES],
 			ifNotExists: ["resourceId"]
 		});
+		await this.#db.ensureSkipIndexes(_mastra_core_storage.TABLE_THREADS);
+		await this.#db.ensureSkipIndexes(_mastra_core_storage.TABLE_MESSAGES);
+		await this.#db.ensureSkipIndexes(_mastra_core_storage.TABLE_RESOURCES);
 	}
 	async dangerouslyClearAll() {
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_MESSAGES });
@@ -1226,16 +1288,9 @@ var MemoryStorageClickhouse = class extends _mastra_core_storage.MemoryStorage {
 		for (const message of messages) {
 			if (!message.resourceId) throw new Error("Resource ID is required");
 			if (!message.threadId) throw new Error("Thread ID is required");
-			if (!await this.getThreadById({ threadId: message.threadId })) throw new Error(`Thread ${message.threadId} not found`);
-		}
-		const threadIdSet = /* @__PURE__ */ new Map();
-		await Promise.all(messages.map(async (m) => {
-			if (!m.resourceId) throw new Error("Resource ID is required");
-			if (!m.threadId) throw new Error("Thread ID is required");
-			const thread = await this.getThreadById({ threadId: m.threadId });
-			if (!thread) throw new Error(`Thread ${m.threadId} not found`);
-			threadIdSet.set(m.threadId, thread);
-		}));
+		}
+		const threadIdSet = await this.getLatestThreads([...new Set(messages.map((m) => m.threadId))]);
+		for (const message of messages) if (!threadIdSet.has(message.threadId)) throw new Error(`Thread ${message.threadId} not found`);
 		try {
 			const existingRows = await (await this.client.query({
 				query: `SELECT id, thread_id FROM ${_mastra_core_storage.TABLE_MESSAGES} WHERE id IN ({ids:Array(String)})`,
@@ -1338,6 +1393,38 @@ var MemoryStorageClickhouse = class extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
+	/** Newest version of each requested thread, keyed by id. Missing threads are absent. */
+	async getLatestThreads(threadIds) {
+		const rows = await (await this.client.query({
+			query: `SELECT
+          id,
+          "resourceId",
+          title,
+          metadata,
+          toDateTime64(createdAt, 3) as createdAt,
+          toDateTime64(updatedAt, 3) as updatedAt
+        FROM "${_mastra_core_storage.TABLE_THREADS}"
+        WHERE id IN {threadIds:Array(String)}
+        ORDER BY updatedAt DESC
+        LIMIT 1 BY id`,
+			query_params: { threadIds },
+			clickhouse_settings: {
+				date_time_input_format: "best_effort",
+				date_time_output_format: "iso",
+				use_client_time_zone: 1,
+				output_format_json_quote_64bit_integers: 0
+			}
+		})).json();
+		const threads = /* @__PURE__ */ new Map();
+		for (const row of rows.data) {
+			const thread = transformRow(row);
+			threads.set(thread.id, {
+				...thread,
+				metadata: parseMetadata(thread.metadata)
+			});
+		}
+		return threads;
+	}
 	async getThreadById({ threadId, resourceId }) {
 		try {
 			const thread = transformRow((await (await this.client.query({
@@ -1512,19 +1599,27 @@ var MemoryStorageClickhouse = class extends _mastra_core_storage.MemoryStorage {
 					metadataIndex++;
 				}
 			}
+			const latestThreads = `
+        latest_threads AS (
+          SELECT
+            id,
+            resourceId,
+            title,
+            metadata,
+            toDateTime64(createdAt, 3) as createdAt,
+            toDateTime64(updatedAt, 3) as updatedAt
+          FROM ${_mastra_core_storage.TABLE_THREADS}
+          ${filter?.resourceId ? `WHERE id IN (SELECT id FROM ${_mastra_core_storage.TABLE_THREADS} WHERE resourceId = {resourceId:String})` : ""}
+          ORDER BY updatedAt DESC
+          LIMIT 1 BY id
+        )`;
+			const latestWhere = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
 			const total = (await (await this.client.query({
 				query: `
-          WITH ranked_threads AS (
-            SELECT
-              id,
-              resourceId,
-              metadata,
-              ROW_NUMBER() OVER (PARTITION BY id ORDER BY updatedAt DESC) as row_num
-            FROM ${_mastra_core_storage.TABLE_THREADS}
-          )
-          SELECT count(*) as total 
-          FROM ranked_threads 
-          WHERE row_num = 1 ${whereClauses.length > 0 ? `AND ${whereClauses.join(" AND ")}` : ""}
+          WITH ${latestThreads}
+          SELECT count(*) as total
+          FROM latest_threads
+          ${latestWhere}
         `,
 				query_params: queryParams,
 				clickhouse_settings: {
@@ -1544,17 +1639,7 @@ var MemoryStorageClickhouse = class extends _mastra_core_storage.MemoryStorage {
 			return {
 				threads: transformRows((await (await this.client.query({
 					query: `
-              WITH ranked_threads AS (
-                SELECT
-                  id,
-                  resourceId,
-                  title,
-                  metadata,
-                  toDateTime64(createdAt, 3) as createdAt,
-                  toDateTime64(updatedAt, 3) as updatedAt,
-                  ROW_NUMBER() OVER (PARTITION BY id ORDER BY updatedAt DESC) as row_num
-                FROM ${_mastra_core_storage.TABLE_THREADS}
-              )
+              WITH ${latestThreads}
               SELECT
                 id,
                 resourceId,
@@ -1562,8 +1647,8 @@ var MemoryStorageClickhouse = class extends _mastra_core_storage.MemoryStorage {
                 metadata,
                 createdAt,
                 updatedAt
-              FROM ranked_threads
-              WHERE row_num = 1 ${whereClauses.length > 0 ? `AND ${whereClauses.join(" AND ")}` : ""}
+              FROM latest_threads
+              ${latestWhere}
               ORDER BY "${field}" ${direction === "DESC" ? "DESC" : "ASC"}
               LIMIT {perPage:Int64} OFFSET {offset:Int64}
             `,
@@ -1676,37 +1761,32 @@ var MemoryStorageClickhouse = class extends _mastra_core_storage.MemoryStorage {
 						clickhouse_settings: {
 							date_time_input_format: "best_effort",
 							use_client_time_zone: 1,
-							output_format_json_quote_64bit_integers: 0
+							output_format_json_quote_64bit_integers: 0,
+							mutations_sync: "1"
 						}
 					}));
 				}
 			}
 			if (updatePromises.length > 0) await Promise.all(updatePromises);
-			await this.client.command({
-				query: `OPTIMIZE TABLE ${_mastra_core_storage.TABLE_MESSAGES} FINAL`,
+			const verifyResult = await this.client.query({
+				query: `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${_mastra_core_storage.TABLE_MESSAGES} WHERE id IN {messageIds:Array(String)}`,
+				query_params: { messageIds },
 				clickhouse_settings: {
 					date_time_input_format: "best_effort",
+					date_time_output_format: "iso",
 					use_client_time_zone: 1,
 					output_format_json_quote_64bit_integers: 0
 				}
 			});
+			const verifiedById = /* @__PURE__ */ new Map();
+			for (const row of transformRows((await verifyResult.json()).data)) if (!verifiedById.has(row.id)) verifiedById.set(row.id, row);
 			for (const existingMessage of parsedExistingMessages) {
 				const updatePayload = messages.find((m) => m.id === existingMessage.id);
 				if (!updatePayload) continue;
 				const { id, ...fieldsToUpdate } = updatePayload;
 				if (Object.keys(fieldsToUpdate).length === 0) continue;
-				const verifyRows = await (await this.client.query({
-					query: `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${_mastra_core_storage.TABLE_MESSAGES} WHERE id = {messageId:String}`,
-					query_params: { messageId: id },
-					clickhouse_settings: {
-						date_time_input_format: "best_effort",
-						date_time_output_format: "iso",
-						use_client_time_zone: 1,
-						output_format_json_quote_64bit_integers: 0
-					}
-				})).json();
-				if (verifyRows.data.length > 0) {
-					const updatedMessage = transformRows(verifyRows.data)[0];
+				if (verifiedById.has(id)) {
+					const updatedMessage = verifiedById.get(id);
 					if (updatedMessage) {
 						let needsRetry = false;
 						for (const [key, value] of Object.entries(fieldsToUpdate)) if (key === "content") {
@@ -1773,68 +1853,42 @@ var MemoryStorageClickhouse = class extends _mastra_core_storage.MemoryStorage {
 			}
 			if (threadIdsToUpdate.size > 0) {
 				await new Promise((resolve) => setTimeout(resolve, 10));
-				const now = (/* @__PURE__ */ new Date()).toISOString().replace("Z", "");
-				const threadUpdatePromises = Array.from(threadIdsToUpdate).map(async (threadId) => {
-					const threadRows = await (await this.client.query({
-						query: `SELECT id, resourceId, title, metadata, createdAt FROM ${_mastra_core_storage.TABLE_THREADS} WHERE id = {threadId:String} ORDER BY updatedAt DESC LIMIT 1`,
-						query_params: { threadId },
-						clickhouse_settings: {
-							date_time_input_format: "best_effort",
-							date_time_output_format: "iso",
-							use_client_time_zone: 1,
-							output_format_json_quote_64bit_integers: 0
-						}
-					})).json();
-					if (threadRows.data.length > 0) {
-						const existingThread = threadRows.data[0];
-						await this.client.command({
-							query: `DELETE FROM ${_mastra_core_storage.TABLE_THREADS} WHERE id = {threadId:String}`,
-							query_params: { threadId },
-							clickhouse_settings: {
-								date_time_input_format: "best_effort",
-								use_client_time_zone: 1,
-								output_format_json_quote_64bit_integers: 0
-							}
-						});
-						await this.client.insert({
-							table: _mastra_core_storage.TABLE_THREADS,
-							format: "JSONEachRow",
-							values: [{
-								id: existingThread.id,
-								resourceId: existingThread.resourceId,
-								title: existingThread.title,
-								metadata: typeof existingThread.metadata === "string" ? existingThread.metadata : serializeMetadata(existingThread.metadata),
-								createdAt: existingThread.createdAt,
-								updatedAt: now
-							}],
-							clickhouse_settings: {
-								date_time_input_format: "best_effort",
-								use_client_time_zone: 1,
-								output_format_json_quote_64bit_integers: 0
-							}
-						});
-					}
-				});
-				await Promise.all(threadUpdatePromises);
-			}
-			const updatedMessages = [];
-			for (const messageId of messageIds) {
-				const updatedRows = await (await this.client.query({
-					query: `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${_mastra_core_storage.TABLE_MESSAGES} WHERE id = {messageId:String}`,
-					query_params: { messageId },
+				const now = Date.now();
+				const existingThreads = await this.getLatestThreads(Array.from(threadIdsToUpdate));
+				if (existingThreads.size > 0) await this.client.insert({
+					table: _mastra_core_storage.TABLE_THREADS,
+					format: "JSONEachRow",
+					values: Array.from(existingThreads.values()).map((existingThread) => ({
+						id: existingThread.id,
+						resourceId: existingThread.resourceId,
+						title: existingThread.title,
+						metadata: serializeMetadata(existingThread.metadata),
+						createdAt: existingThread.createdAt,
+						updatedAt: new Date(Math.max(now, new Date(existingThread.updatedAt).getTime() + 1)).toISOString().replace("Z", "")
+					})),
 					clickhouse_settings: {
 						date_time_input_format: "best_effort",
-						date_time_output_format: "iso",
 						use_client_time_zone: 1,
 						output_format_json_quote_64bit_integers: 0
 					}
-				})).json();
-				if (updatedRows.data.length > 0) {
-					const message = transformRows(updatedRows.data)[0];
-					if (message) updatedMessages.push(message);
-				}
+				});
 			}
-			return updatedMessages.map((message) => {
+			const updatedResult = await this.client.query({
+				query: `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${_mastra_core_storage.TABLE_MESSAGES} WHERE id IN {messageIds:Array(String)}`,
+				query_params: { messageIds },
+				clickhouse_settings: {
+					date_time_input_format: "best_effort",
+					date_time_output_format: "iso",
+					use_client_time_zone: 1,
+					output_format_json_quote_64bit_integers: 0
+				}
+			});
+			const updatedById = /* @__PURE__ */ new Map();
+			for (const row of transformRows((await updatedResult.json()).data)) if (!updatedById.has(row.id)) updatedById.set(row.id, row);
+			return messageIds.flatMap((messageId) => {
+				const message = updatedById.get(messageId);
+				return message ? [message] : [];
+			}).map((message) => {
 				if (typeof message.content === "string") try {
 					message.content = JSON.parse(message.content);
 				} catch {}
@@ -1930,35 +1984,9 @@ var MemoryStorageClickhouse = class extends _mastra_core_storage.MemoryStorage {
 					...existingResource.metadata,
 					...metadata
 				},
-				updatedAt: /* @__PURE__ */ new Date()
+				updatedAt: new Date(Math.max(Date.now(), existingResource.updatedAt.getTime() + 1))
 			};
-			const updateQuery = `
-            ALTER TABLE ${_mastra_core_storage.TABLE_RESOURCES}
-            UPDATE workingMemory = {workingMemory:String}, metadata = {metadata:String}, updatedAt = {updatedAt:String}
-            WHERE id = {resourceId:String}
-          `;
-			await this.client.command({
-				query: updateQuery,
-				query_params: {
-					workingMemory: updatedResource.workingMemory,
-					metadata: JSON.stringify(updatedResource.metadata),
-					updatedAt: updatedResource.updatedAt.toISOString().replace("Z", ""),
-					resourceId
-				},
-				clickhouse_settings: {
-					date_time_input_format: "best_effort",
-					use_client_time_zone: 1,
-					output_format_json_quote_64bit_integers: 0
-				}
-			});
-			await this.client.command({
-				query: `OPTIMIZE TABLE ${_mastra_core_storage.TABLE_RESOURCES} FINAL`,
-				clickhouse_settings: {
-					date_time_input_format: "best_effort",
-					use_client_time_zone: 1,
-					output_format_json_quote_64bit_integers: 0
-				}
-			});
+			await this.saveResource({ resource: updatedResource });
 			return updatedResource;
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
@@ -2406,14 +2434,10 @@ var ObservabilityStorageClickhouse = class extends _mastra_core_storage.Observab
 				}
 				if (filters.hasChildError !== void 0) {
 					const finalClause = (TABLE_ENGINES[_mastra_core_storage.TABLE_SPANS] ?? "MergeTree()").startsWith("ReplacingMergeTree") ? "FINAL" : "";
-					if (filters.hasChildError) conditions.push(`EXISTS (
-              SELECT 1 FROM ${_mastra_core_storage.TABLE_SPANS} ${finalClause} c
-              WHERE c.traceId = ${_mastra_core_storage.TABLE_SPANS}.traceId AND c.error IS NOT NULL AND c.error != ''
-            )`);
-					else conditions.push(`NOT EXISTS (
-              SELECT 1 FROM ${_mastra_core_storage.TABLE_SPANS} ${finalClause} c
-              WHERE c.traceId = ${_mastra_core_storage.TABLE_SPANS}.traceId AND c.error IS NOT NULL AND c.error != ''
-            )`);
+					conditions.push(`traceId ${filters.hasChildError ? "IN" : "NOT IN"} (
+            SELECT c.traceId FROM ${_mastra_core_storage.TABLE_SPANS} ${finalClause} c
+            WHERE c.error IS NOT NULL AND c.error != ''
+          )`);
 				}
 			}
 			const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -2505,35 +2529,58 @@ var ObservabilityStorageClickhouse = class extends _mastra_core_storage.Observab
 	async batchUpdateSpans(args) {
 		try {
 			const now = Date.now();
+			if (args.records.length === 0) return;
+			const keyParams = {};
+			const keyTuples = args.records.map((record, i) => {
+				keyParams[`t_${i}`] = record.traceId;
+				keyParams[`s_${i}`] = record.spanId;
+				return `({t_${i}:String}, {s_${i}:String})`;
+			});
+			const existingResult = await this.client.query({
+				query: `SELECT *, toDateTime64(createdAt, 3) as createdAt, toDateTime64(updatedAt, 3) as updatedAt
+                FROM ${_mastra_core_storage.TABLE_SPANS}
+                WHERE (traceId, spanId) IN (${keyTuples.join(", ")})
+                -- Newest version per span, which is what ReplacingMergeTree(updatedAt)
+                -- keeps. FINAL would merge every part the batch's keys touch, which
+                -- costs far more than reading the unmerged versions and sorting them.
+                ORDER BY updatedAt DESC
+                LIMIT 1 BY traceId, spanId`,
+				query_params: keyParams,
+				clickhouse_settings: {
+					date_time_input_format: "best_effort",
+					date_time_output_format: "iso",
+					use_client_time_zone: 1,
+					output_format_json_quote_64bit_integers: 0
+				}
+			});
+			const spanKey = (traceId, spanId) => `${traceId}\u0000${spanId}`;
+			const current = /* @__PURE__ */ new Map();
+			for (const row of transformRows((await existingResult.json()).data)) current.set(spanKey(row.traceId, row.spanId), row);
 			for (const record of args.records) {
-				const existing = await this.#db.load({
-					tableName: _mastra_core_storage.TABLE_SPANS,
-					keys: {
-						spanId: record.spanId,
-						traceId: record.traceId
-					}
+				const key = spanKey(record.traceId, record.spanId);
+				const existing = current.get(key);
+				if (!existing) continue;
+				const updates = { ...record.updates };
+				if (updates.startedAt instanceof Date) updates.startedAt = updates.startedAt.getTime();
+				if (updates.endedAt instanceof Date) updates.endedAt = updates.endedAt.getTime();
+				current.set(key, {
+					...existing,
+					...updates,
+					updatedAt: now,
+					__updated: true
 				});
-				if (existing) {
-					const updates = { ...record.updates };
-					if (updates.startedAt instanceof Date) updates.startedAt = updates.startedAt.getTime();
-					if (updates.endedAt instanceof Date) updates.endedAt = updates.endedAt.getTime();
-					const updated = {
-						...existing,
-						...updates,
-						updatedAt: now
-					};
-					await this.client.insert({
-						table: _mastra_core_storage.TABLE_SPANS,
-						values: [updated],
-						format: "JSONEachRow",
-						clickhouse_settings: {
-							date_time_input_format: "best_effort",
-							use_client_time_zone: 1,
-							output_format_json_quote_64bit_integers: 0
-						}
-					});
-				}
 			}
+			const updatedRows = Array.from(current.values()).filter((row) => row.__updated).map(({ __updated: _updated, ...row }) => row);
+			if (updatedRows.length > 0) await this.client.insert({
+				table: _mastra_core_storage.TABLE_SPANS,
+				values: updatedRows,
+				format: "JSONEachRow",
+				clickhouse_settings: {
+					date_time_input_format: "best_effort",
+					use_client_time_zone: 1,
+					output_format_json_quote_64bit_integers: 0
+				}
+			});
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLICKHOUSE", "BATCH_UPDATE_SPANS", "FAILED"),
@@ -2762,7 +2809,12 @@ CREATE TABLE IF NOT EXISTS ${TABLE_TRACE_ROOTS} (
   output             Nullable(String),
   error              Nullable(String),
   metadataRaw        Nullable(String),
-  requestContext     Nullable(String)
+  requestContext     Nullable(String),
+
+  -- traceId is second in the sort key, behind startedAt, so point lookups by
+  -- traceId (getRootSpan, trace deletes, trace-query root dedupe) need a skip
+  -- index to avoid scanning every granule.
+  INDEX idx_traceId traceId TYPE bloom_filter(0.01) GRANULARITY 1
 )
 ENGINE = ReplacingMergeTree
 PARTITION BY toDate(endedAt)
@@ -2836,7 +2888,9 @@ CREATE TABLE IF NOT EXISTS ${TABLE_TRACE_BRANCHES} (
   output             Nullable(String),
   error              Nullable(String),
   metadataRaw        Nullable(String),
-  requestContext     Nullable(String)
+  requestContext     Nullable(String),
+
+  INDEX idx_traceId traceId TYPE bloom_filter(0.01) GRANULARITY 1
 )
 ENGINE = ReplacingMergeTree
 PARTITION BY toDate(endedAt)
@@ -3065,7 +3119,19 @@ CREATE TABLE IF NOT EXISTS ${TABLE_LOG_EVENTS} (
   -- Information-only JSON payloads
   data               Nullable(String),
   metadata           Nullable(String),
-  scope              Nullable(String)
+  scope              Nullable(String),
+
+  -- Same ID drilldown indexes as metric_events: these columns are outside
+  -- the sort key, so without them every drilldown scans the time range.
+  INDEX idx_traceId traceId TYPE bloom_filter(0.01) GRANULARITY 2,
+  INDEX idx_threadId threadId TYPE bloom_filter(0.01) GRANULARITY 2,
+  INDEX idx_resourceId resourceId TYPE bloom_filter(0.01) GRANULARITY 2,
+  INDEX idx_userId userId TYPE bloom_filter(0.01) GRANULARITY 2,
+  INDEX idx_organizationId organizationId TYPE bloom_filter(0.01) GRANULARITY 2,
+  INDEX idx_experimentId experimentId TYPE bloom_filter(0.01) GRANULARITY 2,
+  INDEX idx_runId runId TYPE bloom_filter(0.01) GRANULARITY 2,
+  INDEX idx_sessionId sessionId TYPE bloom_filter(0.01) GRANULARITY 2,
+  INDEX idx_requestId requestId TYPE bloom_filter(0.01) GRANULARITY 2
 )
 ENGINE = ReplacingMergeTree
 PARTITION BY toDate(timestamp)
@@ -3194,7 +3260,8 @@ SETTINGS allow_nullable_key = 1
 `;
 const SCORE_EVENTS_CURRENT_DDL = `
 CREATE TABLE IF NOT EXISTS ${TABLE_SCORE_EVENTS_CURRENT} (
-${SCORE_EVENT_COLUMNS_DDL}
+${SCORE_EVENT_COLUMNS_DDL},
+  INDEX idx_traceId traceId TYPE bloom_filter(0.01) GRANULARITY 1
 )
 ENGINE = ReplacingMergeTree(writeVersion)
 PARTITION BY cityHash64(scoreId) % 64
@@ -3322,7 +3389,11 @@ CREATE TABLE IF NOT EXISTS ${TABLE_FEEDBACK_EVENTS} (
 
   -- Information-only JSON payloads
   metadata           Nullable(String),
-  scope              Nullable(String)
+  scope              Nullable(String),
+
+  -- feedbackId is last in the sort key; id lookups (write versions, review
+  -- updates, deletes, trace-query dedupe) need a skip index.
+  INDEX idx_feedbackId feedbackId TYPE bloom_filter(0.01) GRANULARITY 1
 )
 ENGINE = ReplacingMergeTree
 PARTITION BY toDate(timestamp)
@@ -3568,11 +3639,15 @@ const ALL_MIGRATIONS = [
 	addColumn(TABLE_SCORE_EVENTS, "rootEntityVersionId", "Nullable(String)"),
 	addBloomIndex(TABLE_SCORE_EVENTS, "idx_scoreId", "scoreId", 1),
 	addBloomIndex(TABLE_SCORE_EVENTS_DELTA, "idx_scoreId", "scoreId", 1),
+	addBloomIndex(TABLE_SCORE_EVENTS_CURRENT, "idx_traceId", "traceId", 1),
 	addColumn(TABLE_FEEDBACK_EVENTS, "writeVersion", "UInt64 DEFAULT 0"),
 	addColumn(TABLE_FEEDBACK_EVENTS, "entityVersionId", "Nullable(String)"),
 	addColumn(TABLE_FEEDBACK_EVENTS, "reviewStatus", "LowCardinality(String) DEFAULT 'needs-review'"),
 	addColumn(TABLE_FEEDBACK_EVENTS, "parentEntityVersionId", "Nullable(String)"),
 	addColumn(TABLE_FEEDBACK_EVENTS, "rootEntityVersionId", "Nullable(String)"),
+	addBloomIndex(TABLE_FEEDBACK_EVENTS, "idx_feedbackId", "feedbackId", 1),
+	addBloomIndex(TABLE_TRACE_ROOTS, "idx_traceId", "traceId", 1),
+	addBloomIndex(TABLE_TRACE_BRANCHES, "idx_traceId", "traceId", 1),
 	addBloomIndex(TABLE_METRIC_EVENTS, "idx_traceId", "traceId"),
 	addBloomIndex(TABLE_METRIC_EVENTS, "idx_threadId", "threadId"),
 	addBloomIndex(TABLE_METRIC_EVENTS, "idx_resourceId", "resourceId"),
@@ -3582,6 +3657,17 @@ const ALL_MIGRATIONS = [
 	addBloomIndex(TABLE_METRIC_EVENTS, "idx_runId", "runId"),
 	addBloomIndex(TABLE_METRIC_EVENTS, "idx_sessionId", "sessionId"),
 	addBloomIndex(TABLE_METRIC_EVENTS, "idx_requestId", "requestId"),
+	...[
+		"traceId",
+		"threadId",
+		"resourceId",
+		"userId",
+		"organizationId",
+		"experimentId",
+		"runId",
+		"sessionId",
+		"requestId"
+	].map((column) => addBloomIndex(TABLE_LOG_EVENTS, `idx_${column}`, column)),
 	addBloomIndex(TABLE_DELETION_REQUESTS, "idx_predicateValues", "predicateValues")
 ];
 const ALL_TABLE_NAMES = [
@@ -4677,6 +4763,11 @@ function validateCursorId(cursor) {
 		text: "Invalid observability delta cursor"
 	});
 }
+/** ANDs `conditions` onto a `WHERE ...` clause, or starts one when `whereClause` is empty. */
+function appendWhere(whereClause, ...conditions) {
+	const parts = [whereClause.replace(/^\s*WHERE\s+/i, ""), ...conditions].filter(Boolean);
+	return parts.length > 0 ? `WHERE ${parts.join(" AND ")}` : "";
+}
 //#endregion
 //#region src/storage/domains/observability/v-next/feedback.ts
 const FEEDBACK_TYPED_COLUMNS = /* @__PURE__ */ new Set([
@@ -4783,12 +4874,21 @@ function resolveFeedbackGroupBy(groupBy) {
 function toSeriesName$1(values) {
 	return values.map((v) => v == null ? "" : String(v)).join("|");
 }
-async function queryJson$2(client, query, params) {
+/**
+* Lets `FINAL` reads use skip indexes on older servers, where it defaults off.
+* Only for lookups on a column shared by every version of a sort key (so a
+* skipped granule can never hold a newer version of a matching row).
+*/
+const FINAL_SKIP_INDEX_SETTINGS = { use_skip_indexes_if_final: 1 };
+async function queryJson$2(client, query, params, settings = {}) {
 	return await (await client.query({
 		query,
 		query_params: params,
 		format: "JSONEachRow",
-		clickhouse_settings: CH_SETTINGS
+		clickhouse_settings: {
+			...CH_SETTINGS,
+			...settings
+		}
 	})).json();
 }
 async function feedbackRowsWithWriteVersions(client, feedbacks) {
@@ -4897,7 +4997,7 @@ async function hasFeedbackDeletionRequest(client, feedbackId, organizationId, re
 		feedbackId,
 		organizationId: organizationId ?? "",
 		resourceId: resourceId ?? ""
-	})).length > 0;
+	}, FINAL_SKIP_INDEX_SETTINGS)).length > 0;
 }
 /**
 * Review updates insert a replacement row, so they need only `INSERT` and the
@@ -4918,7 +5018,7 @@ async function updateFeedbackReviewStatus(client, args, replication) {
 	const existingRow = (await queryJson$2(client, `SELECT * FROM ${TABLE_FEEDBACK_EVENTS} FINAL
      WHERE feedbackId = {feedbackId:String}
      ORDER BY writeVersion DESC, timestamp DESC
-     LIMIT 1`, { feedbackId }))[0];
+     LIMIT 1`, { feedbackId }, FINAL_SKIP_INDEX_SETTINGS))[0];
 	if (!existingRow) throw feedbackNotFoundError(feedbackId);
 	const { organizationId, resourceId } = existingRow;
 	const redelete = async () => {
@@ -4995,12 +5095,16 @@ async function queryFeedbackAfterCursor(client, whereClause, params, limit, curs
         f.timestamp AS timestamp,
         f.feedbackId AS feedbackId,
         toString(d.cursorId) AS cursorId
-      FROM ${TABLE_FEEDBACK_EVENTS_DELTA} d
-      INNER JOIN ${TABLE_FEEDBACK_EVENTS} f FINAL
-        ON ((f.traceId = d.traceId) OR (f.traceId IS NULL AND d.traceId IS NULL))
+      FROM ${TABLE_FEEDBACK_EVENTS} f FINAL
+      INNER JOIN (
+        SELECT cursorId, traceId, timestamp, feedbackId
+        FROM ${TABLE_FEEDBACK_EVENTS_DELTA}
+        WHERE cursorId > {afterCursor:UInt64}
+      ) d
+        ON isNotDistinctFrom(f.traceId, d.traceId)
        AND f.timestamp = d.timestamp
        AND f.feedbackId = d.feedbackId
-      ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+      ${appendWhere(whereClause, `f.timestamp >= (SELECT min(timestamp) FROM ${TABLE_FEEDBACK_EVENTS_DELTA} WHERE cursorId > {afterCursor:UInt64})`, `(f.timestamp, f.feedbackId) IN (${`SELECT timestamp, feedbackId FROM ${TABLE_FEEDBACK_EVENTS_DELTA} WHERE cursorId > {afterCursor:UInt64}`})`)}
       ORDER BY d.cursorId ASC
       LIMIT {fetchLimit:UInt32}
     `, {
@@ -5009,18 +5113,24 @@ async function queryFeedbackAfterCursor(client, whereClause, params, limit, curs
 		fetchLimit: limit + 1
 	});
 }
+/**
+* Newest delta cursor whose feedback matches the filters. Without filters
+* this is the stream head; with filters, the feedback scan is bounded below by
+* the oldest `timestamp` still in the delta table.
+*/
 async function getDeltaCursor$5(client, whereClause, params) {
+	if (!whereClause) return getStreamHeadCursor$5(client);
 	const cursorId = (await queryJson$2(client, `
       SELECT toString(max(d.cursorId)) AS cursorId
       FROM mastra_feedback_events_delta d
-      INNER JOIN mastra_feedback_events f FINAL
-        ON ((f.traceId = d.traceId) OR (f.traceId IS NULL AND d.traceId IS NULL))
-       AND f.timestamp = d.timestamp
-       AND f.feedbackId = d.feedbackId
-      ${whereClause}
+      WHERE (d.timestamp, d.feedbackId) IN (
+        SELECT f.timestamp, f.feedbackId
+        FROM mastra_feedback_events f FINAL
+        ${appendWhere(whereClause, `f.timestamp >= (SELECT min(timestamp) FROM mastra_feedback_events_delta)`)}
+      )
     `, params))[0]?.cursorId ?? null;
 	if (cursorId) return cursorId;
-	return (await queryJson$2(client, `SELECT toString(max(cursorId)) AS cursorId FROM mastra_feedback_events_delta`, {}))[0]?.cursorId ?? "0";
+	return getStreamHeadCursor$5(client);
 }
 async function getStreamHeadCursor$5(client) {
 	return (await queryJson$2(client, `SELECT toString(max(cursorId)) AS cursorId FROM mastra_feedback_events_delta`, {}))[0]?.cursorId ?? "0";
@@ -5142,26 +5252,22 @@ async function getFeedbackPercentiles(client, args) {
 	const combined = mergeFilters$2(buildFeedbackIdentityFilter(args), buildFeedbackFilterConditions(args.filters));
 	const whereClause = toWhereClause$2(combined);
 	if (!Array.isArray(args.percentiles) || args.percentiles.length === 0) throw new Error("Percentiles must include at least one value between 0 and 1.");
-	const series = [];
-	for (const p of args.percentiles) {
-		if (!Number.isFinite(p) || p < 0 || p > 1) throw new Error(`Percentile value must be a finite number between 0 and 1, got ${p}`);
-		const rows = await queryJson$2(client, `
-      SELECT toStartOfInterval(timestamp, ${intervalSql}) AS bucket,
-             quantile(${p})(valueNumber) AS pvalue
-      FROM ${TABLE_FEEDBACK_EVENTS} FINAL
-      ${whereClause}
-      GROUP BY bucket
-      ORDER BY bucket
-    `, combined.params);
-		series.push({
-			percentile: p,
-			points: rows.map((row) => ({
-				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
-				value: Number(row.pvalue ?? 0)
-			}))
-		});
-	}
-	return { series };
+	for (const p of args.percentiles) if (!Number.isFinite(p) || p < 0 || p > 1) throw new Error(`Percentile value must be a finite number between 0 and 1, got ${p}`);
+	const rows = await queryJson$2(client, `
+    SELECT toStartOfInterval(timestamp, ${intervalSql}) AS bucket,
+           quantiles(${args.percentiles.join(", ")})(valueNumber) AS pvalues
+    FROM ${TABLE_FEEDBACK_EVENTS} FINAL
+    ${whereClause}
+    GROUP BY bucket
+    ORDER BY bucket
+  `, combined.params);
+	return { series: args.percentiles.map((percentile, index) => ({
+		percentile,
+		points: rows.map((row) => ({
+			timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+			value: Number(row.pvalues?.[index] ?? 0)
+		}))
+	})) };
 }
 //#endregion
 //#region src/storage/domains/observability/v-next/logs.ts
@@ -5240,6 +5346,7 @@ async function listLogs(client, args, strategy) {
 	};
 }
 async function queryLogsAfterCursor(client, whereClause, params, limit, cursorId) {
+	const deltaKeys = `SELECT timestamp, logId FROM ${TABLE_LOG_EVENTS_DELTA} WHERE cursorId > {afterCursor:UInt64}`;
 	return await (await client.query({
 		query: `
         SELECT
@@ -5247,11 +5354,15 @@ async function queryLogsAfterCursor(client, whereClause, params, limit, cursorId
           l.timestamp AS timestamp,
           l.logId AS logId,
           toString(d.cursorId) AS cursorId
-        FROM ${TABLE_LOG_EVENTS_DELTA} d
-        INNER JOIN ${TABLE_LOG_EVENTS} l
+        FROM ${TABLE_LOG_EVENTS} l
+        INNER JOIN (
+          SELECT cursorId, timestamp, logId
+          FROM ${TABLE_LOG_EVENTS_DELTA}
+          WHERE cursorId > {afterCursor:UInt64}
+        ) d
           ON l.timestamp = d.timestamp
          AND l.logId = d.logId
-        ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+        ${appendWhere(whereClause, `(l.timestamp, l.logId) IN (${deltaKeys})`)}
         ORDER BY d.cursorId ASC
         LIMIT {fetchLimit:UInt32}
       `,
@@ -5264,26 +5375,29 @@ async function queryLogsAfterCursor(client, whereClause, params, limit, cursorId
 		clickhouse_settings: CH_SETTINGS
 	})).json();
 }
+/**
+* Newest delta cursor whose log matches the filters. Without filters this is
+* the stream head; with filters, the log scan is bounded below by the oldest
+* `timestamp` still in the delta table.
+*/
 async function getDeltaCursor$4(client, whereClause, params) {
+	if (!whereClause) return getStreamHeadCursor$4(client);
 	const cursorId = (await (await client.query({
 		query: `
         SELECT toString(max(d.cursorId)) AS cursorId
         FROM mastra_log_events_delta d
-        INNER JOIN mastra_log_events l
-          ON l.timestamp = d.timestamp
-         AND l.logId = d.logId
-        ${whereClause}
+        WHERE (d.timestamp, d.logId) IN (
+          SELECT l.timestamp, l.logId
+          FROM mastra_log_events l
+          ${appendWhere(whereClause, `l.timestamp >= (SELECT min(timestamp) FROM mastra_log_events_delta)`)}
+        )
       `,
 		query_params: params,
 		format: "JSONEachRow",
 		clickhouse_settings: CH_SETTINGS
 	})).json())[0]?.cursorId ?? null;
 	if (cursorId) return cursorId;
-	return (await (await client.query({
-		query: `SELECT toString(max(cursorId)) AS cursorId FROM mastra_log_events_delta`,
-		format: "JSONEachRow",
-		clickhouse_settings: CH_SETTINGS
-	})).json())[0]?.cursorId ?? "0";
+	return getStreamHeadCursor$4(client);
 }
 async function getStreamHeadCursor$4(client) {
 	return (await (await client.query({
@@ -5509,12 +5623,16 @@ async function queryMetricsAfterCursor(client, whereClause, params, limit, curso
         m.timestamp AS timestamp,
         m.metricId AS metricId,
         toString(d.cursorId) AS cursorId
-      FROM ${TABLE_METRIC_EVENTS_DELTA} d
-      INNER JOIN ${TABLE_METRIC_EVENTS} m
+      FROM ${TABLE_METRIC_EVENTS} m
+      INNER JOIN (
+        SELECT cursorId, name, timestamp, metricId
+        FROM ${TABLE_METRIC_EVENTS_DELTA}
+        WHERE cursorId > {afterCursor:UInt64}
+      ) d
         ON m.name = d.name
        AND m.timestamp = d.timestamp
        AND m.metricId = d.metricId
-      ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+      ${appendWhere(whereClause, `(m.name, m.timestamp, m.metricId) IN (${`SELECT name, timestamp, metricId FROM ${TABLE_METRIC_EVENTS_DELTA} WHERE cursorId > {afterCursor:UInt64}`})`)}
       ORDER BY d.cursorId ASC
       LIMIT {fetchLimit:UInt32}
     `, {
@@ -5523,18 +5641,24 @@ async function queryMetricsAfterCursor(client, whereClause, params, limit, curso
 		fetchLimit: limit + 1
 	});
 }
+/**
+* Newest delta cursor whose metric matches the filters. Without filters this
+* is the stream head; with filters, the metric scan is bounded below by the
+* oldest `timestamp` still in the delta table.
+*/
 async function getDeltaCursor$3(client, whereClause, params) {
+	if (!whereClause) return getStreamHeadCursor$3(client);
 	const cursorId = (await queryJson$1(client, `
       SELECT toString(max(d.cursorId)) AS cursorId
       FROM mastra_metric_events_delta d
-      INNER JOIN mastra_metric_events m
-        ON m.name = d.name
-       AND m.timestamp = d.timestamp
-       AND m.metricId = d.metricId
-      ${whereClause}
+      WHERE (d.name, d.timestamp, d.metricId) IN (
+        SELECT m.name, m.timestamp, m.metricId
+        FROM mastra_metric_events m
+        ${appendWhere(whereClause, `m.timestamp >= (SELECT min(timestamp) FROM mastra_metric_events_delta)`)}
+      )
     `, params))[0]?.cursorId ?? null;
 	if (cursorId) return cursorId;
-	return (await queryJson$1(client, `SELECT toString(max(cursorId)) AS cursorId FROM mastra_metric_events_delta`, {}))[0]?.cursorId ?? "0";
+	return getStreamHeadCursor$3(client);
 }
 async function getStreamHeadCursor$3(client) {
 	return (await queryJson$1(client, `SELECT toString(max(cursorId)) AS cursorId FROM mastra_metric_events_delta`, {}))[0]?.cursorId ?? "0";
@@ -5733,29 +5857,26 @@ async function getMetricPercentiles(client, args) {
 		params: { percentileName: args.name }
 	}, signalFilter);
 	const whereClause = toWhereClause$1(combined);
-	const series = [];
-	for (const p of args.percentiles) {
-		if (p < 0 || p > 1) throw new Error(`Percentile value must be between 0 and 1, got ${p}`);
-		const rows = await queryJson$1(client, `
-      SELECT toStartOfInterval(timestamp, ${intervalSql}) AS bucket,
-             quantile(${p})(value) AS pvalue
-      FROM ${TABLE_METRIC_EVENTS}
-      ${whereClause}
-      GROUP BY bucket
-      ORDER BY bucket
-    `, combined.params);
-		series.push({
-			percentile: p,
-			points: rows.map((row) => ({
-				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
-				value: Number(row.pvalue ?? 0)
-			}))
-		});
-	}
-	return { series };
+	for (const p of args.percentiles) if (!Number.isFinite(p) || p < 0 || p > 1) throw new Error(`Percentile value must be a finite number between 0 and 1, got ${p}`);
+	if (args.percentiles.length === 0) return { series: [] };
+	const rows = await queryJson$1(client, `
+    SELECT toStartOfInterval(timestamp, ${intervalSql}) AS bucket,
+           quantiles(${args.percentiles.join(", ")})(value) AS pvalues
+    FROM ${TABLE_METRIC_EVENTS}
+    ${whereClause}
+    GROUP BY bucket
+    ORDER BY bucket
+  `, combined.params);
+	return { series: args.percentiles.map((percentile, index) => ({
+		percentile,
+		points: rows.map((row) => ({
+			timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+			value: Number(row.pvalues?.[index] ?? 0)
+		}))
+	})) };
 }
 async function getMetricNames(client, args) {
-	const conditions = [`kind = 'metricName'`];
+	const conditions = [`kind = 'metricName'`, `key1 = ''`];
 	const params = {};
 	if (args.prefix) {
 		conditions.push(`value LIKE {namePrefix:String}`);
@@ -6216,6 +6337,22 @@ function currentScoresRelation(sourcePredicate) {
     ${sourcePredicate ? `WHERE ${sourcePredicate}` : ""}
   )`;
 }
+/**
+* Current-state scores narrowed before FINAL merges. `score_events_current` is
+* keyed by scoreId, so a traceId filter only applies after FINAL has merged
+* the whole table. When the (unaliased) filter pins traceId, the matching
+* scoreIds are first read from the history table, whose sort key starts with
+* traceId. Every current row was written to history, so the candidate set is a
+* superset; callers still apply the same filter to the current version.
+*
+* Time ranges alone are not narrowed this way: scoreIds are hash-distributed,
+* so the ids from any real time window touch nearly every granule of the
+* current table and the extra history scan costs more than it saves.
+*/
+function prunedCurrentScoresRelation(historyFilter) {
+	if (!historyFilter.conditions.some((condition) => condition.startsWith("traceId "))) return currentScoresRelation();
+	return currentScoresRelation(`scoreId IN (SELECT scoreId FROM ${TABLE_SCORE_EVENTS} WHERE ${historyFilter.conditions.join(" AND ")})`);
+}
 function buildScoreIdentityFilter(args) {
 	const conditions = ["scorerId = {olapScorerId:String}"];
 	const params = { olapScorerId: args.scorerId };
@@ -6360,7 +6497,7 @@ async function listScores(client, args, strategy) {
 		};
 	}
 	const currentDeltaCursor = deltaCursorEnabled ? await getDeltaCursor$2(client, whereClause, filter.params) : void 0;
-	const scoresRelation = currentScoresRelation();
+	const scoresRelation = prunedCurrentScoresRelation(buildScoresFilterConditions(parsed.filters));
 	const countResult = await queryJson(client, `SELECT count() AS total FROM ${scoresRelation} AS s ${whereClause}`, filter.params);
 	const rows = await queryJson(client, `SELECT * FROM ${scoresRelation} AS s ${whereClause} ORDER BY ${orderBy} LIMIT {limit:UInt32} OFFSET {offset:UInt32}`, {
 		...filter.params,
@@ -6398,15 +6535,19 @@ async function queryScoresAfterCursor(client, whereClause, params, limit, cursor
         s.timestamp AS timestamp,
         s.scoreId AS scoreId,
         toString(d.cursorId) AS cursorId
-      FROM ${TABLE_SCORE_EVENTS_DELTA} d
-      INNER JOIN ${TABLE_SCORE_EVENTS_CURRENT} s FINAL
+      FROM ${TABLE_SCORE_EVENTS_CURRENT} s FINAL
+      INNER JOIN (
+        SELECT cursorId, scoreId
+        FROM ${TABLE_SCORE_EVENTS_DELTA}
+        WHERE cursorId > {afterCursor:UInt64}
+          AND scoreId NOT IN (
+            SELECT scoreId FROM ${TABLE_SCORE_EVENTS_DELTA}
+            WHERE cursorId <= {afterCursor:UInt64}
+              AND scoreId IN (SELECT scoreId FROM ${TABLE_SCORE_EVENTS_DELTA} WHERE cursorId > {afterCursor:UInt64})
+          )
+      ) d
         ON s.scoreId = d.scoreId
-      ${whereClause ? `${whereClause} AND` : "WHERE"} d.cursorId > {afterCursor:UInt64}
-        AND d.scoreId NOT IN (
-          SELECT scoreId FROM ${TABLE_SCORE_EVENTS_DELTA}
-          WHERE cursorId <= {afterCursor:UInt64}
-            AND scoreId IN (SELECT scoreId FROM ${TABLE_SCORE_EVENTS_DELTA} WHERE cursorId > {afterCursor:UInt64})
-        )
+      ${appendWhere(whereClause, `s.scoreId IN (SELECT scoreId FROM ${TABLE_SCORE_EVENTS_DELTA} WHERE cursorId > {afterCursor:UInt64})`)}
       ORDER BY d.cursorId ASC
       LIMIT 1 BY s.scoreId
       LIMIT {fetchLimit:UInt32}
@@ -6416,16 +6557,24 @@ async function queryScoresAfterCursor(client, whereClause, params, limit, cursor
 		fetchLimit: limit + 1
 	});
 }
+/**
+* Newest delta cursor whose current score matches the filters. Without
+* filters this is the stream head; with filters, FINAL only merges the
+* scoreIds still in the delta table.
+*/
 async function getDeltaCursor$2(client, whereClause, params) {
+	if (!whereClause) return getStreamHeadCursor$2(client);
 	const cursorId = (await queryJson(client, `
       SELECT toString(max(d.cursorId)) AS cursorId
       FROM mastra_score_events_delta d
-      INNER JOIN mastra_score_events_current s FINAL
-        ON s.scoreId = d.scoreId
-      ${whereClause}
+      WHERE d.scoreId IN (
+        SELECT s.scoreId
+        FROM mastra_score_events_current s FINAL
+        ${appendWhere(whereClause, `s.scoreId IN (SELECT scoreId FROM mastra_score_events_delta)`)}
+      )
     `, params))[0]?.cursorId ?? null;
 	if (cursorId) return cursorId;
-	return (await queryJson(client, `SELECT toString(max(cursorId)) AS cursorId FROM mastra_score_events_delta`, {}))[0]?.cursorId ?? "0";
+	return getStreamHeadCursor$2(client);
 }
 async function getStreamHeadCursor$2(client) {
 	return (await queryJson(client, `SELECT toString(max(cursorId)) AS cursorId FROM mastra_score_events_delta`, {}))[0]?.cursorId ?? "0";
@@ -6442,7 +6591,7 @@ async function getScoreAggregate(client, args) {
 	const identity = buildScoreIdentityFilter(args);
 	const combined = mergeFilters(identity, buildScoresFilterConditions(args.filters));
 	const whereClause = toWhereClause(combined);
-	const result = await queryJson(client, `SELECT ${aggSql} AS value FROM ${currentScoresRelation()} ${whereClause}`, combined.params);
+	const result = await queryJson(client, `SELECT ${aggSql} AS value FROM ${prunedCurrentScoresRelation(combined)} ${whereClause}`, combined.params);
 	const value = result[0]?.value == null ? null : Number(result[0]?.value);
 	if (args.comparePeriod && args.filters?.timestamp) {
 		const ts = args.filters.timestamp;
@@ -6477,7 +6626,7 @@ async function getScoreAggregate(client, args) {
 				}
 			}));
 			const prevWhereClause = toWhereClause(prevCombined);
-			const prevResult = await queryJson(client, `SELECT ${aggSql} AS value FROM ${currentScoresRelation()} ${prevWhereClause}`, prevCombined.params);
+			const prevResult = await queryJson(client, `SELECT ${aggSql} AS value FROM ${prunedCurrentScoresRelation(prevCombined)} ${prevWhereClause}`, prevCombined.params);
 			const previousValue = prevResult[0]?.value == null ? null : Number(prevResult[0]?.value);
 			let changePercent = null;
 			if (previousValue !== null && previousValue !== 0 && value !== null) changePercent = (value - previousValue) / Math.abs(previousValue) * 100;
@@ -6495,7 +6644,7 @@ async function getScoreBreakdown(client, args) {
 	const combined = mergeFilters(buildScoreIdentityFilter(args), buildScoresFilterConditions(args.filters));
 	const whereClause = toWhereClause(combined);
 	const resolved = resolveScoreGroupBy(args.groupBy);
-	return { groups: (await queryJson(client, `SELECT ${resolved.map((e) => e.selectSql).join(", ")}, ${aggSql} AS value FROM ${currentScoresRelation()} ${whereClause} GROUP BY ${resolved.map((e) => e.groupSql).join(", ")} ORDER BY value DESC`, combined.params)).map((row) => ({
+	return { groups: (await queryJson(client, `SELECT ${resolved.map((e) => e.selectSql).join(", ")}, ${aggSql} AS value FROM ${prunedCurrentScoresRelation(combined)} ${whereClause} GROUP BY ${resolved.map((e) => e.groupSql).join(", ")} ORDER BY value DESC`, combined.params)).map((row) => ({
 		dimensions: Object.fromEntries(resolved.map((entry, index) => {
 			const v = row[`group_by_${index}`];
 			return [entry.key, v == null ? null : String(v)];
@@ -6514,7 +6663,7 @@ async function getScoreTimeSeries(client, args) {
       SELECT toStartOfInterval(timestamp, ${intervalSql}) AS bucket,
              ${resolved.map((e) => e.selectSql).join(", ")},
              ${aggSql} AS value
-      FROM ${currentScoresRelation()} ${whereClause}
+      FROM ${prunedCurrentScoresRelation(combined)} ${whereClause}
       GROUP BY bucket, ${resolved.map((e) => e.groupSql).join(", ")}
       ORDER BY bucket
     `, combined.params);
@@ -6536,7 +6685,7 @@ async function getScoreTimeSeries(client, args) {
 	const rows = await queryJson(client, `
     SELECT toStartOfInterval(timestamp, ${intervalSql}) AS bucket,
            ${aggSql} AS value
-    FROM ${currentScoresRelation()} ${whereClause}
+    FROM ${prunedCurrentScoresRelation(combined)} ${whereClause}
     GROUP BY bucket
     ORDER BY bucket
   `, combined.params);
@@ -6553,26 +6702,22 @@ async function getScorePercentiles(client, args) {
 	const combined = mergeFilters(buildScoreIdentityFilter(args), buildScoresFilterConditions(args.filters));
 	const whereClause = toWhereClause(combined);
 	if (!Array.isArray(args.percentiles) || args.percentiles.length === 0) throw new Error("Percentiles must include at least one value between 0 and 1.");
-	const series = [];
-	for (const p of args.percentiles) {
-		if (!Number.isFinite(p) || p < 0 || p > 1) throw new Error(`Percentile value must be a finite number between 0 and 1, got ${p}`);
-		const rows = await queryJson(client, `
-      SELECT toStartOfInterval(timestamp, ${intervalSql}) AS bucket,
-             quantile(${p})(score) AS pvalue
-      FROM ${currentScoresRelation()}
-      ${whereClause}
-      GROUP BY bucket
-      ORDER BY bucket
-    `, combined.params);
-		series.push({
-			percentile: p,
-			points: rows.map((row) => ({
-				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
-				value: Number(row.pvalue ?? 0)
-			}))
-		});
-	}
-	return { series };
+	for (const p of args.percentiles) if (!Number.isFinite(p) || p < 0 || p > 1) throw new Error(`Percentile value must be a finite number between 0 and 1, got ${p}`);
+	const rows = await queryJson(client, `
+    SELECT toStartOfInterval(timestamp, ${intervalSql}) AS bucket,
+           quantiles(${args.percentiles.join(", ")})(score) AS pvalues
+    FROM ${prunedCurrentScoresRelation(combined)}
+    ${whereClause}
+    GROUP BY bucket
+    ORDER BY bucket
+  `, combined.params);
+	return { series: args.percentiles.map((percentile, index) => ({
+		percentile,
+		points: rows.map((row) => ({
+			timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+			value: Number(row.pvalues?.[index] ?? 0)
+		}))
+	})) };
 }
 //#endregion
 //#region src/storage/domains/observability/v-next/trace-query.ts
@@ -6816,6 +6961,22 @@ const TRACE_SELECT = `
   r.entityType AS entityType,
   r.environment AS environment,
   ${TRACE_STATUS_SQL} AS status`;
+/** Candidate columns carried through the page-mode window sort (no payload blobs). */
+const TRACE_PAGE_COLUMNS = [
+	"traceId",
+	"rootSpanId",
+	"name",
+	"entityId",
+	"parentSpanId",
+	"threadId",
+	"resourceId",
+	"startedAt",
+	"endedAt",
+	"entityName",
+	"entityType",
+	"environment",
+	"status"
+];
 var ParameterBuilder = class {
 	params = {};
 	#next = 1;
@@ -6902,13 +7063,12 @@ function collectThreadRelationCollections(predicate, collections) {
 }
 function compilePredicate(predicate, parameters) {
 	if (predicate.type === "relation") {
-		const existence = `EXISTS (
-      SELECT 1 FROM ${predicate.collection === "spans" ? "current_spans" : predicate.collection === "scores" ? "current_scores" : "current_feedback"} s
+		const matching = `(
+      SELECT s.traceId FROM ${predicate.collection === "spans" ? "current_spans" : predicate.collection === "scores" ? "current_scores" : "current_feedback"} s
       WHERE isNotNull(s.traceId)
-        AND s.traceId = r.traceId
         AND (${predicate.collection === "feedback" ? compileFeedbackScalarPredicate(predicate.predicate, parameters) : compileScalarPredicate(predicate.predicate, predicate.collection === "spans" ? SPAN_FIELDS : SCORE_FIELDS, parameters)})
     )`;
-		return predicate.quantifier === "some" ? existence : `NOT ${existence}`;
+		return `r.traceId ${predicate.quantifier === "some" ? "IN" : "NOT IN"} ${matching}`;
 	}
 	if (predicate.type === "boolean") return predicate.args.map((arg) => `(${compilePredicate(arg, parameters)})`).join(predicate.operator === "and" ? " AND " : " OR ");
 	if (predicate.type === "not") return `NOT (${compilePredicate(predicate.arg, parameters)})`;
@@ -6916,12 +7076,12 @@ function compilePredicate(predicate, parameters) {
 }
 function compileThreadPredicate(predicate, parameters) {
 	if (predicate.type === "relation") {
-		const existence = `EXISTS (
-      SELECT 1 FROM eligible_roots r
-      WHERE r.threadId = t.threadId
+		const matching = `(
+      SELECT r.threadId FROM eligible_roots r
+      WHERE isNotNull(r.threadId)
         AND (${compilePredicate(predicate.predicate, parameters)})
     )`;
-		return predicate.quantifier === "some" ? existence : `NOT ${existence}`;
+		return `t.threadId ${predicate.quantifier === "some" ? "IN" : "NOT IN"} ${matching}`;
 	}
 	if (predicate.type === "boolean") return predicate.args.map((arg) => `(${compileThreadPredicate(arg, parameters)})`).join(predicate.operator === "and" ? " AND " : " OR ");
 	return `NOT (${compileThreadPredicate(predicate.arg, parameters)})`;
@@ -7022,6 +7182,15 @@ function compileClickHouseTraceScope(selection, relationCollections, parameters,
     FROM (
       SELECT *
       FROM ${TABLE_FEEDBACK_EVENTS} FINAL
+      -- ClickHouse cannot push the scope filter through LIMIT 1 BY, so keep
+      -- every version of each feedbackId that ever pointed into the scope
+      -- (traceId leads the sort key). A rewrite may move a feedback to another
+      -- trace, so the current version is still filtered below.
+      WHERE feedbackId IN (
+        SELECT feedbackId
+        FROM ${TABLE_FEEDBACK_EVENTS}
+        WHERE traceId IN (SELECT traceId FROM root_scope)
+      )
       ORDER BY feedbackId, writeVersion DESC, timestamp DESC
       LIMIT 1 BY feedbackId
     ) AS current
@@ -7076,11 +7245,12 @@ LIMIT ${parameters.add(plan.limit + 1, "UInt64")}`,
 			cursorId: "0",
 			traceId: ""
 		};
+		const lowerCursor = parameters.add(after.cursorId, "UInt64");
 		return {
 			query: `${candidates}, delta_candidates AS (
   SELECT traceId, max(cursorId) AS latestCursorId
   FROM ${TABLE_TRACE_ROOTS_DELTA}
-  WHERE tuple(cursorId, traceId) > ${`tuple(${parameters.add(after.cursorId, "UInt64")}, ${parameters.add(after.traceId, "String")})`} ${deltaHead ? `AND tuple(cursorId, traceId) <= tuple(${parameters.add(deltaHead.cursorId, "UInt64")}, ${parameters.add(deltaHead.traceId, "String")})` : ""}
+  WHERE cursorId >= ${lowerCursor} AND tuple(cursorId, traceId) > ${`tuple(${lowerCursor}, ${parameters.add(after.traceId, "String")})`} ${deltaHead ? `AND tuple(cursorId, traceId) <= tuple(${parameters.add(deltaHead.cursorId, "UInt64")}, ${parameters.add(deltaHead.traceId, "String")})` : ""}
   GROUP BY traceId
 )
 SELECT c.*, toString(d.latestCursorId) AS __delta_cursor
@@ -7094,46 +7264,25 @@ LIMIT ${parameters.add(plan.limit + 1, "UInt64")}`,
 	}
 	const orderField = resolveOrderField(plan.orderBy.field);
 	const direction = plan.orderBy.direction === "asc" ? "ASC" : "DESC";
-	if (plan.paginationMode === "page") return {
-		query: `${candidates},
+	if (plan.paginationMode === "page") {
+		const onPage = `__row_position > ${parameters.add(plan.page * plan.perPage, "UInt64")} AND __row_position <= ${parameters.add((plan.page + 1) * plan.perPage, "UInt64")}`;
+		return {
+			query: `${candidates},
 page_rows AS (
-  SELECT *, row_number() OVER (ORDER BY ${orderField} ${direction}, traceId ASC) AS __row_position
-  FROM candidates
-  ORDER BY ${orderField} ${direction}, traceId ASC
-  LIMIT ${parameters.add(plan.perPage, "UInt64")} OFFSET ${parameters.add(plan.page * plan.perPage, "UInt64")}
-),
-page_total AS (
-  SELECT count() AS total
+  SELECT
+    ${TRACE_PAGE_COLUMNS.join(",\n    ")},
+    row_number() OVER (ORDER BY ${orderField} ${direction}, traceId ASC) AS __row_position,
+    count() OVER () AS total
   FROM candidates
 )
-SELECT page_rows.*, page_total.total, 0 AS __metadata
+SELECT *, if(${onPage}, 0, 1) AS __metadata
 FROM page_rows
-CROSS JOIN page_total
-UNION ALL
-SELECT
-  '' AS traceId,
-  '' AS rootSpanId,
-  '' AS name,
-  CAST(NULL, 'Nullable(String)') AS entityId,
-  CAST(NULL, 'Nullable(String)') AS parentSpanId,
-  CAST(NULL, 'Nullable(String)') AS metadata,
-  CAST(NULL, 'Nullable(String)') AS input,
-  CAST(NULL, 'Nullable(String)') AS threadId,
-  CAST(NULL, 'Nullable(String)') AS resourceId,
-  toDateTime64(0, 3, 'UTC') AS startedAt,
-  toDateTime64(0, 3, 'UTC') AS endedAt,
-  CAST(NULL, 'Nullable(String)') AS entityName,
-  CAST(NULL, 'Nullable(String)') AS entityType,
-  CAST(NULL, 'Nullable(String)') AS environment,
-  '' AS status,
-  0 AS __row_position,
-  page_total.total AS total,
-  1 AS __metadata
-FROM page_total
+WHERE (${onPage}) OR __row_position = 1
 ORDER BY __metadata ASC, __row_position ASC`,
-		query_params: parameters.params,
-		sharedSnapshot: true
-	};
+			query_params: parameters.params,
+			sharedSnapshot: true
+		};
+	}
 	let pageCondition = "";
 	if (plan.cursor) {
 		const comparison = plan.orderBy.direction === "asc" ? ">" : "<";
@@ -7151,6 +7300,23 @@ LIMIT ${limit}`,
 		query_params: parameters.params
 	};
 }
+/**
+* Fetches the metadata/input payloads for page-mode rows. Looks rows up by the
+* trace_roots sort-key prefix `(startedAt, traceId)`, so only the page's
+* granules are read. A root can have unmerged versions in different `endedAt`
+* partitions, so `endedAt` is part of the key: the payload comes from the same
+* version as the candidate row.
+*/
+function compileClickHouseTraceRootPayloads(keys) {
+	const parameters = new ParameterBuilder();
+	return {
+		query: `SELECT traceId, spanId AS rootSpanId, metadataRaw AS metadata, input
+FROM ${TABLE_TRACE_ROOTS}
+WHERE (startedAt, traceId, spanId, endedAt) IN (${keys.map((key) => `(${parameters.add(key.startedAt, "DateTime64(3, 'UTC')")}, ${parameters.add(key.traceId, "String")}, ${parameters.add(key.rootSpanId, "String")}, ${parameters.add(key.endedAt, "DateTime64(3, 'UTC')")})`).join(", ")})
+LIMIT 1 BY traceId, spanId`,
+		query_params: parameters.params
+	};
+}
 function compileClickHouseThreadQuery(plan) {
 	const parameters = new ParameterBuilder();
 	const relationCollections = collectRelationCollections(plan.traces.where);
@@ -7344,7 +7510,21 @@ async function queryTraces(client, plan, timeoutMs, strategy = null) {
 	if (plan.paginationMode === "page") {
 		const rows = await runWithClickHouseTraceQueryTimeout(client, { timeoutMs: deltaHead ? remaining() : timeoutMs }, compileClickHouseTraceQuery(plan, deltaHead));
 		const total = Number(rows.at(-1)?.total ?? 0);
-		const traces = rows.filter((row) => Number(row.__metadata) === 0).map((row) => ({
+		const pageRows = rows.filter((row) => Number(row.__metadata) === 0);
+		const payloads = /* @__PURE__ */ new Map();
+		if (pageRows.length > 0) {
+			const payloadRows = await runWithClickHouseTraceQueryTimeout(client, { timeoutMs: remaining() }, compileClickHouseTraceRootPayloads(pageRows.map((row) => ({
+				traceId: String(row.traceId),
+				rootSpanId: String(row.rootSpanId),
+				startedAt: asIsoTimestamp(row.startedAt),
+				endedAt: asIsoTimestamp(row.endedAt)
+			}))));
+			for (const payload of payloadRows) payloads.set(`${payload.traceId}\u0000${payload.rootSpanId}`, payload);
+		}
+		const traces = pageRows.map((row) => ({
+			...row,
+			...payloads.get(`${row.traceId}\u0000${row.rootSpanId}`)
+		})).map((row) => ({
 			traceId: String(row.traceId),
 			rootSpanId: String(row.rootSpanId),
 			name: row.name,
@@ -7887,18 +8067,16 @@ async function listTraceRows(client, args, strategy, projection, mapRows) {
 	const page = pagination?.page ?? 0;
 	const perPage = pagination?.perPage ?? 10;
 	const { conditions, params } = buildTraceFilterConditions(filters, "r");
-	if (filters?.hasChildError != null) if (filters.hasChildError) conditions.push(`EXISTS (
-        SELECT 1 FROM ${TABLE_SPAN_EVENTS} c
-        WHERE c.traceId = r.traceId
-          AND c.parentSpanId IS NOT NULL
-          AND c.error IS NOT NULL
-      )`);
-	else conditions.push(`NOT EXISTS (
-        SELECT 1 FROM ${TABLE_SPAN_EVENTS} c
-        WHERE c.traceId = r.traceId
-          AND c.parentSpanId IS NOT NULL
+	if (filters?.hasChildError != null) {
+		const scope = buildTraceFilterConditions(filters, "scope_r");
+		const traceScope = scope.conditions.length ? `c.traceId IN (SELECT scope_r.traceId FROM ${TABLE_TRACE_ROOTS} scope_r WHERE ${scope.conditions.join(" AND ")})
+          AND ` : "";
+		conditions.push(`r.traceId ${filters.hasChildError ? "IN" : "NOT IN"} (
+        SELECT c.traceId FROM ${TABLE_SPAN_EVENTS} c
+        WHERE ${traceScope}c.parentSpanId IS NOT NULL
           AND c.error IS NOT NULL
       )`);
+	}
 	const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
 	const deltaCursorEnabled = deltaPollingSupported(strategy);
 	if (mode === "delta") {
@@ -7954,15 +8132,27 @@ async function listTraceRows(client, args, strategy, projection, mapRows) {
 	const rows = await (await client.query({
 		query: `
       SELECT ${projection.outerSelect} FROM (
+        -- Deferred join: pick the page's sort keys from a narrow sort, then
+        -- read full rows only for those keys. LIMIT 1 BY disables ClickHouse's
+        -- own lazy materialization, so sorting SELECT * directly would carry
+        -- every matching row's payload columns through the sort. The filter is
+        -- applied again on the re-read: a dedupeKey can have unmerged versions
+        -- (in different endedAt partitions) and only a matching one may win.
         SELECT ${projection.innerSelect}
         FROM ${TABLE_TRACE_ROOTS} r
-        ${whereClause}
-        ORDER BY dedupeKey
+        ${appendWhere(whereClause, `(r.startedAt, r.traceId, r.dedupeKey) IN (
+          SELECT startedAt, traceId, dedupeKey
+          FROM ${TABLE_TRACE_ROOTS} r
+          ${whereClause}
+          ORDER BY ${orderClause}, dedupeKey ASC
+          LIMIT 1 BY dedupeKey
+          LIMIT {limit:UInt32}
+          OFFSET {offset:UInt32}
+        )`)}
+        ORDER BY ${orderClause}, dedupeKey ASC
         LIMIT 1 BY dedupeKey
       )
-      ORDER BY ${orderClause}
-      LIMIT {limit:UInt32}
-      OFFSET {offset:UInt32}
+      ORDER BY ${orderClause}, dedupeKey ASC
     `,
 		query_params: {
 			...params,
@@ -7996,6 +8186,7 @@ async function listTracesLight(client, args, strategy) {
 	return listTraceRows(client, args, strategy, LIGHT_PROJECTION, (rows) => rows.map(rowToLightSpanRecord));
 }
 async function queryTracesAfterCursor(client, deltaSelect, whereClause, params, limit, cursorId) {
+	const deltaKeys = `SELECT startedAt, traceId, dedupeKey FROM ${TABLE_TRACE_ROOTS_DELTA} WHERE cursorId > {afterCursor:UInt64}`;
 	return await (await client.query({
 		query: `
         SELECT
@@ -8004,12 +8195,16 @@ async function queryTracesAfterCursor(client, deltaSelect, whereClause, params,
           r.traceId AS traceId,
           r.dedupeKey AS dedupeKey,
           toString(d.cursorId) AS cursorId
-        FROM ${TABLE_TRACE_ROOTS_DELTA} d
-        INNER JOIN ${TABLE_TRACE_ROOTS} r
+        FROM ${TABLE_TRACE_ROOTS} r
+        INNER JOIN (
+          SELECT cursorId, startedAt, traceId, dedupeKey
+          FROM ${TABLE_TRACE_ROOTS_DELTA}
+          WHERE cursorId > {afterCursor:UInt64}
+        ) d
           ON r.startedAt = d.startedAt
          AND r.traceId = d.traceId
          AND r.dedupeKey = d.dedupeKey
-        ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+        ${appendWhere(whereClause, `(r.startedAt, r.traceId, r.dedupeKey) IN (${deltaKeys})`)}
         ORDER BY d.cursorId ASC
         LIMIT {fetchLimit:UInt32}
       `,
@@ -8022,27 +8217,30 @@ async function queryTracesAfterCursor(client, deltaSelect, whereClause, params,
 		clickhouse_settings: CH_SETTINGS
 	})).json();
 }
+/**
+* Newest delta cursor whose trace root matches the filters. Without filters
+* every delta row qualifies, so this is the stream head. With filters, the
+* root scan is bounded below by the oldest `startedAt` still in the delta
+* table (a 2-day TTL window) instead of reading all of trace_roots.
+*/
 async function getDeltaCursor$1(client, whereClause, params) {
+	if (!whereClause) return getStreamHeadCursor$1(client);
 	const cursorId = (await (await client.query({
 		query: `
         SELECT toString(max(d.cursorId)) AS cursorId
         FROM mastra_trace_roots_delta d
-        INNER JOIN mastra_trace_roots r
-          ON r.startedAt = d.startedAt
-         AND r.traceId = d.traceId
-         AND r.dedupeKey = d.dedupeKey
-        ${whereClause}
+        WHERE (d.startedAt, d.traceId, d.dedupeKey) IN (
+          SELECT r.startedAt, r.traceId, r.dedupeKey
+          FROM mastra_trace_roots r
+          ${appendWhere(whereClause, `r.startedAt >= (SELECT min(startedAt) FROM mastra_trace_roots_delta)`)}
+        )
       `,
 		query_params: params,
 		format: "JSONEachRow",
 		clickhouse_settings: CH_SETTINGS
 	})).json())[0]?.cursorId ?? null;
 	if (cursorId) return cursorId;
-	return (await (await client.query({
-		query: `SELECT toString(max(cursorId)) AS cursorId FROM mastra_trace_roots_delta`,
-		format: "JSONEachRow",
-		clickhouse_settings: CH_SETTINGS
-	})).json())[0]?.cursorId ?? "0";
+	return getStreamHeadCursor$1(client);
 }
 async function getStreamHeadCursor$1(client) {
 	return (await (await client.query({
@@ -8533,15 +8731,28 @@ async function listBranches(client, args, strategy) {
 	const spans = (await (await client.query({
 		query: `
       SELECT * FROM (
+        -- Deferred join: pick the page's sort keys from a narrow sort, then
+        -- read full rows only for those keys. LIMIT 1 BY disables ClickHouse's
+        -- own lazy materialization, so sorting SELECT * directly would carry
+        -- every matching branch's payload columns through the sort. The filter
+        -- is applied again on the re-read: a dedupeKey can have unmerged
+        -- versions (in different endedAt partitions) and only a matching one
+        -- may win.
         SELECT *
         FROM ${TABLE_TRACE_BRANCHES} b
-        ${whereClause}
-        ORDER BY b.dedupeKey
+        ${appendWhere(whereClause, `(b.spanType, b.startedAt, b.traceId, b.dedupeKey) IN (
+          SELECT b.spanType, b.startedAt, b.traceId, b.dedupeKey
+          FROM ${TABLE_TRACE_BRANCHES} b
+          ${whereClause}
+          ORDER BY b.${sortField} ${sortDirection}, b.dedupeKey ASC
+          LIMIT 1 BY b.dedupeKey
+          LIMIT {limit:UInt32}
+          OFFSET {offset:UInt32}
+        )`)}
+        ORDER BY b.${sortField} ${sortDirection}, b.dedupeKey ASC
         LIMIT 1 BY b.dedupeKey
       )
       ORDER BY ${sortField} ${sortDirection}, dedupeKey ASC
-      LIMIT {limit:UInt32}
-      OFFSET {offset:UInt32}
     `,
 		query_params: {
 			...params,
@@ -8563,6 +8774,7 @@ async function listBranches(client, args, strategy) {
 	};
 }
 async function queryBranchesAfterCursor(client, whereClause, params, limit, cursorId) {
+	const deltaKeys = `SELECT spanType, startedAt, traceId, dedupeKey FROM ${TABLE_TRACE_BRANCHES_DELTA} WHERE cursorId > {afterCursor:UInt64}`;
 	return await (await client.query({
 		query: `
         SELECT
@@ -8573,14 +8785,18 @@ async function queryBranchesAfterCursor(client, whereClause, params, limit, curs
           b.spanId AS spanId,
           b.dedupeKey AS dedupeKey,
           toString(d.cursorId) AS cursorId
-        FROM ${TABLE_TRACE_BRANCHES_DELTA} d
-        INNER JOIN ${TABLE_TRACE_BRANCHES} b
+        FROM ${TABLE_TRACE_BRANCHES} b
+        INNER JOIN (
+          SELECT cursorId, spanType, startedAt, traceId, spanId, dedupeKey
+          FROM ${TABLE_TRACE_BRANCHES_DELTA}
+          WHERE cursorId > {afterCursor:UInt64}
+        ) d
           ON b.spanType = d.spanType
          AND b.startedAt = d.startedAt
          AND b.traceId = d.traceId
          AND b.spanId = d.spanId
          AND b.dedupeKey = d.dedupeKey
-        ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+        ${appendWhere(whereClause, `(b.spanType, b.startedAt, b.traceId, b.dedupeKey) IN (${deltaKeys})`)}
         ORDER BY d.cursorId ASC
         LIMIT {fetchLimit:UInt32}
       `,
@@ -8593,29 +8809,29 @@ async function queryBranchesAfterCursor(client, whereClause, params, limit, curs
 		clickhouse_settings: CH_SETTINGS
 	})).json();
 }
+/**
+* Newest delta cursor whose branch matches the filters. Without filters this
+* is the stream head; with filters, the branch scan is bounded below by the
+* oldest `startedAt` still in the delta table.
+*/
 async function getDeltaCursor(client, whereClause, params) {
+	if (!whereClause) return getStreamHeadCursor(client);
 	const cursorId = (await (await client.query({
 		query: `
         SELECT toString(max(d.cursorId)) AS cursorId
         FROM mastra_trace_branches_delta d
-        INNER JOIN mastra_trace_branches b
-          ON b.spanType = d.spanType
-         AND b.startedAt = d.startedAt
-         AND b.traceId = d.traceId
-         AND b.spanId = d.spanId
-         AND b.dedupeKey = d.dedupeKey
-        ${whereClause}
+        WHERE (d.spanType, d.startedAt, d.traceId, d.spanId, d.dedupeKey) IN (
+          SELECT b.spanType, b.startedAt, b.traceId, b.spanId, b.dedupeKey
+          FROM mastra_trace_branches b
+          ${appendWhere(whereClause, `b.startedAt >= (SELECT min(startedAt) FROM mastra_trace_branches_delta)`)}
+        )
       `,
 		query_params: params,
 		format: "JSONEachRow",
 		clickhouse_settings: CH_SETTINGS
 	})).json())[0]?.cursorId ?? null;
 	if (cursorId) return cursorId;
-	return (await (await client.query({
-		query: `SELECT toString(max(cursorId)) AS cursorId FROM mastra_trace_branches_delta`,
-		format: "JSONEachRow",
-		clickhouse_settings: CH_SETTINGS
-	})).json())[0]?.cursorId ?? "0";
+	return getStreamHeadCursor(client);
 }
 async function getStreamHeadCursor(client) {
 	return (await (await client.query({
@@ -9061,14 +9277,14 @@ var ObservabilityStorageClickhouseVNext = class extends _mastra_core_storage.Obs
 			"tag-discovery",
 			"metric-discovery",
 			"trace-query",
-			...spanQueryFeatures,
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
 			"trace-query-tenant-scope",
 			"feedback",
 			"trace-query-context-ids",
-			"trace-aggregate"
+			"trace-aggregate",
+			...spanQueryFeatures
 		];
 		return [
 			"metrics",
@@ -9081,14 +9297,14 @@ var ObservabilityStorageClickhouseVNext = class extends _mastra_core_storage.Obs
 			"metric-discovery",
 			"delta-polling",
 			"trace-query",
-			...spanQueryFeatures,
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
 			"trace-query-tenant-scope",
 			"feedback",
 			"trace-query-context-ids",
-			"trace-aggregate"
+			"trace-aggregate",
+			...spanQueryFeatures
 		];
 	}
 	async createSpan(args) {
@@ -9781,6 +9997,7 @@ var ScoresStorageClickhouse = class extends _mastra_core_storage.ScoresStorage {
 			tableName: _mastra_core_storage.TABLE_SCORERS,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_SCORERS]
 		});
+		await this.#db.ensureSkipIndexes(_mastra_core_storage.TABLE_SCORERS);
 	}
 	async dangerouslyClearAll() {
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_SCORERS });
@@ -10191,6 +10408,7 @@ var WorkflowsStorageClickhouse = class extends _mastra_core_storage.WorkflowsSto
 			schema,
 			ifNotExists: ["resourceId"]
 		});
+		await this.#db.ensureSkipIndexes(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
 	}
 	async dangerouslyClearAll() {
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT });
@@ -10387,7 +10605,8 @@ var WorkflowsStorageClickhouse = class extends _mastra_core_storage.WorkflowsSto
               ORDER BY createdAt DESC LIMIT 1
             `,
 				query_params: values,
-				format: "JSONEachRow"
+				format: "JSONEachRow",
+				clickhouse_settings: { use_skip_indexes_if_final: 1 }
 			})).json();
 			if (!Array.isArray(resultJson) || resultJson.length === 0) return null;
 			return this.parseWorkflowRun(resultJson[0]);