@morlay/session-rdb 0.0.21-alpha.3 → 0.0.21-alpha.4

package/dist/{src-CWTWV7vx.mjs → src-Bn0038Sp.mjs}

@@ -1,6 +1,6 @@
-import { C as WriteGuard, S as toPostgresSchema, a as EVENT_ENCODING, c as eventDimensions, i as DEFAULT_BUSY_TIMEOUT_MS, r as createStorageRepository, t as SqliteBackend, x as postgresTableDefs } from "./sqlite-fpvm5Dzs.mjs";
-import { _ as toJsonlArtifact, d as rowToMeta, f as scanRows, g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow, s as repairReadView, v as usageRowOf } from "./log-CnYct2Dv.mjs";
-import { c as isLegacyVersion, o as adoptLegacyRows, s as convertLegacyRows, t as SessionBranchRdb } from "./branch-5JzX9rUq.mjs";
+import { A as WriteGuard, O as postgresTableDefs, a as addActivityCount, c as emptyTotals, d as DEFAULT_BUSY_TIMEOUT_MS, f as EVENT_ENCODING, h as eventDimensions, i as COUNTED_EVENT_TYPES, k as toPostgresSchema, l as localDayKey, o as addTokenTotals, r as createStorageRepository, s as addTotals, t as SqliteBackend, u as registerSessionUsage } from "./sqlite-C3LHLzYW.mjs";
+import { _ as toJsonlArtifact, d as rowToMeta, f as scanRows, g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow, s as repairReadView, v as usageRowOf } from "./log-C-rbdFwK.mjs";
+import { c as isLegacyVersion, o as adoptLegacyRows, s as convertLegacyRows, t as SessionBranchRdb } from "./branch-Dlmbkfjj.mjs";
 import { registerSessionImport } from "./import.mjs";
 import z from "@deepseek-ai/schemastery";
 import { randomUUID } from "node:crypto";
@@ -20,6 +20,13 @@ import { StorageError, storageBackendServiceKey } from "@deepseek-ai/dsh-storage
 import { Service } from "@deepseek-ai/cordis";
 //#region 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;
@@ -30,9 +37,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"]),
@@ -40,6 +46,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;
@@ -60,9 +76,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 {
@@ -70,7 +87,7 @@ var PostgresBackend = class PostgresBackend {
 				} finally {
 					this.txOverride = previous;
 				}
-			}, { isolationLevel: "serializable" }),
+			}, { isolationLevel: "serializable" })),
 			tables: this.tables
 		});
 	}
@@ -90,6 +107,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({
@@ -130,11 +149,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();
@@ -292,61 +314,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,
@@ -556,118 +693,6 @@ function registerSessionGc(ctx, persistence) {
 	});
 }
 //#endregion
-//#region 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 src/session-query.ts
 var SessionQueryRdb = class extends SessionQueryEngine {
 	constructor(ctx, config = {}) {
@@ -1478,7 +1503,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() {
@@ -1494,7 +1522,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;
 	}
@@ -1572,6 +1603,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) {
@@ -1620,6 +1652,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);
@@ -1678,24 +1739,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");
@@ -1738,22 +1801,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);
@@ -1763,9 +1832,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);
@@ -1782,6 +1860,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;
@@ -1797,6 +1877,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`);
@@ -1835,6 +1919,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,

package/dist/storage.d.mts

@@ -1,4 +1,4 @@
-import { A as tSessionProjcacheRows, C as eventDimensions, D as tPersistenceState, E as tEvents, F as tWorkspaces, I as WriteGuard, L as StorageRepository, M as tStorageUnits, N as tWorkspaceSessions, O as tSchemaMeta, P as tWorkspaceState, S as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, T as tEventUsage, _ as EVENT_ENCODING, a as UsageAggregate, b as JournalMode, g as DEFAULT_BUSY_TIMEOUT_MS, i as SessionRow, j as tSessions, k as tSessionEvents, n as BackendTx, r as EventRow, t as Backend, v as EventKind, w as eventKind, x as SCHEMA_VERSION, y as EventRole } from "./backend-DpdtxYpz.mjs";
+import { A as tSessionEvents, C as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, D as tEvents, E as tEventUsage, F as tWorkspaceState, I as tWorkspaces, L as WriteGuard, M as tSessions, N as tStorageUnits, O as tPersistenceState, P as tWorkspaceSessions, R as StorageRepository, S as SCHEMA_VERSION, T as eventKind, _ as DEFAULT_BUSY_TIMEOUT_MS, a as SessionRow, b as EventRole, i as EventRow, j as tSessionProjcacheRows, k as tSchemaMeta, n as BackendTx, o as UsageAggregate, r as EventCountBucket, t as Backend, v as EVENT_ENCODING, w as eventDimensions, x as JournalMode, y as EventKind } from "./backend-a0xDrUFG.mjs";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { DatabaseSync } from "node:sqlite";
 //#region src/sqlite.d.ts
@@ -47,8 +47,17 @@ declare class SqliteBackend implements Backend {
   /** 父会话被删后留下的 subagent 会话：父已不在表里，或本来就没有父。 */
   listOrphanSubagentSessions(): Promise<SessionId[]>;
   private deleteSessions;
-  /** 用量聚合：只读 `t_event_usage`；可选只算 `sinceMs` 之后的事件行。 */
+  /**
+   * 用量聚合：token 用量沿 `t_event_usage` 的用量行，活动计数（轮次 / 步骤 / 用户输入 / 工具调用）
+   * 沿 `t_events` 的事件类型数——两者限定在**有 token 用量的会话**里，时间范围各自按自己的
+   * `f_created_at`（同一时刻写入，口径一致）。
+   */
   usageReport(sinceMs?: number): Promise<UsageAggregate>;
+  /** 活动计数旁路累加：派生表 `t_event_counts`，不在写事务里（失败可丢，表可销毁重建）。 */
+  incrementEventCounts(id: SessionId, buckets: readonly EventCountBucket[]): Promise<void>;
+  /** 按会话重算活动计数（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
+  rebuildEventCounts(id: SessionId): Promise<void>;
+  deleteEventCounts(id: SessionId): Promise<void>;
   vacuum(): Promise<void>;
   private eventRows;
 }

package/dist/storage.mjs

@@ -1,2 +1,2 @@
-import { C as WriteGuard, _ as tStorageUnits, a as EVENT_ENCODING, b as tWorkspaces, c as eventDimensions, d as tEvents, f as tPersistenceState, g as tSessions, h as tSessionProjcacheRows, i as DEFAULT_BUSY_TIMEOUT_MS, l as eventKind, m as tSessionEvents, n as openDatabase, o as SCHEMA_VERSION, p as tSchemaMeta, s as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, t as SqliteBackend, u as tEventUsage, v as tWorkspaceSessions, y as tWorkspaceState } from "./sqlite-fpvm5Dzs.mjs";
+import { A as WriteGuard, C as tSessions, D as tWorkspaces, E as tWorkspaceState, S as tSessionProjcacheRows, T as tWorkspaceSessions, _ as tEventUsage, b as tSchemaMeta, d as DEFAULT_BUSY_TIMEOUT_MS, f as EVENT_ENCODING, g as eventKind, h as eventDimensions, m as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, n as openDatabase, p as SCHEMA_VERSION, t as SqliteBackend, v as tEvents, w as tStorageUnits, x as tSessionEvents, y as tPersistenceState } from "./sqlite-C3LHLzYW.mjs";
 export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, SqliteBackend, WriteGuard, eventDimensions, eventKind, openDatabase, tEventUsage, tEvents, tPersistenceState, tSchemaMeta, tSessionEvents, tSessionProjcacheRows, tSessions, tStorageUnits, tWorkspaceSessions, tWorkspaceState, tWorkspaces };

package/dist/testing.d.mts

@@ -1,4 +1,4 @@
-import { h as truncateLiveSession } from "./backend-DpdtxYpz.mjs";
+import { g as truncateLiveSession } from "./backend-a0xDrUFG.mjs";
 import { SessionPersistence } from "@deepseek-ai/dsh-session-persistence";
 import { Session, SessionEvent, SessionHeader, SessionId } from "@deepseek-ai/dsh-session";
 import { Context, Fiber } from "@deepseek-ai/cordis";