@morlay/ui-conversation-message-actions 0.0.19-alpha.3 → 0.0.19-alpha.4

package/dist/testing.mjs

@@ -1,9 +1,9 @@
-import { t as SESSION_EDITOR_PATH } from "./shared-LK3nImWW.mjs";
+import { t as SESSION_EDITOR_PATH } from "./shared-BBbOTwy4.mjs";
 import { SessionEditor } from "./index.mjs";
 import { createRequire } from "node:module";
 import { Context, Service } from "@deepseek-ai/cordis";
 import { KNOWN_SESSION_EVENT_TYPES, SESSION_FORMAT_VERSION, Session, Session as Session$1, SessionId, SessionId as SessionIdBrand, SessionLogOffset, SessionSeq, SessionSeq as SessionSeq$1, SessionStore, foldSurface, interruptedTurnClosers, isSurfaceEvent, snapshotSessionEvent } from "@deepseek-ai/dsh-session";
-import { SessionBranch, SessionBranchError, balanceRewindPrefix, buildTimeline, rewindKeepLength } from "@morlay/session-branch";
+import { SessionBranch, SessionBranchError, balanceRewindPrefix, rewindKeepLength } from "@morlay/session-branch";
 import crypto, { createHash, randomUUID } from "node:crypto";
 import { TokenMeter } from "@deepseek-ai/dsh-token-meter";
 import SessionProjectionRegistry from "@deepseek-ai/dsh-session-projection";
@@ -18966,7 +18966,36 @@ const SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
 	"tool/result"
 ]);
 const METERING_EVENT_TYPES = /* @__PURE__ */ new Set(["compaction/summary", "compaction/prune"]);
+/**
+* 升序的 surface 事件 seq 索引：读视图修复里的溯源（replace 的 `sourceEventSeqs` 与
+* metering 的 `shadowedSeqs`）共用这一份，避免每个 replace 各扫一遍全量事件。
+* 前提是输入按 seq 有序（`readLog` 与 live snapshot 都如此）。
+*/
+function surfaceSeqIndex(events) {
+	const seqs = [];
+	for (const event of events) if (SURFACE_EVENT_TYPES.has(event.type)) seqs.push(event.seq);
+	return seqs;
+}
+/** `[startSeq, endSeq]` 内的 surface seq（含端点），二分定位后切片。 */
+function surfaceSeqsInRange(seqs, startSeq, endSeq) {
+	let low = 0;
+	let high = seqs.length;
+	while (low < high) {
+		const mid = low + high >> 1;
+		if (seqs[mid] < startSeq) low = mid + 1;
+		else high = mid;
+	}
+	const from = low;
+	high = seqs.length;
+	while (low < high) {
+		const mid = low + high >> 1;
+		if (seqs[mid] <= endSeq) low = mid + 1;
+		else high = mid;
+	}
+	return seqs.slice(from, low);
+}
 function recomputeReplaceProvenance(events) {
+	const seqs = surfaceSeqIndex(events);
 	for (let i = 0; i < events.length; i++) {
 		const raw = events[i];
 		const op = raw.surfaceOp;
@@ -18978,9 +19007,7 @@ function recomputeReplaceProvenance(events) {
 			raw.sourceEventSeqs = meteringData.shadowedSeqs;
 			continue;
 		}
-		const refs = [];
-		for (const candidate of events) if (candidate.seq >= startSeq && candidate.seq <= endSeq && SURFACE_EVENT_TYPES.has(candidate.type)) refs.push(candidate.seq);
-		raw.sourceEventSeqs = refs;
+		raw.sourceEventSeqs = surfaceSeqsInRange(seqs, startSeq, endSeq);
 	}
 }
 function isEventSeqLike(value) {
@@ -19133,6 +19160,7 @@ function repairRequestHeaders(events) {
 	}
 }
 function syncMeteringRanges(events) {
+	const seqs = surfaceSeqIndex(events);
 	for (let i = 1; i < events.length; i++) {
 		const metering = events[i - 1];
 		if (!METERING_EVENT_TYPES.has(metering.type)) continue;
@@ -19145,7 +19173,7 @@ function syncMeteringRanges(events) {
 			start: startSeq,
 			end: endSeq
 		};
-		data.shadowedSeqs = events.filter((candidate) => candidate.seq >= startSeq && candidate.seq <= endSeq && SURFACE_EVENT_TYPES.has(candidate.type)).map((candidate) => candidate.seq);
+		data.shadowedSeqs = surfaceSeqsInRange(seqs, startSeq, endSeq);
 	}
 }
 const PTC_EVENT_RENAMES = {
@@ -23310,7 +23338,7 @@ const eventUsage = {
 			}
 		},
 		f_created_at: {
-			type: "integer",
+			type: "bigint",
 			notNull: true
 		},
 		f_provider: { type: "text" },
@@ -23676,6 +23704,152 @@ function migrate$1(db, config) {
 	return migrateSync(readMigrationFiles(config), db.session, config);
 }
 //#endregion
+//#region ../session-rdb/src/usage.ts
+const SESSION_USAGE_PATH = "/api/session.usage";
+const DAY_MS = 864e5;
+const ROLLING_DAYS = {
+	"7d": 7,
+	"30d": 30,
+	"90d": 90
+};
+function localDayStart(now) {
+	const start = new Date(now);
+	start.setHours(0, 0, 0, 0);
+	return start;
+}
+/**
+* 范围起点（含），不限时为 undefined。自然日 / 自然周按 host 的本地时区算，周边界是周一 00:00。
+* @param range - 语义键。
+* @param now - 当前时刻。
+* @returns 起点毫秒时间戳，或 undefined。
+*/
+function resolveUsageSince(range, now) {
+	switch (range) {
+		case "all": return;
+		case "day": return localDayStart(now).getTime();
+		case "week": {
+			const start = localDayStart(now);
+			start.setDate(start.getDate() - (start.getDay() + 6) % 7);
+			return start.getTime();
+		}
+		default: return now - ROLLING_DAYS[range] * DAY_MS;
+	}
+}
+function parseUsageRange(value) {
+	return value === "day" || value === "week" || value === "7d" || value === "30d" || value === "90d" ? value : "all";
+}
+/** 计入活动计数的事件类型（轮次 / 步骤 / 用户输入 / 工具调用）。 */
+const COUNTED_EVENT_TYPES = [
+	"turn/start",
+	"step/start",
+	"user/message",
+	"tool/call"
+];
+/** 按事件类型把计数累加到活动指标上（表里按类型存，读的时候折成四项）。 */
+function addActivityCount(target, type, count) {
+	switch (type) {
+		case "turn/start":
+			target.turns += count;
+			return target;
+		case "step/start":
+			target.steps += count;
+			return target;
+		case "user/message":
+			target.userInputs += count;
+			return target;
+		case "tool/call":
+			target.toolCalls += count;
+			return target;
+		default: return target;
+	}
+}
+/** 毫秒时间戳 → host 本地日（`YYYY-MM-DD`，与 SQL 的 localtime 口径一致）。 */
+function localDayKey(ms) {
+	const date = new Date(ms);
+	const pad = (value) => String(value).padStart(2, "0");
+	return `${String(date.getFullYear())}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+function emptyTotals() {
+	return {
+		turns: 0,
+		steps: 0,
+		userInputs: 0,
+		toolCalls: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		reasoningTokens: 0,
+		totalTokens: 0
+	};
+}
+function addTokenTotals(target, row) {
+	target.inputTokens += row.inputTokens;
+	target.outputTokens += row.outputTokens;
+	target.cacheReadTokens += row.cacheReadTokens;
+	target.reasoningTokens += row.reasoningTokens;
+	target.totalTokens += row.totalTokens;
+	return target;
+}
+function addActivityTotals(target, row) {
+	target.turns += row.turns;
+	target.steps += row.steps;
+	target.userInputs += row.userInputs;
+	target.toolCalls += row.toolCalls;
+	return target;
+}
+/** 把一行的整套指标累加进目标（后端合并「是否子代理」两组时用）。 */
+function addTotals(target, row) {
+	addActivityTotals(target, row);
+	addTokenTotals(target, row);
+	return target;
+}
+/**
+* 用量统计通道：一次请求回报总览（含 subagent 拆分）、按天 × 模型的桶与按会话的行。
+* 聚合只算被会话引用的事件行——fork 共享行因此只计一次，已删会话留下的孤儿行不计。
+*/
+function registerSessionUsage(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_USAGE_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					res.writeHead(405, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "method not allowed" }));
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				const raw = Buffer.concat(chunks).toString("utf8");
+				let envelope = {};
+				if (raw !== "") try {
+					envelope = JSON.parse(raw);
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				try {
+					const report = await persistence.usageReport(resolveUsageSince(parseUsageRange(envelope.range), Date.now()));
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify(report));
+				} catch (error) {
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "usage report failed" }));
+				}
+			}
+		}), `session-rdb: ${SESSION_USAGE_PATH} route`);
+	});
+}
+//#endregion
 //#region ../session-rdb/src/storage-takeover/repository.ts
 async function allRows(query) {
 	const q = query;
@@ -23926,6 +24100,32 @@ function createStorageRepository(host) {
 }
 //#endregion
 //#region ../session-rdb/src/sqlite.ts
+/** 活动计数的派生表：可销毁重建（不在 drizzle schema / 迁移里，建表幂等）。 */
+function ensureEventCountsTable(db) {
+	db.exec(`CREATE TABLE IF NOT EXISTS t_event_counts (
+      f_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      f_session_id TEXT NOT NULL,
+      f_day TEXT NOT NULL,
+      f_type TEXT NOT NULL,
+      f_count INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS uq_event_counts_session_day_type
+      ON t_event_counts(f_session_id, f_day, f_type);
+    CREATE INDEX IF NOT EXISTS idx_event_counts_day ON t_event_counts(f_day);`);
+}
+/** 一次性回填活动计数（表为空时从事件表重算；幂等）。 */
+function backfillEventCounts(db) {
+	if (db.prepare("SELECT count(*) AS n FROM t_event_counts").get().n > 0) return;
+	db.exec(`INSERT OR IGNORE INTO t_event_counts (f_session_id, f_day, f_type, f_count)
+    SELECT b.f_session_id,
+           date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
+           e.f_type,
+           count(*)
+      FROM t_session_events b
+      JOIN t_events e ON e.f_event_id = b.f_event_id
+     WHERE e.f_type IN (${COUNTED_EVENT_TYPE_SQL$1})
+     GROUP BY 1, 2, 3`);
+}
 /**
 * 一次性回填：旧库的用量从未写过 `t_event_usage`，建表后按事件行补一次（幂等：表非空即跳过）。
 */
@@ -23955,9 +24155,8 @@ function backfillEventUsage(db) {
             OR json_extract(e.f_data, '$.usage') IS NOT NULL)`);
 }
 /** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
-function totalsOf(row) {
+function tokenTotalsOf$1(row) {
 	return {
-		events: row.events,
 		inputTokens: row.input_tokens ?? 0,
 		outputTokens: row.output_tokens ?? 0,
 		cacheReadTokens: row.cache_read_tokens ?? 0,
@@ -23965,6 +24164,26 @@ function totalsOf(row) {
 		totalTokens: row.total_tokens ?? 0
 	};
 }
+/** 一行的整套指标：token 用量 + 活动计数（轮次 / 步骤 / 用户输入 / 工具调用）。 */
+function emptyActivity$1() {
+	return {
+		turns: 0,
+		steps: 0,
+		userInputs: 0,
+		toolCalls: 0
+	};
+}
+/** 有 token 用量的会话：活动计数与列表都限定在这一批会话里，口径一致。 */
+function hasUsageSession(column) {
+	return `EXISTS (SELECT 1 FROM t_session_events ub
+                    JOIN t_event_usage uu ON uu.f_event_id = ub.f_event_id
+                   WHERE ub.f_session_id = ${column})`;
+}
+const SUBAGENT_OF_EVENT = `EXISTS (SELECT 1 FROM t_session_events sb
+                                     JOIN t_sessions ss ON ss.f_session_id = sb.f_session_id
+                                    WHERE sb.f_event_id = %EVENT% AND ss.f_origin = 'subagent')`;
+/** `IN (...)` 用的类型字面量（与 `COUNTED_EVENT_TYPES` 同源）。 */
+const COUNTED_EVENT_TYPE_SQL$1 = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
 const sqliteMigrationsDir = fileURLToPath(new URL("../drizzle/sqlite/", import.meta.url));
 const sqliteTxQueues = /* @__PURE__ */ new Map();
 function enqueueSqliteTx(path, fn) {
@@ -23987,6 +24206,8 @@ async function openDatabase(path, journalMode, busyTimeout = DEFAULT_BUSY_TIMEOU
 		const { user_version: onDisk } = db.prepare("PRAGMA user_version").get();
 		if (onDisk === 2 && !hasMigrationsTable(db)) await baselineV2(db);
 		migrate$1(dbx, { migrationsFolder: sqliteMigrationsDir });
+		ensureEventCountsTable(db);
+		backfillEventCounts(db);
 		backfillEventUsage(db);
 		dbx.insert(tPersistenceState).values({
 			fSingleton: 1,
@@ -24127,10 +24348,13 @@ var SqliteBackend = class SqliteBackend {
 		return (fromSequence === void 0 ? this.eventRows().where(eq(tSessionEvents.fSessionId, id)) : this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence)))).orderBy(tSessionEvents.fSequence).all();
 	}
 	async getEventTypeAt(id, sequence) {
-		return this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get()?.fType;
+		return this.db.select({ fType: tEvents.fType }).from(tSessionEvents).innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId)).where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get()?.fType;
 	}
 	async getEventTypesBefore(id, beforeSequence, limit) {
-		return this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), lt(tSessionEvents.fSequence, beforeSequence))).orderBy(desc(tSessionEvents.fSequence)).limit(limit).all();
+		return this.db.select({
+			fSequence: tSessionEvents.fSequence,
+			fType: tEvents.fType
+		}).from(tSessionEvents).innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId)).where(and(eq(tSessionEvents.fSessionId, id), lt(tSessionEvents.fSequence, beforeSequence))).orderBy(desc(tSessionEvents.fSequence)).limit(limit).all();
 	}
 	async listSessions() {
 		return this.db.select().from(tSessions).all();
@@ -24258,30 +24482,49 @@ var SqliteBackend = class SqliteBackend {
 		const info = this.db.delete(tSessions).where(inArray(tSessions.fSessionId, ids)).run();
 		return Number(info.changes);
 	}
-	/** 用量聚合：只读 `t_event_usage`；可选只算 `sinceMs` 之后的事件行。 */
+	/**
+	* 用量聚合：token 用量沿 `t_event_usage` 的用量行，活动计数（轮次 / 步骤 / 用户输入 / 工具调用）
+	* 沿 `t_events` 的事件类型数——两者限定在**有 token 用量的会话**里，时间范围各自按自己的
+	* `f_created_at`（同一时刻写入，口径一致）。
+	*/
 	async usageReport(sinceMs) {
-		const sinceClause = sinceMs === void 0 ? "" : " AND u.f_created_at >= ?";
-		const sinceParams = sinceMs === void 0 ? [] : [sinceMs];
+		const usageSince = sinceMs === void 0 ? "" : " AND u.f_created_at >= ?";
+		const params = sinceMs === void 0 ? [] : [sinceMs];
+		const daySince = sinceMs === void 0 ? "" : " AND c.f_day >= ?";
+		const dayParams = sinceMs === void 0 ? [] : [localDayKey(sinceMs)];
+		const subagentOfUsage = SUBAGENT_OF_EVENT.replace("%EVENT%", "u.f_event_id");
 		const buckets = this.db.$client.prepare(`SELECT date(u.f_created_at / 1000, 'unixepoch', 'localtime') AS day,
                 u.f_provider AS provider,
                 u.f_model AS model,
-                EXISTS (SELECT 1 FROM t_session_events sb
-                          JOIN t_sessions ss ON ss.f_session_id = sb.f_session_id
-                         WHERE sb.f_event_id = u.f_event_id AND ss.f_origin = 'subagent') AS subagent,
-                count(*) AS events,
+                ${subagentOfUsage} AS subagent,
+                sum(u.f_input_tokens) AS input_tokens,
+                sum(u.f_output_tokens) AS output_tokens,
+                sum(u.f_cache_read_tokens) AS cache_read_tokens,
+                sum(u.f_reasoning_tokens) AS reasoning_tokens,
+                sum(u.f_total_tokens) AS total_tokens
+           FROM t_event_usage u
+          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${usageSince}
+          GROUP BY day, provider, model, subagent`).all(...params);
+		const tokenScope = this.db.$client.prepare(`SELECT ${subagentOfUsage} AS subagent,
                 sum(u.f_input_tokens) AS input_tokens,
                 sum(u.f_output_tokens) AS output_tokens,
                 sum(u.f_cache_read_tokens) AS cache_read_tokens,
                 sum(u.f_reasoning_tokens) AS reasoning_tokens,
                 sum(u.f_total_tokens) AS total_tokens
            FROM t_event_usage u
-          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${sinceClause}
-          GROUP BY day, provider, model, subagent`).all(...sinceParams);
-		const sessions = this.db.$client.prepare(`SELECT b.f_session_id AS session_id,
+          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${usageSince}
+          GROUP BY subagent`).all(...params);
+		const activityScope = this.db.$client.prepare(`SELECT (s.f_origin = 'subagent') AS subagent,
+                c.f_type AS f_type,
+                sum(c.f_count) AS n
+           FROM t_event_counts c
+           JOIN t_sessions s ON s.f_session_id = c.f_session_id
+          WHERE ${hasUsageSession("c.f_session_id")}${daySince}
+          GROUP BY subagent, c.f_type`).all(...dayParams);
+		const tokenSessions = this.db.$client.prepare(`SELECT b.f_session_id AS session_id,
                 s.f_title AS title,
                 (s.f_origin = 'subagent') AS subagent,
                 (s.f_archived_at IS NOT NULL) AS archived,
-                count(*) AS events,
                 sum(u.f_input_tokens) AS input_tokens,
                 sum(u.f_output_tokens) AS output_tokens,
                 sum(u.f_cache_read_tokens) AS cache_read_tokens,
@@ -24290,25 +24533,69 @@ var SqliteBackend = class SqliteBackend {
            FROM t_session_events b
            JOIN t_event_usage u ON u.f_event_id = b.f_event_id
            JOIN t_sessions s ON s.f_session_id = b.f_session_id
-          WHERE 1 = 1${sinceClause}
-          GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at`).all(...sinceParams);
+          WHERE 1 = 1${usageSince}
+          GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at`).all(...params);
+		const activitySessions = this.db.$client.prepare(`SELECT c.f_session_id AS session_id,
+                c.f_type AS f_type,
+                sum(c.f_count) AS n
+           FROM t_event_counts c
+          WHERE ${hasUsageSession("c.f_session_id")}${daySince}
+          GROUP BY c.f_session_id, c.f_type`).all(...dayParams);
+		const human = emptyTotals();
+		const subagent = emptyTotals();
+		for (const row of tokenScope) addTokenTotals(row.subagent === 1 ? subagent : human, tokenTotalsOf$1(row));
+		for (const row of activityScope) addActivityCount(row.subagent === 1 ? subagent : human, row.f_type, row.n ?? 0);
+		const totals = addTotals(addTotals(emptyTotals(), human), subagent);
+		const activityBySession = /* @__PURE__ */ new Map();
+		for (const row of activitySessions) {
+			const target = activityBySession.get(row.session_id) ?? emptyActivity$1();
+			addActivityCount(target, row.f_type, row.n ?? 0);
+			activityBySession.set(row.session_id, target);
+		}
 		return {
+			totals,
+			subagent,
+			human,
 			buckets: buckets.map((row) => ({
 				day: row.day,
 				provider: row.provider,
 				model: row.model,
 				subagent: row.subagent === 1,
-				...totalsOf(row)
+				...tokenTotalsOf$1(row)
 			})),
-			sessions: sessions.map((row) => ({
+			sessions: tokenSessions.map((row) => ({
 				sessionId: row.session_id,
 				title: row.title,
 				subagent: row.subagent === 1,
 				archived: row.archived === 1,
-				...totalsOf(row)
+				...tokenTotalsOf$1(row),
+				...activityBySession.get(row.session_id) ?? emptyActivity$1()
 			}))
 		};
 	}
+	/** 活动计数旁路累加：派生表 `t_event_counts`，不在写事务里（失败可丢，表可销毁重建）。 */
+	async incrementEventCounts(id, buckets) {
+		if (buckets.length === 0) return;
+		const statement = this.db.$client.prepare(`INSERT INTO t_event_counts (f_session_id, f_day, f_type, f_count) VALUES (?, ?, ?, ?)
+       ON CONFLICT(f_session_id, f_day, f_type) DO UPDATE SET f_count = f_count + excluded.f_count`);
+		for (const bucket of buckets) statement.run(id, bucket.day, bucket.type, bucket.count);
+	}
+	/** 按会话重算活动计数（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
+	async rebuildEventCounts(id) {
+		this.db.$client.prepare("DELETE FROM t_event_counts WHERE f_session_id = ?").run(id);
+		this.db.$client.prepare(`INSERT INTO t_event_counts (f_session_id, f_day, f_type, f_count)
+         SELECT b.f_session_id,
+                date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
+                e.f_type,
+                count(*)
+           FROM t_session_events b
+           JOIN t_events e ON e.f_event_id = b.f_event_id
+          WHERE b.f_session_id = ? AND e.f_type IN (${COUNTED_EVENT_TYPE_SQL$1})
+          GROUP BY 1, 2, 3`).run(id);
+	}
+	async deleteEventCounts(id) {
+		this.db.$client.prepare("DELETE FROM t_event_counts WHERE f_session_id = ?").run(id);
+	}
 	async vacuum() {
 		await enqueueSqliteTx(this.dbPath, async () => {
 			this.db.$client.exec("VACUUM");
@@ -24337,6 +24624,13 @@ async function migrate(db, config) {
 //#endregion
 //#region ../session-rdb/src/postgres.ts
 const postgresMigrationsDir = fileURLToPath(new URL("../drizzle/postgres/", import.meta.url));
+const pgWriteQueues = /* @__PURE__ */ new Map();
+/** 按介质（连接串 + schema）串行化写事务，与 SQLite 侧的 `enqueueSqliteTx` 同形。 */
+function enqueuePgWrite(key, fn) {
+	const run = (pgWriteQueues.get(key) ?? Promise.resolve()).then(fn);
+	pgWriteQueues.set(key, run.then(() => void 0, () => void 0));
+	return run;
+}
 /** pg 的 text 列窄化：非字符串（含 null）都不当作文本。 */
 function text(value) {
 	return typeof value === "string" ? value : null;
@@ -24347,9 +24641,8 @@ function numeric(value) {
 	return Number.isFinite(parsed) ? parsed : 0;
 }
 /** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
-function totalsOfRow(row) {
+function tokenTotalsOf(row) {
 	return {
-		events: numeric(row["events"]),
 		inputTokens: numeric(row["input_tokens"]),
 		outputTokens: numeric(row["output_tokens"]),
 		cacheReadTokens: numeric(row["cache_read_tokens"]),
@@ -24357,6 +24650,16 @@ function totalsOfRow(row) {
 		totalTokens: numeric(row["total_tokens"])
 	};
 }
+function emptyActivity() {
+	return {
+		turns: 0,
+		steps: 0,
+		userInputs: 0,
+		toolCalls: 0
+	};
+}
+/** `IN (...)` 用的类型字面量（与 `COUNTED_EVENT_TYPES` 同源）。 */
+const COUNTED_EVENT_TYPE_SQL = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
 var PostgresBackend = class PostgresBackend {
 	db;
 	options;
@@ -24377,9 +24680,10 @@ var PostgresBackend = class PostgresBackend {
 			this.rejectOpened = reject;
 		});
 		this.opened.catch(() => {});
+		const writeQueueKey = options.identityBase;
 		this.storage = createStorageRepository({
 			db: () => this.opened.then(() => this.txOverride ?? this.db),
-			writeAtomically: (fn) => this.db.transaction(async (tx) => {
+			writeAtomically: (fn) => enqueuePgWrite(writeQueueKey, () => this.db.transaction(async (tx) => {
 				const previous = this.txOverride;
 				this.txOverride = tx;
 				try {
@@ -24387,7 +24691,7 @@ var PostgresBackend = class PostgresBackend {
 				} finally {
 					this.txOverride = previous;
 				}
-			}, { isolationLevel: "serializable" }),
+			}, { isolationLevel: "serializable" })),
 			tables: this.tables
 		});
 	}
@@ -24407,6 +24711,8 @@ var PostgresBackend = class PostgresBackend {
 			if (await this.readMeta(this.db, "schema_version") === "2") await this.baselineV2();
 		}
 		await migrate(this.db, { migrationsFolder: postgresMigrationsDir });
+		await this.ensureEventCountsTable();
+		await this.backfillEventCounts();
 		await this.backfillEventUsage();
 		const storeId = await this.db.transaction(async (tx) => {
 			await tx.insert(this.tables["t_persistence_state"]).values({
@@ -24447,11 +24753,14 @@ var PostgresBackend = class PostgresBackend {
 	}
 	async getEventTypeAt(id, sequence) {
 		const table = this.tables["t_session_events"];
-		return (await this.eventRows(this.db).where(and(eq(table.fSessionId, id), eq(table.fSequence, sequence))).limit(1).execute())[0]?.fType;
+		return (await this.db.select({ fType: this.tables["t_events"].fType }).from(table).innerJoin(this.tables["t_events"], eq(table.fEventId, this.tables["t_events"].fEventId)).where(and(eq(table.fSessionId, id), eq(table.fSequence, sequence))).limit(1).execute())[0]?.fType;
 	}
 	async getEventTypesBefore(id, beforeSequence, limit) {
 		const table = this.tables["t_session_events"];
-		return await this.eventRows(this.db).where(and(eq(table.fSessionId, id), lt(table.fSequence, beforeSequence))).orderBy(desc(table.fSequence)).limit(limit).execute();
+		return await this.db.select({
+			fSequence: table.fSequence,
+			fType: this.tables["t_events"].fType
+		}).from(table).innerJoin(this.tables["t_events"], eq(table.fEventId, this.tables["t_events"].fEventId)).where(and(eq(table.fSessionId, id), lt(table.fSequence, beforeSequence))).orderBy(desc(table.fSequence)).limit(limit).execute();
 	}
 	async listSessions() {
 		return this.db.select().from(this.tables["t_sessions"]).execute();
@@ -24609,61 +24918,176 @@ var PostgresBackend = class PostgresBackend {
 	}
 	/** 用量聚合：与 SQLite 侧同形，读 `t_event_usage`，数值列回来是字符串。 */
 	async usageReport(sinceMs) {
-		const sinceClause = sinceMs === void 0 ? sql`` : sql` AND u.f_created_at >= ${sinceMs}`;
+		const usageSince = sinceMs === void 0 ? sql`` : sql` AND u.f_created_at >= ${sinceMs}`;
+		const daySince = sinceMs === void 0 ? sql`` : sql` AND c.f_day >= ${localDayKey(sinceMs)}`;
 		const tEventUsage = this.tables["t_event_usage"];
 		const tSessionEvents = this.tables["t_session_events"];
 		const tSessions = this.tables["t_sessions"];
+		const eventCountsTable = this.qualifiedTable("t_event_counts");
+		const subagentOfUsage = sql`EXISTS (SELECT 1 FROM ${tSessionEvents} sb
+                                            JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
+                                           WHERE sb.f_event_id = u.f_event_id AND ss.f_origin = 'subagent')`;
+		const subagentOfCounts = sql`EXISTS (SELECT 1 FROM ${tSessionEvents} sb
+                                            JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
+                                           WHERE sb.f_session_id = c.f_session_id AND ss.f_origin = 'subagent')`;
+		const hasUsageSession = (column) => sql`EXISTS (SELECT 1 FROM ${tSessionEvents} ub
+                                           JOIN ${tEventUsage} uu ON uu.f_event_id = ub.f_event_id
+                                          WHERE ub.f_session_id = ${sql.raw(column)})`;
+		const tokenColumns = sql.raw(`sum(u.f_input_tokens) AS input_tokens,
+                sum(u.f_output_tokens) AS output_tokens,
+                sum(u.f_cache_read_tokens) AS cache_read_tokens,
+                sum(u.f_reasoning_tokens) AS reasoning_tokens,
+                sum(u.f_total_tokens) AS total_tokens`);
 		const buckets = await this.db.execute(sql`
       SELECT to_char(to_timestamp(u.f_created_at / 1000.0), 'YYYY-MM-DD') AS day,
              u.f_provider AS provider,
              u.f_model AS model,
-             EXISTS (SELECT 1 FROM ${tSessionEvents} sb
-                       JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
-                      WHERE sb.f_event_id = u.f_event_id AND ss.f_origin = 'subagent') AS subagent,
-             count(*) AS events,
-             sum(u.f_input_tokens) AS input_tokens,
-             sum(u.f_output_tokens) AS output_tokens,
-             sum(u.f_cache_read_tokens) AS cache_read_tokens,
-             sum(u.f_reasoning_tokens) AS reasoning_tokens,
-             sum(u.f_total_tokens) AS total_tokens
+             ${subagentOfUsage} AS subagent,
+             ${tokenColumns}
         FROM ${tEventUsage} u
-       WHERE EXISTS (SELECT 1 FROM ${tSessionEvents} rb WHERE rb.f_event_id = u.f_event_id)${sinceClause}
+       WHERE EXISTS (SELECT 1 FROM ${tSessionEvents} rb WHERE rb.f_event_id = u.f_event_id)${usageSince}
        GROUP BY 1, 2, 3, 4
     `);
-		const sessions = await this.db.execute(sql`
+		const tokenScope = await this.db.execute(sql`
+      SELECT ${subagentOfUsage} AS subagent,
+             ${tokenColumns}
+        FROM ${tEventUsage} u
+       WHERE EXISTS (SELECT 1 FROM ${tSessionEvents} rb WHERE rb.f_event_id = u.f_event_id)${usageSince}
+       GROUP BY 1
+    `);
+		const activityScope = await this.db.execute(sql`
+      SELECT ${subagentOfCounts} AS subagent,
+             c.f_type AS f_type,
+             sum(c.f_count) AS n
+        FROM ${sql.raw(eventCountsTable)} c
+        JOIN ${tSessions} s ON s.f_session_id = c.f_session_id
+       WHERE ${hasUsageSession("c.f_session_id")}${daySince}
+       GROUP BY 1, 2
+    `);
+		const tokenSessions = await this.db.execute(sql`
       SELECT b.f_session_id AS session_id,
              s.f_title AS title,
              (s.f_origin = 'subagent') AS subagent,
              (s.f_archived_at IS NOT NULL) AS archived,
-             count(*) AS events,
-             sum(u.f_input_tokens) AS input_tokens,
-             sum(u.f_output_tokens) AS output_tokens,
-             sum(u.f_cache_read_tokens) AS cache_read_tokens,
-             sum(u.f_reasoning_tokens) AS reasoning_tokens,
-             sum(u.f_total_tokens) AS total_tokens
+             ${tokenColumns}
         FROM ${tSessionEvents} b
         JOIN ${tEventUsage} u ON u.f_event_id = b.f_event_id
         JOIN ${tSessions} s ON s.f_session_id = b.f_session_id
-       WHERE 1 = 1${sinceClause}
+       WHERE 1 = 1${usageSince}
        GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at
     `);
+		const activitySessions = await this.db.execute(sql`
+      SELECT c.f_session_id AS session_id,
+             c.f_type AS f_type,
+             sum(c.f_count) AS n
+        FROM ${sql.raw(eventCountsTable)} c
+       WHERE ${hasUsageSession("c.f_session_id")}${daySince}
+       GROUP BY c.f_session_id, c.f_type
+    `);
+		const human = emptyTotals();
+		const subagent = emptyTotals();
+		for (const row of tokenScope.rows) addTokenTotals(row["subagent"] === true ? subagent : human, tokenTotalsOf(row));
+		for (const row of activityScope.rows) addActivityCount(row["subagent"] === true ? subagent : human, String(row["f_type"]), numeric(row["n"]));
+		const totals = addTotals(addTotals(emptyTotals(), human), subagent);
+		const activityBySession = /* @__PURE__ */ new Map();
+		for (const row of activitySessions.rows) {
+			const key = String(row["session_id"]);
+			const target = activityBySession.get(key) ?? emptyActivity();
+			addActivityCount(target, String(row["f_type"]), numeric(row["n"]));
+			activityBySession.set(key, target);
+		}
 		return {
+			totals,
+			subagent,
+			human,
 			buckets: buckets.rows.map((row) => ({
 				day: String(row["day"]),
 				provider: text(row["provider"]),
 				model: text(row["model"]),
 				subagent: row["subagent"] === true,
-				...totalsOfRow(row)
+				...tokenTotalsOf(row)
 			})),
-			sessions: sessions.rows.map((row) => ({
+			sessions: tokenSessions.rows.map((row) => ({
 				sessionId: String(row["session_id"]),
 				title: text(row["title"]),
 				subagent: row["subagent"] === true,
 				archived: row["archived"] === true,
-				...totalsOfRow(row)
+				...tokenTotalsOf(row),
+				...activityBySession.get(String(row["session_id"])) ?? emptyActivity()
 			}))
 		};
 	}
+	/** 表名限定到配置的 schema（派生表不进 drizzle schema / 迁移，建表幂等）。 */
+	qualifiedTable(name) {
+		const schema = this.options.schema ?? "public";
+		return schema === "public" ? name : `"${schema}".${name}`;
+	}
+	async ensureEventCountsTable() {
+		const table = this.qualifiedTable("t_event_counts");
+		await this.db.execute(sql.raw(`CREATE TABLE IF NOT EXISTS ${table} (
+        f_id serial PRIMARY KEY,
+        f_session_id text NOT NULL,
+        f_day text NOT NULL,
+        f_type text NOT NULL,
+        f_count integer NOT NULL DEFAULT 0
+      )`));
+		await this.db.execute(sql.raw(`CREATE UNIQUE INDEX IF NOT EXISTS uq_event_counts_session_day_type ON ${table}(f_session_id, f_day, f_type)`));
+		await this.db.execute(sql.raw(`CREATE INDEX IF NOT EXISTS idx_event_counts_day ON ${table}(f_day)`));
+	}
+	/** 一次性回填活动计数（表为空时从事件表重算；幂等）。 */
+	async backfillEventCounts() {
+		const table = this.qualifiedTable("t_event_counts");
+		const existing = await this.db.execute(sql.raw(`SELECT count(*) AS n FROM ${table}`));
+		if (Number(existing.rows[0]?.["n"] ?? 0) > 0) return;
+		const tSessionEvents = this.tables["t_session_events"];
+		const tEvents = this.tables["t_events"];
+		await this.db.execute(sql`
+      INSERT INTO ${sql.raw(table)} (f_session_id, f_day, f_type, f_count)
+      SELECT ${tSessionEvents}.f_session_id,
+             to_char(to_timestamp(${tEvents}.f_created_at / 1000.0), 'YYYY-MM-DD'),
+             ${tEvents}.f_type,
+             count(*)
+        FROM ${tSessionEvents}
+        JOIN ${tEvents} ON ${tEvents}.f_event_id = ${tSessionEvents}.f_event_id
+       WHERE ${tEvents}.f_type IN (${sql.raw(COUNTED_EVENT_TYPE_SQL)})
+       GROUP BY 1, 2, 3
+      ON CONFLICT DO NOTHING
+    `);
+	}
+	/** 活动计数旁路累加：派生表，不在写事务里（失败可丢，表可销毁重建）。 */
+	async incrementEventCounts(id, buckets) {
+		if (buckets.length === 0) return;
+		const table = this.qualifiedTable("t_event_counts");
+		for (const bucket of buckets) await this.db.execute(sql`
+        INSERT INTO ${sql.raw(table)} (f_session_id, f_day, f_type, f_count)
+        VALUES (${id}, ${bucket.day}, ${bucket.type}, ${bucket.count})
+        ON CONFLICT (f_session_id, f_day, f_type)
+          DO UPDATE SET f_count = ${sql.raw(`${table}.f_count`)} + EXCLUDED.f_count
+      `);
+	}
+	/** 按会话重算活动计数（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
+	async rebuildEventCounts(id) {
+		const table = this.qualifiedTable("t_event_counts");
+		const tSessionEvents = this.tables["t_session_events"];
+		const tEvents = this.tables["t_events"];
+		await this.db.execute(sql`DELETE FROM ${sql.raw(table)} WHERE f_session_id = ${id}`);
+		await this.db.execute(sql`
+      INSERT INTO ${sql.raw(table)} (f_session_id, f_day, f_type, f_count)
+      SELECT ${tSessionEvents}.f_session_id,
+             to_char(to_timestamp(${tEvents}.f_created_at / 1000.0), 'YYYY-MM-DD'),
+             ${tEvents}.f_type,
+             count(*)
+        FROM ${tSessionEvents}
+        JOIN ${tEvents} ON ${tEvents}.f_event_id = ${tSessionEvents}.f_event_id
+       WHERE ${tSessionEvents}.f_session_id = ${id}
+         AND ${tEvents}.f_type IN (${sql.raw(COUNTED_EVENT_TYPE_SQL)})
+       GROUP BY 1, 2, 3
+    `);
+	}
+	async deleteEventCounts(id) {
+		const table = this.qualifiedTable("t_event_counts");
+		await this.db.execute(sql`DELETE FROM ${sql.raw(table)} WHERE f_session_id = ${id}`);
+	}
 	async getPrevBridge(exec, id, sequence) {
 		return (await exec.select({
 			fEventId: this.tables["t_session_events"].fEventId,
@@ -24884,6 +25308,7 @@ var SessionBranchRdbProvider = class {
 		} finally {
 			await handle.close();
 		}
+		await this.persistence.rebuildEventCounts(childId);
 		return childId;
 	}
 	async rewind(id, toBoundary, signal) {
@@ -24956,6 +25381,7 @@ var SessionBranchRdbProvider = class {
 			headSeq: keepLength - 1,
 			snapshotEvents: () => []
 		});
+		await this.persistence.rebuildEventCounts(id);
 		return {
 			header: rowToMeta(row),
 			revision: await internals.readStoredRevision(id)
@@ -25058,16 +25484,6 @@ var SessionBranchRdb = class extends SessionBranch {
 	rewind(id, toBoundary, signal) {
 		return this.provider.rewind(id, toBoundary, signal);
 	}
-	async timeline(sessionId, signal) {
-		const persistence = this.ctx.sessionPersistence;
-		const snapshots = await persistence.listSnapshots(signal);
-		const readOwnEvents = async (id, fromSeq, s) => {
-			const live = this.ctx.sessions.get(id);
-			if (live !== void 0) return live.snapshotEvents().slice(fromSeq);
-			return (await persistence.internals().readFrom(id, fromSeq, s)).events;
-		};
-		return buildTimeline(snapshots, readOwnEvents, sessionId, signal);
-	}
 };
 //#endregion
 //#region ../../../node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/index.mjs
@@ -26632,118 +27048,6 @@ function registerSessionGc(ctx, persistence) {
 	});
 }
 //#endregion
-//#region ../session-rdb/src/usage.ts
-const SESSION_USAGE_PATH = "/api/session.usage";
-const DAY_MS = 864e5;
-const ROLLING_DAYS = {
-	"7d": 7,
-	"30d": 30,
-	"90d": 90
-};
-function localDayStart(now) {
-	const start = new Date(now);
-	start.setHours(0, 0, 0, 0);
-	return start;
-}
-/**
-* 范围起点（含），不限时为 undefined。自然日 / 自然周按 host 的本地时区算，周边界是周一 00:00。
-* @param range - 语义键。
-* @param now - 当前时刻。
-* @returns 起点毫秒时间戳，或 undefined。
-*/
-function resolveUsageSince(range, now) {
-	switch (range) {
-		case "all": return;
-		case "day": return localDayStart(now).getTime();
-		case "week": {
-			const start = localDayStart(now);
-			start.setDate(start.getDate() - (start.getDay() + 6) % 7);
-			return start.getTime();
-		}
-		default: return now - ROLLING_DAYS[range] * DAY_MS;
-	}
-}
-function parseUsageRange(value) {
-	return value === "day" || value === "week" || value === "7d" || value === "30d" || value === "90d" ? value : "all";
-}
-function emptyTotals() {
-	return {
-		events: 0,
-		inputTokens: 0,
-		outputTokens: 0,
-		cacheReadTokens: 0,
-		reasoningTokens: 0,
-		totalTokens: 0
-	};
-}
-/** 折叠一组行（桶或会话行）的用量。 */
-function sumUsage(rows) {
-	const totals = emptyTotals();
-	for (const row of rows) {
-		totals.events += row.events;
-		totals.inputTokens += row.inputTokens;
-		totals.outputTokens += row.outputTokens;
-		totals.cacheReadTokens += row.cacheReadTokens;
-		totals.reasoningTokens += row.reasoningTokens;
-		totals.totalTokens += row.totalTokens;
-	}
-	return totals;
-}
-/**
-* 用量统计通道：一次请求回报总览（含 subagent 拆分）、按天 × 模型的桶与按会话的行。
-* 聚合只算被会话引用的事件行——fork 共享行因此只计一次，已删会话留下的孤儿行不计。
-*/
-function registerSessionUsage(ctx, persistence) {
-	ctx.inject(["webServer", "connection"], (webCtx) => {
-		const webServer = webCtx.webServer;
-		const connection = webCtx.get("connection");
-		return webCtx.effect(() => webServer.register({
-			kind: "exact",
-			path: SESSION_USAGE_PATH,
-			handler: async (req, res) => {
-				const rejection = connection.requestRejection(req);
-				if (rejection !== void 0) {
-					res.writeHead(rejection);
-					res.end(rejection === 401 ? "unauthorized" : "forbidden");
-					return;
-				}
-				if (req.method !== "POST") {
-					res.writeHead(405, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "method not allowed" }));
-					return;
-				}
-				const chunks = [];
-				for await (const chunk of req) chunks.push(chunk);
-				const raw = Buffer.concat(chunks).toString("utf8");
-				let envelope = {};
-				if (raw !== "") try {
-					envelope = JSON.parse(raw);
-				} catch {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "request body is not JSON" }));
-					return;
-				}
-				try {
-					const aggregate = await persistence.usageReport(resolveUsageSince(parseUsageRange(envelope.range), Date.now()));
-					const totals = sumUsage(aggregate.buckets);
-					const subagent = sumUsage(aggregate.buckets.filter((bucket) => bucket.subagent));
-					const human = sumUsage(aggregate.buckets.filter((bucket) => !bucket.subagent));
-					res.writeHead(200, { "content-type": "application/json" });
-					res.end(JSON.stringify({
-						totals,
-						subagent,
-						human,
-						...aggregate
-					}));
-				} catch (error) {
-					res.writeHead(500, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "usage report failed" }));
-				}
-			}
-		}), `session-rdb: ${SESSION_USAGE_PATH} route`);
-	});
-}
-//#endregion
 //#region ../../../vendor/deepseek-harness/packages/session/session-format-catalog/lib/types/message-projections.js
 /** Pure first-party message interpreters for detached current-format replay, including browser readers. */
 /** Installed interpretation definitions; recovery listeners are mounted separately by their owning plugins. */
@@ -34512,7 +34816,10 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		});
 		this.liveBuffers.delete(id);
 		this.liveReady.delete(id);
+		this.liveFailures.delete(id);
+		this.liveDropWarned.delete(id);
 		this.reuseEventIds.delete(id);
+		await this.deleteEventCounts(id);
 	}
 	/** GC 通道：回收已无桥接行引用的事件行（孤儿），返回删除行数。 */
 	async collectOrphans() {
@@ -34528,7 +34835,10 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		for (const id of deletable) {
 			this.liveBuffers.delete(id);
 			this.liveReady.delete(id);
+			this.liveFailures.delete(id);
+			this.liveDropWarned.delete(id);
 			this.reuseEventIds.delete(id);
+			await this.deleteEventCounts(id);
 		}
 		return deleted;
 	}
@@ -34606,6 +34916,7 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		});
 		this.writeGuard.confirmHead(meta.id, confirmedHead);
 		this.tracker.materialized(meta.id);
+		await this.recordEventCounts(meta.id, events);
 		return true;
 	}
 	async readLog(id, options = {}, signal) {
@@ -34654,6 +34965,35 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 			...tornFrom !== void 0 ? { tornFrom } : {}
 		};
 	}
+	/**
+	* 活动计数**旁路累加**：不在写事务里、失败只 warn——`t_event_counts` 是可销毁重建的派生表，
+	* 丢几次累加不影响可用性（需要时用 `rebuildEventCounts` 重算）。
+	*/
+	async recordEventCounts(id, events) {
+		const buckets = eventCountBuckets(events);
+		if (buckets.length === 0) return;
+		try {
+			await this.backend.incrementEventCounts(id, buckets);
+		} catch (error) {
+			this.ctx.logger.warn(`session-rdb: activity counts for "${id}" not updated (${describeError(error)})`);
+		}
+	}
+	/** 重算一个会话的活动计数（rewind / fork 之后；best-effort，同 `recordEventCounts`）。 */
+	async rebuildEventCounts(id) {
+		try {
+			await this.backend.rebuildEventCounts(id);
+		} catch (error) {
+			this.ctx.logger.warn(`session-rdb: activity counts for "${id}" not rebuilt (${describeError(error)})`);
+		}
+	}
+	/** 会话删除时清掉它的活动计数行（best-effort）。 */
+	async deleteEventCounts(id) {
+		try {
+			await this.backend.deleteEventCounts(id);
+		} catch (error) {
+			this.ctx.logger.warn(`session-rdb: activity counts for "${id}" not deleted (${describeError(error)})`);
+		}
+	}
 	async rewriteMigratedLog(id, log) {
 		await this.backend.transaction(async (tx) => {
 			await tx.deleteBridgeTail(id, 0);
@@ -34712,24 +35052,26 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		}
 	}
 	async load(id, signal) {
-		const handle = await this.open(id, "read", signal === void 0 ? void 0 : { signal });
-		try {
-			const { events } = await handle.read(0, void 0, signal === void 0 ? void 0 : { signal });
-			const row = await this.backend.getSession(id);
-			if (row === void 0) throw new SessionPersistenceNotFoundError(id);
-			if (isLegacyVersion(row.fVersion)) return {
-				meta: handle.header,
-				inheritedEventCount: handle.inheritedEventCount,
-				events
-			};
-			return {
-				meta: rowToMeta(row),
-				inheritedEventCount: SessionLogOffset(row.fSeedLength ?? 0),
-				events
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const log = await this.readLog(id, {}, signal);
+		if (log === void 0) {
+			const pending = this.tracker.pendingOf(id);
+			if (pending !== void 0) return {
+				meta: pending.header,
+				inheritedEventCount: SessionLogOffset(pending.inheritedEventCount),
+				events: []
 			};
-		} finally {
-			await handle.close();
+			throw new SessionPersistenceNotFoundError(id);
 		}
+		repairReadView(log.events);
+		validateStoredEvents(log.meta, log.events);
+		return {
+			meta: log.meta,
+			inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
+			events: log.events
+		};
 	}
 	async append(id, events) {
 		const handle = await this.open(id, "write");
@@ -34772,22 +35114,28 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 	rowRevision(row) {
 		return SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`);
 	}
+	liveFailures = /* @__PURE__ */ new Map();
+	liveDropWarned = /* @__PURE__ */ new Set();
+	watchLiveReady(ctx, session, ready) {
+		ready.catch((error) => {
+			const failure = error instanceof Error ? error : new Error(typeof error === "string" ? error : `live session "${session.id}" persistence failed`);
+			this.liveFailures.set(session.id, failure);
+			this.liveBuffers.delete(session.id);
+			ctx.logger.error(`session-rdb: live session "${session.id}" persistence unavailable (${failure.message}); its events will not be persisted`);
+		});
+	}
 	installLiveRouting(ctx) {
 		ctx.on("session/created", (session) => {
 			this.liveBuffers.set(session.id, []);
 			const ready = this.ensureLiveHandle(session);
 			this.liveReady.set(session.id, ready);
-			ready.catch((error) => {
-				ctx.logger.warn(`session-rdb: live session "${session.id}" persistence init failed: ${String(error)}`);
-			});
+			this.watchLiveReady(ctx, session, ready);
 		});
 		for (const session of ctx.sessions.list()) {
 			this.liveBuffers.set(session.id, []);
 			const ready = this.ensureLiveHandle(session);
 			this.liveReady.set(session.id, ready);
-			ready.catch((error) => {
-				ctx.logger.warn(`session-rdb: live session "${session.id}" persistence init failed: ${String(error)}`);
-			});
+			this.watchLiveReady(ctx, session, ready);
 		}
 		ctx.on("session/event", (session, event) => {
 			const handle = this.tracker.writerOf(session.id);
@@ -34797,9 +35145,18 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 				});
 				return;
 			}
+			if (this.liveFailures.has(session.id)) {
+				if (!this.liveDropWarned.has(session.id)) {
+					this.liveDropWarned.add(session.id);
+					ctx.logger.warn(`session-rdb: dropping events for live session "${session.id}" because persistence failed earlier`);
+				}
+				return;
+			}
 			this.liveBuffers.get(session.id)?.push(structuredClone(event));
 		});
 		ctx.on("session/flush", (session) => {
+			const failure = this.liveFailures.get(session.id);
+			if (failure !== void 0) return Promise.reject(failure);
 			const handle = this.tracker.writerOf(session.id);
 			if (handle === void 0) {
 				const ready = this.liveReady.get(session.id);
@@ -34816,6 +35173,8 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 			const ready = this.liveReady.get(session.id);
 			this.liveBuffers.delete(session.id);
 			this.liveReady.delete(session.id);
+			this.liveFailures.delete(session.id);
+			this.liveDropWarned.delete(session.id);
 			const closeHandle = () => {
 				const handle = this.tracker.writerOf(session.id);
 				if (handle === void 0) return;
@@ -34831,6 +35190,10 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		});
 		ctx.effect(() => async () => {
 			await Promise.allSettled(this.liveReady.values());
+			this.liveBuffers.clear();
+			this.liveReady.clear();
+			this.liveFailures.clear();
+			this.liveDropWarned.clear();
 			await this.tracker.closeAll();
 			await this.close();
 		}, `${this.name} open handles`);
@@ -34869,6 +35232,26 @@ function seedCoversPrefix(seed, prefix) {
 		return seedEvent !== void 0 && JSON.stringify(seedEvent) === JSON.stringify(event);
 	});
 }
+/** 一批事件折成活动计数的桶：只数四种类型，按本地日聚合。 */
+function eventCountBuckets(events) {
+	const counted = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (!COUNTED_EVENT_TYPES.includes(event.type)) continue;
+		const day = localDayKey(event.time);
+		const key = `${day}#${event.type}`;
+		const bucket = counted.get(key) ?? {
+			day,
+			type: event.type,
+			count: 0
+		};
+		bucket.count += 1;
+		counted.set(key, bucket);
+	}
+	return [...counted.values()];
+}
+function describeError(error) {
+	return error instanceof Error ? error.message : "unknown error";
+}
 function createBackend(config) {
 	if (config.type === "sqlite") return new SqliteBackend({
 		path: config.path,