@morlay/session-rdb 0.0.21-alpha.7 → 0.0.21-alpha.8

package/dist/{src-B9X8BKyh.mjs → src-BWqePRA7.mjs}

@@ -1,6 +1,6 @@
-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-zcXVyMxr.mjs";
-import { _ as sessionInsertRow, b as toJsonlArtifact, g as sessionConflictRow, h as scanRows, m as rowToMeta, r as hasLegacyShape, u as repairReadView, x as usageRowOf, y as titleOfEventData } from "./log-qCNkDjh5.mjs";
-import { c as isLegacyVersion, o as adoptLegacyRows, s as convertLegacyRows, t as SessionBranchRdb } from "./branch-BjUR6wfe.mjs";
+import { C as postgresTableDefs, T as WriteGuard, a as EVENT_ENCODING, c as eventDimensions, i as DEFAULT_BUSY_TIMEOUT_MS, r as createStorageRepository, t as SqliteBackend, w as toPostgresSchema } from "./sqlite-ChM_sHAG.mjs";
+import { A as registerSessionUsage, C as COUNTED_EVENT_TYPES, D as addTotals, E as addTokenTotals, O as emptyTotals, S as usageRowOf, T as addActivityTotals, _ as sessionConflictRow, b as titleOfEventData, g as sealOwnEvents, h as scanRows, k as localDayKey, m as rowToMeta, r as needsShapeAdoption, u as repairReadView, v as sessionInsertRow, w as addActivityCount, x as toJsonlArtifact } from "./log-DTcvsMz7.mjs";
+import { c as isLegacyVersion, o as adoptLegacyRows, s as convertLegacyRows, t as SessionBranchRdb } from "./branch-7eOh_tbO.mjs";
 import { registerSessionImport } from "./import.mjs";
 import z from "@deepseek-ai/schemastery";
 import { randomUUID } from "node:crypto";
@@ -54,6 +54,15 @@ function emptyActivity() {
 		toolCalls: 0
 	};
 }
+/** `t_session_counts` 的四项计数折成活动计数（pg 的 sum 回落成字符串）。 */
+function activityTotalsOf(row) {
+	return {
+		turns: numeric(row["turns"]),
+		steps: numeric(row["steps"]),
+		userInputs: numeric(row["user_inputs"]),
+		toolCalls: numeric(row["tool_calls"])
+	};
+}
 /** `IN (...)` 用的类型字面量（与 `COUNTED_EVENT_TYPES` 同源）。 */
 const COUNTED_EVENT_TYPE_SQL = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
 var PostgresBackend = class PostgresBackend {
@@ -107,9 +116,7 @@ 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();
+		await this.backfillUsageTables();
 		const storeId = await this.db.transaction(async (tx) => {
 			await tx.insert(this.tables["t_persistence_state"]).values({
 				fSingleton: 1,
@@ -170,7 +177,7 @@ var PostgresBackend = class PostgresBackend {
 			getHead: (id) => this.getHead(tx, id),
 			getSeedLength: (id) => this.getSeedLength(tx, id),
 			updateSeedLength: (id, seedLength) => this.updateSeedLength(tx, id, seedLength),
-			insertEvents: (events) => this.insertEvents(tx, events),
+			insertEvents: (events, usageRows) => this.insertEvents(tx, events, usageRows),
 			insertBridges: (rows) => this.insertBridges(tx, rows),
 			updateHead: (id, headEventId, headSequence) => this.updateHead(tx, id, headEventId, headSequence),
 			bumpRevision: (id, lastEventAt) => this.bumpRevision(tx, id, lastEventAt),
@@ -207,14 +214,10 @@ var PostgresBackend = class PostgresBackend {
 		await exec.update(this.tables["t_sessions"]).set({ fSeedLength: seedLength }).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
 	}
 	static INSERT_BATCH_ROWS = 1e3;
-	async insertEvents(exec, events) {
+	async insertEvents(exec, events, usageRows) {
 		if (events.length === 0) return;
 		for (let i = 0; i < events.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_events"]).values(events.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((event) => ({ ...event }))).execute();
-		const usage = events.flatMap((event) => {
-			const row = usageRowOf(event);
-			return row === void 0 ? [] : [row];
-		});
-		if (usage.length > 0) await exec.insert(this.tables["t_event_usage"]).values(usage).onConflictDoNothing().execute();
+		if (usageRows.length > 0) for (let i = 0; i < usageRows.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_event_usage"]).values(usageRows.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((row) => ({ ...row }))).onConflictDoNothing().execute();
 	}
 	async insertBridges(exec, rows) {
 		if (rows.length === 0) return;
@@ -284,21 +287,41 @@ var PostgresBackend = class PostgresBackend {
 	async vacuum() {
 		await this.db.execute(sql`VACUUM ANALYZE`);
 	}
-	/** 一次性回填：旧库没写过 `t_event_usage`，建表后按事件行补一次（表非空即跳过）。 */
+	/** 派生统计表的回填：任一表为空即按事件表全量重算（幂等，迁移删表重建后自愈）。 */
+	async backfillUsageTables() {
+		await this.backfillEventUsage();
+		await this.backfillSessionUsage();
+		await this.backfillSessionCounts();
+	}
+	async tableIsEmpty(table) {
+		const existing = await this.db.execute(sql.raw(`SELECT count(*) AS n FROM ${table}`));
+		return Number(existing.rows[0]?.["n"] ?? 0) === 0;
+	}
+	/**
+	* 用量行：一条 `assistant/message` 事件行一行，物化本地日与两个归属标记。
+	* 本地日按数据库会话时区渲染（部署前提是它与 host 时区一致，`localDayKey` 同口径）。
+	*/
 	async backfillEventUsage() {
+		if (!await this.tableIsEmpty(this.qualifiedTable("t_event_usage"))) return;
 		const tEventUsage = this.tables["t_event_usage"];
 		const tEvents = this.tables["t_events"];
-		const existing = await this.db.execute(sql`SELECT count(*) AS n FROM ${tEventUsage}`);
-		if (Number(existing.rows[0]?.["n"] ?? 0) > 0) return;
+		const tSessionEvents = this.tables["t_session_events"];
+		const tSessions = this.tables["t_sessions"];
 		await this.db.execute(sql`
       INSERT INTO ${tEventUsage} (
-        f_event_id, f_created_at, f_provider, f_model,
+        f_event_id, f_created_at, f_day, f_provider, f_model, f_referenced, f_subagent,
         f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
       SELECT e.f_event_id, e.f_created_at,
+             to_char(to_timestamp(e.f_created_at / 1000.0), 'YYYY-MM-DD'),
              coalesce(e.f_data::json #>> '{data,message,source,provider}',
                       e.f_data::json #>> '{message,source,provider}'),
              coalesce(e.f_data::json #>> '{data,message,source,model}',
                       e.f_data::json #>> '{message,source,model}'),
+             (EXISTS (SELECT 1 FROM ${tSessionEvents} rb
+                       WHERE rb.f_event_id = e.f_event_id))::int,
+             (EXISTS (SELECT 1 FROM ${tSessionEvents} sb
+                        JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
+                       WHERE sb.f_event_id = e.f_event_id AND ss.f_origin = 'subagent'))::int,
              coalesce((e.f_data::json #>> '{data,usage,inputTokens}')::integer,
                       (e.f_data::json #>> '{usage,inputTokens}')::integer, 0),
              coalesce((e.f_data::json #>> '{data,usage,outputTokens}')::integer,
@@ -314,6 +337,47 @@ var PostgresBackend = class PostgresBackend {
          AND (e.f_data::json #> '{data,usage}' IS NOT NULL
               OR e.f_data::json #> '{usage}' IS NOT NULL)
       ON CONFLICT DO NOTHING
+    `);
+	}
+	/** 会话 × 本地日 × 模型的 token 汇总：从桥接行 × 用量行重算（含 fork 继承前缀）。 */
+	async backfillSessionUsage() {
+		if (!await this.tableIsEmpty(this.qualifiedTable("t_session_usage"))) return;
+		const tSessionUsage = this.tables["t_session_usage"];
+		const tSessionEvents = this.tables["t_session_events"];
+		const tEventUsage = this.tables["t_event_usage"];
+		await this.db.execute(sql`
+      INSERT INTO ${tSessionUsage} (
+        f_session_id, f_day, f_provider, f_model,
+        f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
+      SELECT b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, ''),
+             sum(u.f_input_tokens), sum(u.f_output_tokens), sum(u.f_cache_read_tokens),
+             sum(u.f_reasoning_tokens), sum(u.f_total_tokens)
+        FROM ${tSessionEvents} b
+        JOIN ${tEventUsage} u ON u.f_event_id = b.f_event_id
+       GROUP BY 1, 2, 3, 4
+      ON CONFLICT DO NOTHING
+    `);
+	}
+	/** 会话 × 本地日的活动计数：从桥接行 × 事件类型重算。 */
+	async backfillSessionCounts() {
+		if (!await this.tableIsEmpty(this.qualifiedTable("t_session_counts"))) return;
+		const tSessionCounts = this.tables["t_session_counts"];
+		const tSessionEvents = this.tables["t_session_events"];
+		const tEvents = this.tables["t_events"];
+		await this.db.execute(sql`
+      INSERT INTO ${tSessionCounts} (
+        f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
+      SELECT b.f_session_id,
+             to_char(to_timestamp(e.f_created_at / 1000.0), 'YYYY-MM-DD'),
+             sum(CASE WHEN e.f_type = 'turn/start' THEN 1 ELSE 0 END),
+             sum(CASE WHEN e.f_type = 'step/start' THEN 1 ELSE 0 END),
+             sum(CASE WHEN e.f_type = 'user/message' THEN 1 ELSE 0 END),
+             sum(CASE WHEN e.f_type = 'tool/call' THEN 1 ELSE 0 END)
+        FROM ${tSessionEvents} b
+        JOIN ${tEvents} e ON e.f_event_id = b.f_event_id
+       WHERE e.f_type IN (${sql.raw(COUNTED_EVENT_TYPE_SQL)})
+       GROUP BY 1, 2
+      ON CONFLICT DO NOTHING
     `);
 	}
 	/** 用量聚合：与 SQLite 侧同形，读 `t_event_usage`，数值列回来是字符串。 */
@@ -366,85 +430,78 @@ var PostgresBackend = class PostgresBackend {
 			total: numeric(counted.rows[0]?.["n"] ?? 0)
 		};
 	}
+	/**
+	* 用量聚合：与 SQLite 侧同形——只读三张派生统计表（用量行给去重口径的总量与「天 × 模型」桶，
+	* 两张会话汇总表给按会话的行），数值列回来是字符串。物化列让这里不做 `EXISTS`、不回连事件表。
+	*/
 	async usageReport(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 usageSince = sinceMs === void 0 ? sql`` : sql` AND f_created_at >= ${sinceMs}`;
+		const dayFilter = (column) => sinceMs === void 0 ? sql`` : sql` AND ${sql.raw(column)} >= ${localDayKey(sinceMs)}`;
 		const tEventUsage = this.tables["t_event_usage"];
-		const tSessionEvents = this.tables["t_session_events"];
+		const tSessionUsage = this.tables["t_session_usage"];
+		const tSessionCounts = this.tables["t_session_counts"];
 		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 tokenColumns = (alias) => sql.raw(`sum(${alias}.f_input_tokens) AS input_tokens,
+                sum(${alias}.f_output_tokens) AS output_tokens,
+                sum(${alias}.f_cache_read_tokens) AS cache_read_tokens,
+                sum(${alias}.f_reasoning_tokens) AS reasoning_tokens,
+                sum(${alias}.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,
-             ${subagentOfUsage} AS subagent,
-             ${tokenColumns}
-        FROM ${tEventUsage} u
-       WHERE EXISTS (SELECT 1 FROM ${tSessionEvents} rb WHERE rb.f_event_id = u.f_event_id)${usageSince}
+      SELECT a.f_day AS day,
+             a.f_provider AS provider,
+             a.f_model AS model,
+             (a.f_subagent = 1) AS subagent,
+             ${tokenColumns("a")}
+        FROM ${tEventUsage} a
+       WHERE a.f_referenced = 1${usageSince}
        GROUP BY 1, 2, 3, 4
     `);
 		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}
+      SELECT (a.f_subagent = 1) AS subagent,
+             ${tokenColumns("a")}
+        FROM ${tEventUsage} a
+       WHERE a.f_referenced = 1${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
+      SELECT (s.f_origin = 'subagent') AS subagent,
+             sum(c.f_turns) AS turns,
+             sum(c.f_steps) AS steps,
+             sum(c.f_user_inputs) AS user_inputs,
+             sum(c.f_tool_calls) AS tool_calls
+        FROM ${tSessionCounts} c
         JOIN ${tSessions} s ON s.f_session_id = c.f_session_id
-       WHERE ${hasUsageSession("c.f_session_id")}${daySince}
-       GROUP BY 1, 2
+       WHERE EXISTS (SELECT 1 FROM ${tSessionUsage} ub WHERE ub.f_session_id = c.f_session_id)${dayFilter("c.f_day")}
+       GROUP BY 1
     `);
 		const tokenSessions = await this.db.execute(sql`
-      SELECT b.f_session_id AS session_id,
+      SELECT u.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,
-             ${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${usageSince}
-       GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at
+             ${tokenColumns("u")}
+        FROM ${tSessionUsage} u
+        JOIN ${tSessions} s ON s.f_session_id = u.f_session_id
+       WHERE 1 = 1${dayFilter("u.f_day")}
+       GROUP BY u.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
+             sum(c.f_turns) AS turns,
+             sum(c.f_steps) AS steps,
+             sum(c.f_user_inputs) AS user_inputs,
+             sum(c.f_tool_calls) AS tool_calls
+        FROM ${tSessionCounts} c
+       WHERE 1 = 1${dayFilter("c.f_day")}
+       GROUP BY c.f_session_id
     `);
 		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"]));
+		for (const row of activityScope.rows) addActivityTotals(row["subagent"] === true ? subagent : human, activityTotalsOf(row));
 		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);
-		}
+		for (const row of activitySessions.rows) activityBySession.set(String(row["session_id"]), activityTotalsOf(row));
 		return {
 			totals,
 			subagent,
@@ -466,76 +523,100 @@ var PostgresBackend = class PostgresBackend {
 			}))
 		};
 	}
-	/** 表名限定到配置的 schema（派生表不进 drizzle schema / 迁移，建表幂等）。 */
+	/** 表名限定到配置的 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
-    `);
+	/** token 用量旁路累加：派生表 `t_session_usage`，不在写事务里（失败可丢，表可销毁重建）。 */
+	async incrementSessionUsage(id, buckets) {
+		if (buckets.length === 0) return;
+		const tSessionUsage = this.tables["t_session_usage"];
+		for (const bucket of buckets) await this.db.execute(sql`
+        INSERT INTO ${tSessionUsage} (
+          f_session_id, f_day, f_provider, f_model,
+          f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
+        VALUES (${id}, ${bucket.day}, ${bucket.provider ?? ""}, ${bucket.model ?? ""},
+                ${bucket.inputTokens}, ${bucket.outputTokens}, ${bucket.cacheReadTokens},
+                ${bucket.reasoningTokens}, ${bucket.totalTokens})
+        ON CONFLICT (f_session_id, f_day, f_provider, f_model) DO UPDATE SET
+          f_input_tokens = ${tSessionUsage}.f_input_tokens + EXCLUDED.f_input_tokens,
+          f_output_tokens = ${tSessionUsage}.f_output_tokens + EXCLUDED.f_output_tokens,
+          f_cache_read_tokens = ${tSessionUsage}.f_cache_read_tokens + EXCLUDED.f_cache_read_tokens,
+          f_reasoning_tokens = ${tSessionUsage}.f_reasoning_tokens + EXCLUDED.f_reasoning_tokens,
+          f_total_tokens = ${tSessionUsage}.f_total_tokens + EXCLUDED.f_total_tokens
+      `);
 	}
-	/** 活动计数旁路累加：派生表，不在写事务里（失败可丢，表可销毁重建）。 */
-	async incrementEventCounts(id, buckets) {
+	/** 活动计数旁路累加：派生表 `t_session_counts`，同上（四项计数一次落）。 */
+	async incrementSessionCounts(id, buckets) {
 		if (buckets.length === 0) return;
-		const table = this.qualifiedTable("t_event_counts");
+		const tSessionCounts = this.tables["t_session_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
+        INSERT INTO ${tSessionCounts} (
+          f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
+        VALUES (${id}, ${bucket.day}, ${bucket.turns}, ${bucket.steps},
+                ${bucket.userInputs}, ${bucket.toolCalls})
+        ON CONFLICT (f_session_id, f_day) DO UPDATE SET
+          f_turns = ${tSessionCounts}.f_turns + EXCLUDED.f_turns,
+          f_steps = ${tSessionCounts}.f_steps + EXCLUDED.f_steps,
+          f_user_inputs = ${tSessionCounts}.f_user_inputs + EXCLUDED.f_user_inputs,
+          f_tool_calls = ${tSessionCounts}.f_tool_calls + EXCLUDED.f_tool_calls
       `);
 	}
-	/** 按会话重算活动计数（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
-	async rebuildEventCounts(id) {
-		const table = this.qualifiedTable("t_event_counts");
+	/** 按会话重算两张汇总表（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
+	async rebuildSessionStats(id) {
+		const tSessionUsage = this.tables["t_session_usage"];
+		const tSessionCounts = this.tables["t_session_counts"];
 		const tSessionEvents = this.tables["t_session_events"];
+		const tEventUsage = this.tables["t_event_usage"];
 		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`DELETE FROM ${tSessionUsage} 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
+      INSERT INTO ${tSessionUsage} (
+        f_session_id, f_day, f_provider, f_model,
+        f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
+      SELECT b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, ''),
+             sum(u.f_input_tokens), sum(u.f_output_tokens), sum(u.f_cache_read_tokens),
+             sum(u.f_reasoning_tokens), sum(u.f_total_tokens)
+        FROM ${tSessionEvents} b
+        JOIN ${tEventUsage} u ON u.f_event_id = b.f_event_id
+       WHERE b.f_session_id = ${id}
+       GROUP BY 1, 2, 3, 4
+    `);
+		await this.db.execute(sql`DELETE FROM ${tSessionCounts} WHERE f_session_id = ${id}`);
+		await this.db.execute(sql`
+      INSERT INTO ${tSessionCounts} (
+        f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
+      SELECT b.f_session_id,
+             to_char(to_timestamp(e.f_created_at / 1000.0), 'YYYY-MM-DD'),
+             sum(CASE WHEN e.f_type = 'turn/start' THEN 1 ELSE 0 END),
+             sum(CASE WHEN e.f_type = 'step/start' THEN 1 ELSE 0 END),
+             sum(CASE WHEN e.f_type = 'user/message' THEN 1 ELSE 0 END),
+             sum(CASE WHEN e.f_type = 'tool/call' THEN 1 ELSE 0 END)
+        FROM ${tSessionEvents} b
+        JOIN ${tEvents} e ON e.f_event_id = b.f_event_id
+       WHERE b.f_session_id = ${id} AND e.f_type IN (${sql.raw(COUNTED_EVENT_TYPE_SQL)})
+       GROUP BY 1, 2
     `);
 	}
-	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}`);
+	/** 全量重算用量行的引用标记（rewind / fork / 会话删除之后）。 */
+	async refreshEventUsageFlags() {
+		const tEventUsage = this.tables["t_event_usage"];
+		const tSessionEvents = this.tables["t_session_events"];
+		const tSessions = this.tables["t_sessions"];
+		await this.db.execute(sql`
+      UPDATE ${tEventUsage} SET
+        f_referenced = (EXISTS (SELECT 1 FROM ${tSessionEvents} rb
+                                 WHERE rb.f_event_id = ${tEventUsage}.f_event_id))::int,
+        f_subagent = (EXISTS (SELECT 1 FROM ${tSessionEvents} sb
+                                JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
+                               WHERE sb.f_event_id = ${tEventUsage}.f_event_id
+                                 AND ss.f_origin = 'subagent'))::int
+    `);
+	}
+	async deleteSessionStats(id) {
+		await this.db.execute(sql`DELETE FROM ${this.tables["t_session_usage"]} WHERE f_session_id = ${id}`);
+		await this.db.execute(sql`DELETE FROM ${this.tables["t_session_counts"]} WHERE f_session_id = ${id}`);
 	}
 	async getPrevBridge(exec, id, sequence) {
 		return (await exec.select({
@@ -1657,7 +1738,7 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 		this.liveFailures.delete(id);
 		this.liveDropWarned.delete(id);
 		this.reuseEventIds.delete(id);
-		await this.deleteEventCounts(id);
+		await this.dropSessionStats(id);
 	}
 	/** GC 通道：回收已无桥接行引用的事件行（孤儿），返回删除行数。 */
 	async collectOrphans() {
@@ -1676,7 +1757,7 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 			this.liveFailures.delete(id);
 			this.liveDropWarned.delete(id);
 			this.reuseEventIds.delete(id);
-			await this.deleteEventCounts(id);
+			await this.dropSessionStats(id);
 		}
 		return deleted;
 	}
@@ -1727,9 +1808,11 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 	async appendBatch(meta, inheritedEventCount, events, tornTruncateTo) {
 		await this.ready;
 		if (events.length === 0) return false;
+		sealOwnEvents(events);
 		validateStoredEvents(meta, [...events]);
 		const reuse = this.reuseEventIds.get(meta.id);
 		let confirmedHead = -1;
+		let usageRows = [];
 		await this.backend.transaction(async (tx) => {
 			if (tornTruncateTo !== void 0) {
 				await tx.deleteBridgeTail(meta.id, tornTruncateTo);
@@ -1743,18 +1826,19 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 			}, randomUUID());
 			const head = await tx.getHead(meta.id);
 			this.writeGuard.assertNoConcurrentWriter(meta.id, head.fHeadSequence);
-			const { headEventId, headSequence } = await appendEventTail(tx, meta, events, {
+			const appended = await appendEventTail(tx, meta, events, {
 				parentId: head.fHeadEventId,
 				nextSeq: head.fHeadSequence + 1
 			}, reuse);
-			await tx.updateHead(meta.id, headEventId, headSequence);
+			usageRows = appended.usageRows;
+			await tx.updateHead(meta.id, appended.headEventId, appended.headSequence);
 			await tx.bumpRevision(meta.id, maxEventTime(events));
-			confirmedHead = headSequence;
+			confirmedHead = appended.headSequence;
 		});
 		if (reuse !== void 0) this.reuseEventIds.delete(meta.id);
 		this.writeGuard.confirmHead(meta.id, confirmedHead);
 		this.tracker.materialized(meta.id);
-		await this.recordEventCounts(meta.id, events);
+		await this.recordSessionStats(meta.id, events, usageRows);
 		return true;
 	}
 	async readLog(id, options = {}, signal) {
@@ -1792,7 +1876,7 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 			};
 		}
 		const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0);
-		if (hasLegacyShape(preserved)) {
+		if (needsShapeAdoption(preserved)) {
 			const adopted = adoptLegacyRows(row, eventRows);
 			return {
 				meta: adopted.meta,
@@ -1817,32 +1901,43 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 		};
 	}
 	/**
-	* 活动计数**旁路累加**：不在写事务里、失败只 warn——`t_event_counts` 是可销毁重建的派生表，
-	* 丢几次累加不影响可用性（需要时用 `rebuildEventCounts` 重算）。
+	* 统计衍生表的**旁路累加**：不在写事务里、失败只 warn——两张会话汇总表都是可销毁重建的
+	* 派生表，丢几次累加不影响可用性（需要时用 `rebuildSessionStats` 重算）。
+	* token 走写路径已折好的用量行，活动计数走本批事件类型。
 	*/
-	async recordEventCounts(id, events) {
-		const buckets = eventCountBuckets(events);
-		if (buckets.length === 0) return;
-		try {
-			await this.backend.incrementEventCounts(id, buckets);
+	async recordSessionStats(id, events, usageRows) {
+		const usageBuckets = sessionUsageBuckets(usageRows);
+		if (usageBuckets.length > 0) try {
+			await this.backend.incrementSessionUsage(id, usageBuckets);
+		} catch (error) {
+			this.ctx.logger.warn(`session-rdb: token usage for "${id}" not updated (${describeError(error)})`);
+		}
+		const countBuckets = sessionCountBuckets(events);
+		if (countBuckets.length > 0) try {
+			await this.backend.incrementSessionCounts(id, countBuckets);
 		} catch (error) {
 			this.ctx.logger.warn(`session-rdb: activity counts for "${id}" not updated (${describeError(error)})`);
 		}
 	}
-	/** 重算一个会话的活动计数（rewind / fork 之后；best-effort，同 `recordEventCounts`）。 */
-	async rebuildEventCounts(id) {
+	/**
+	* 重算一个会话的统计（rewind / fork 之后；best-effort，同 `recordSessionStats`）：
+	* 两张汇总表按会话重算，用量行的引用标记全量重算（引用可能跨会话消失）。
+	*/
+	async rebuildSessionStats(id) {
 		try {
-			await this.backend.rebuildEventCounts(id);
+			await this.backend.rebuildSessionStats(id);
+			await this.backend.refreshEventUsageFlags();
 		} catch (error) {
-			this.ctx.logger.warn(`session-rdb: activity counts for "${id}" not rebuilt (${describeError(error)})`);
+			this.ctx.logger.warn(`session-rdb: session stats for "${id}" not rebuilt (${describeError(error)})`);
 		}
 	}
-	/** 会话删除时清掉它的活动计数行（best-effort）。 */
-	async deleteEventCounts(id) {
+	/** 会话删除时清掉它的汇总行，并重算用量行的引用标记（被删会话引用的行要立刻退出统计）。 */
+	async dropSessionStats(id) {
 		try {
-			await this.backend.deleteEventCounts(id);
+			await this.backend.deleteSessionStats(id);
+			await this.backend.refreshEventUsageFlags();
 		} catch (error) {
-			this.ctx.logger.warn(`session-rdb: activity counts for "${id}" not deleted (${describeError(error)})`);
+			this.ctx.logger.warn(`session-rdb: session stats for "${id}" not deleted (${describeError(error)})`);
 		}
 	}
 	async rewriteMigratedLog(id, log) {
@@ -1855,13 +1950,14 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 				meta: log.meta,
 				inheritedEventCount: SessionLogOffset(log.inheritedEventCount)
 			}, randomUUID());
-			const { headEventId, headSequence } = await appendEventTail(tx, log.meta, log.events, {
+			const appended = await appendEventTail(tx, log.meta, log.events, {
 				parentId: "",
 				nextSeq: 0
 			});
-			await tx.updateHead(id, headEventId, headSequence);
+			await tx.updateHead(id, appended.headEventId, appended.headSequence);
 			await tx.bumpRevision(id, maxEventTime(log.events));
 		});
+		await this.rebuildSessionStats(id);
 	}
 	async listSnapshots(signal) {
 		signal?.throwIfAborted();
@@ -2091,19 +2187,46 @@ function seedCoversPrefix(seed, prefix) {
 		return seedEvent !== void 0 && JSON.stringify(seedEvent) === JSON.stringify(event);
 	});
 }
-/** 一批事件折成活动计数的桶：只数四种类型，按本地日聚合。 */
-function eventCountBuckets(events) {
+/** 一批事件折成活动计数的桶：只数四种类型，按本地日聚合成四项。 */
+function sessionCountBuckets(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) ?? {
+		const bucket = counted.get(day) ?? {
 			day,
-			type: event.type,
-			count: 0
+			turns: 0,
+			steps: 0,
+			userInputs: 0,
+			toolCalls: 0
 		};
-		bucket.count += 1;
+		addActivityCount(bucket, event.type, 1);
+		counted.set(day, bucket);
+	}
+	return [...counted.values()];
+}
+/** 一批用量行折成 token 桶：按「本地日 × 模型」聚合（模型未知落空串，与表口径一致）。 */
+function sessionUsageBuckets(usageRows) {
+	const counted = /* @__PURE__ */ new Map();
+	for (const row of usageRows) {
+		const provider = row.fProvider ?? "";
+		const model = row.fModel ?? "";
+		const key = `${row.fDay}#${provider}#${model}`;
+		const bucket = counted.get(key) ?? {
+			day: row.fDay,
+			provider,
+			model,
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			reasoningTokens: 0,
+			totalTokens: 0
+		};
+		bucket.inputTokens += row.fInputTokens;
+		bucket.outputTokens += row.fOutputTokens;
+		bucket.cacheReadTokens += row.fCacheReadTokens;
+		bucket.reasoningTokens += row.fReasoningTokens;
+		bucket.totalTokens += row.fTotalTokens;
 		counted.set(key, bucket);
 	}
 	return [...counted.values()];
@@ -2135,6 +2258,7 @@ async function appendEventTail(tx, meta, events, anchor, reuse) {
 	let parentId = anchor.parentId;
 	let nextSeq = anchor.nextSeq;
 	const eventRows = [];
+	const usageRows = [];
 	const bridgeRows = [];
 	for (const event of events) {
 		const reusedId = reuse?.get(event.seq);
@@ -2142,7 +2266,7 @@ async function appendEventTail(tx, meta, events, anchor, reuse) {
 		if (reusedId === void 0) {
 			const { kind, role, name, actionId } = eventDimensions(event);
 			const { data, surfaceOp: _surfaceOp, sourceEventSeqs: _sourceEventSeqs, ...envelope } = event;
-			eventRows.push({
+			const row = {
 				fEventId: eventId,
 				fParentId: parentId,
 				fType: event.type,
@@ -2156,7 +2280,10 @@ async function appendEventTail(tx, meta, events, anchor, reuse) {
 					data
 				}),
 				fCreatedAt: event.time
-			});
+			};
+			eventRows.push(row);
+			const usageRow = usageRowOf(row, meta.origin === "subagent");
+			if (usageRow !== void 0) usageRows.push(usageRow);
 		}
 		const surfaceOp = event.surfaceOp === void 0 ? null : JSON.stringify(event.surfaceOp);
 		bridgeRows.push({
@@ -2168,12 +2295,13 @@ async function appendEventTail(tx, meta, events, anchor, reuse) {
 		parentId = eventId;
 		nextSeq++;
 	}
-	if (eventRows.length > 0) await tx.insertEvents(eventRows);
+	if (eventRows.length > 0) await tx.insertEvents(eventRows, usageRows);
 	await tx.insertBridges(bridgeRows);
 	if (events.some((event) => event.type === "session/title")) await tx.refreshTitle(meta.id);
 	return {
 		headEventId: parentId,
-		headSequence: nextSeq - 1
+		headSequence: nextSeq - 1,
+		usageRows
 	};
 }
 //#endregion