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

package/dist/{sqlite-zcXVyMxr.mjs → sqlite-ChM_sHAG.mjs}

@@ -1,4 +1,4 @@
-import { _ as sessionInsertRow, g as sessionConflictRow, x as usageRowOf, y as titleOfEventData } from "./log-qCNkDjh5.mjs";
+import { C as COUNTED_EVENT_TYPES, D as addTotals, E as addTokenTotals, O as emptyTotals, T as addActivityTotals, _ as sessionConflictRow, b as titleOfEventData, k as localDayKey, v as sessionInsertRow } from "./log-DTcvsMz7.mjs";
 import { randomUUID } from "node:crypto";
 import { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
 import { and, desc, eq, gte, inArray, isNotNull, lt, notInArray, sql } from "drizzle-orm";
@@ -453,7 +453,9 @@ const sessionProjcacheRows = {
 //#region src/entities/v3/event-usage.ts
 /**
 * 用量日志：一条 `assistant/message` 事件一行（按事件行唯一，fork 共享行不重复）。
-* 统计只读这张表，不再逐行解析事件的 JSON；事件行本身仍留在 `t_events`。
+* 读侧维度全部物化在行上——本地日、是否被会话引用、是否被子代理会话引用——统计因此不做
+* `EXISTS` 判定、也不回连事件表；事件行本身仍留在 `t_events`。
+* 取舍见 ADR-统计衍生表物化归属与汇总。
 */
 const eventUsage = {
 	name: "t_event_usage",
@@ -471,8 +473,22 @@ const eventUsage = {
 			type: "bigint",
 			notNull: true
 		},
+		f_day: {
+			type: "text",
+			notNull: true
+		},
 		f_provider: { type: "text" },
 		f_model: { type: "text" },
+		f_referenced: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		},
+		f_subagent: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		},
 		f_input_tokens: {
 			type: "integer",
 			notNull: true,
@@ -502,6 +518,118 @@ const eventUsage = {
 	indexes: { idx_event_usage_created_at: { columns: ["f_created_at"] } }
 };
 //#endregion
+//#region src/entities/v3/session-usage.ts
+/**
+* 会话 × 本地日 × 模型的 token 汇总（派生统计表）：**按会话的行**读它，因此保住
+* 「fork 子会话含继承前缀」的口径（各会话行之和 ≥ 总量）而不回连事件表。
+* 旁路累加、可按会话重建，读侧只读；取舍见 ADR-统计衍生表物化归属与汇总。
+*/
+const sessionUsage = {
+	name: "t_session_usage",
+	columns: {
+		f_session_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_sessions",
+				column: "f_session_id",
+				onDelete: "cascade"
+			}
+		},
+		f_day: {
+			type: "text",
+			notNull: true
+		},
+		f_provider: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_model: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_input_tokens: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		},
+		f_output_tokens: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		},
+		f_cache_read_tokens: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		},
+		f_reasoning_tokens: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		},
+		f_total_tokens: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		}
+	},
+	uniques: { uq_session_usage_key: { columns: [
+		"f_session_id",
+		"f_day",
+		"f_provider",
+		"f_model"
+	] } }
+};
+//#endregion
+//#region src/entities/v3/session-counts.ts
+/**
+* 会话 × 本地日的活动计数（派生统计表）：轮次 / 步骤 / 用户输入 / 工具调用四列直接读，
+* 不再存事件类型、也不在读取时折。旁路累加、可按会话重建，读侧只读；
+* 取舍见 ADR-统计衍生表物化归属与汇总。
+*/
+const sessionCounts = {
+	name: "t_session_counts",
+	columns: {
+		f_session_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_sessions",
+				column: "f_session_id",
+				onDelete: "cascade"
+			}
+		},
+		f_day: {
+			type: "text",
+			notNull: true
+		},
+		f_turns: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		},
+		f_steps: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		},
+		f_user_inputs: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		},
+		f_tool_calls: {
+			type: "integer",
+			notNull: true,
+			default: 0
+		}
+	},
+	uniques: { uq_session_counts_key: { columns: ["f_session_id", "f_day"] } }
+};
+//#endregion
 //#region src/entities/v3/index.ts
 const sqliteTableDefs = [
 	persistenceState,
@@ -514,7 +642,9 @@ const sqliteTableDefs = [
 	workspaceSessions,
 	workspaceState,
 	sessionProjcacheRows,
-	eventUsage
+	eventUsage,
+	sessionUsage,
+	sessionCounts
 ];
 const postgresTableDefs = [
 	persistenceState,
@@ -527,7 +657,9 @@ const postgresTableDefs = [
 	workspaceSessions,
 	workspaceState,
 	sessionProjcacheRows,
-	eventUsage
+	eventUsage,
+	sessionUsage,
+	sessionCounts
 ];
 ({ ...sessionEvents$1 }), { ...sessionEvents$1.columns };
 //#endregion
@@ -547,6 +679,8 @@ const tWorkspaceSessions = sqliteTables["t_workspace_sessions"];
 const tWorkspaceState = sqliteTables["t_workspace_state"];
 const tSessionProjcacheRows = sqliteTables["t_session_projcache_row"];
 const tEventUsage = sqliteTables["t_event_usage"];
+const tSessionUsage = sqliteTables["t_session_usage"];
+const tSessionCounts = sqliteTables["t_session_counts"];
 const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
 function eventKind(event) {
 	switch (event.type) {
@@ -703,152 +837,6 @@ function eventDimensions(event) {
 	}
 }
 //#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";
-}
-/** 计入活动计数的事件类型（轮次 / 步骤 / 用户输入 / 工具调用）。 */
-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 src/storage-takeover/repository.ts
 async function allRows(query) {
 	const q = query;
@@ -1107,45 +1095,44 @@ function createStorageRepository(host) {
 }
 //#endregion
 //#region 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})
-     GROUP BY 1, 2, 3`);
+/** 用量行的「被引用」物化表达式（`%EVENT%` 换成事件 id 列）。 */
+const EVENT_REFERENCED_SQL = `EXISTS (SELECT 1 FROM t_session_events rb
+                                       WHERE rb.f_event_id = %EVENT%)`;
+/** 用量行的「被 subagent 会话引用」物化表达式（`%EVENT%` 换成事件 id 列）。 */
+const EVENT_SUBAGENT_SQL = `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 = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
+function withEvent(expression, column) {
+	return expression.replace("%EVENT%", column);
 }
 /**
-* 一次性回填：旧库的用量从未写过 `t_event_usage`，建表后按事件行补一次（幂等：表非空即跳过）。
+* 派生统计表的回填：任一表为空即按事件表全量重算（幂等；迁移删表重建后、手动清空后都靠它自愈）。
+* 顺序有依赖：用量行（带物化列）先落，两张会话汇总表再从它 / 事件表重算。
 */
+function backfillUsageTables(db) {
+	backfillEventUsage(db);
+	backfillSessionUsage(db);
+	backfillSessionCounts(db);
+}
+function tableIsEmpty(db, table) {
+	return db.prepare(`SELECT count(*) AS n FROM ${table}`).get().n === 0;
+}
+/** 用量行：一条 `assistant/message` 事件行一行，物化本地日与两个归属标记。 */
 function backfillEventUsage(db) {
-	if (db.prepare("SELECT count(*) AS n FROM t_event_usage").get().n > 0) return;
+	if (!tableIsEmpty(db, "t_event_usage")) return;
 	db.exec(`INSERT OR IGNORE INTO t_event_usage (
-      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,
+           date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
            coalesce(json_extract(e.f_data, '$.data.message.source.provider'),
                     json_extract(e.f_data, '$.message.source.provider')),
            coalesce(json_extract(e.f_data, '$.data.message.source.model'),
                     json_extract(e.f_data, '$.message.source.model')),
+           ${withEvent(EVENT_REFERENCED_SQL, "e.f_event_id")},
+           ${withEvent(EVENT_SUBAGENT_SQL, "e.f_event_id")},
            coalesce(json_extract(e.f_data, '$.data.usage.inputTokens'),
                     json_extract(e.f_data, '$.usage.inputTokens'), 0),
            coalesce(json_extract(e.f_data, '$.data.usage.outputTokens'),
@@ -1161,6 +1148,35 @@ function backfillEventUsage(db) {
        AND (json_extract(e.f_data, '$.data.usage') IS NOT NULL
             OR json_extract(e.f_data, '$.usage') IS NOT NULL)`);
 }
+/** 会话 × 本地日 × 模型的 token 汇总：从桥接行 × 用量行重算（含 fork 继承前缀）。 */
+function backfillSessionUsage(db) {
+	if (!tableIsEmpty(db, "t_session_usage")) return;
+	db.exec(`INSERT OR IGNORE INTO t_session_usage (
+      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 t_session_events b
+      JOIN t_event_usage u ON u.f_event_id = b.f_event_id
+     GROUP BY b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, '')`);
+}
+/** 会话 × 本地日的活动计数：从桥接行 × 事件类型重算。 */
+function backfillSessionCounts(db) {
+	if (!tableIsEmpty(db, "t_session_counts")) return;
+	db.exec(`INSERT OR IGNORE INTO t_session_counts (
+      f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
+    SELECT b.f_session_id,
+           date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
+           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 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})
+     GROUP BY b.f_session_id, 2`);
+}
 function sessionListRowOf(row) {
 	return {
 		sessionId: typeof row["session_id"] === "string" ? row["session_id"] : String(row["session_id"]),
@@ -1184,6 +1200,15 @@ function tokenTotalsOf(row) {
 		totalTokens: row.total_tokens ?? 0
 	};
 }
+/** `t_session_counts` 的原始行（列名是 SQL 别名）折成四项活动计数。 */
+function activityTotalsOf(row) {
+	return {
+		turns: row.turns ?? 0,
+		steps: row.steps ?? 0,
+		userInputs: row.user_inputs ?? 0,
+		toolCalls: row.tool_calls ?? 0
+	};
+}
 /** 一行的整套指标：token 用量 + 活动计数（轮次 / 步骤 / 用户输入 / 工具调用）。 */
 function emptyActivity() {
 	return {
@@ -1193,17 +1218,10 @@ function emptyActivity() {
 		toolCalls: 0
 	};
 }
-/** 有 token 用量的会话：活动计数与列表都限定在这一批会话里，口径一致。 */
+/** 有 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})`;
+	return `EXISTS (SELECT 1 FROM t_session_usage ub 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 = 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) {
@@ -1226,9 +1244,7 @@ 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(dbx, { migrationsFolder: sqliteMigrationsDir });
-		ensureEventCountsTable(db);
-		backfillEventCounts(db);
-		backfillEventUsage(db);
+		backfillUsageTables(db);
 		dbx.insert(tPersistenceState).values({
 			fSingleton: 1,
 			fStoreId: randomUUID()
@@ -1399,7 +1415,7 @@ var SqliteBackend = class SqliteBackend {
 		getHead: (id) => this.getHead(id),
 		getSeedLength: (id) => this.getSeedLength(id),
 		updateSeedLength: (id, seedLength) => this.updateSeedLength(id, seedLength),
-		insertEvents: (events) => this.insertEvents(events),
+		insertEvents: (events, usageRows) => this.insertEvents(events, usageRows),
 		insertBridges: (rows) => this.insertBridges(rows),
 		updateHead: (id, headEventId, headSequence) => this.updateHead(id, headEventId, headSequence),
 		bumpRevision: (id, lastEventAt) => this.bumpRevision(id, lastEventAt),
@@ -1432,14 +1448,10 @@ var SqliteBackend = class SqliteBackend {
 		this.db.update(tSessions).set({ fSeedLength: seedLength }).where(eq(tSessions.fSessionId, id)).run();
 	}
 	static INSERT_BATCH_ROWS = 1e3;
-	async insertEvents(events) {
+	async insertEvents(events, usageRows) {
 		if (events.length === 0) return;
 		for (let i = 0; i < events.length; i += SqliteBackend.INSERT_BATCH_ROWS) this.db.insert(tEvents).values(events.slice(i, i + SqliteBackend.INSERT_BATCH_ROWS).map((event) => ({ ...event }))).run();
-		const usage = events.flatMap((event) => {
-			const row = usageRowOf(event);
-			return row === void 0 ? [] : [row];
-		});
-		if (usage.length > 0) this.db.insert(tEventUsage).values(usage).onConflictDoNothing().run();
+		if (usageRows.length > 0) this.db.insert(tEventUsage).values(usageRows.map((row) => ({ ...row }))).onConflictDoNothing().run();
 	}
 	async insertBridges(rows) {
 		if (rows.length === 0) return;
@@ -1549,41 +1561,49 @@ var SqliteBackend = class SqliteBackend {
 			total: Number(counted.n)
 		};
 	}
+	/**
+	* 用量聚合：只读三张派生统计表——事件级用量行给去重口径的总量与「天 × 模型」桶，
+	* `t_session_usage` / `t_session_counts` 给按会话的行（含 fork 继承前缀）。
+	* 归属、本地日与「是否被引用」都是物化列，这里不再现算、也不回连事件表。
+	* 事件级按毫秒时间戳过滤、汇总表按本地日过滤——`sinceMs` 对齐到本地零点时两者等价。
+	*/
 	async usageReport(sinceMs) {
-		const usageSince = sinceMs === void 0 ? "" : " AND u.f_created_at >= ?";
+		const usageSince = sinceMs === void 0 ? "" : " AND f_created_at >= ?";
 		const params = sinceMs === void 0 ? [] : [sinceMs];
-		const daySince = sinceMs === void 0 ? "" : " AND c.f_day >= ?";
+		const daySince = sinceMs === void 0 ? "" : " AND %COL% >= ?";
 		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,
-                ${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)${usageSince}
-          GROUP BY subagent`).all(...params);
+		const dayFilter = (column) => daySince.replace("%COL%", column);
+		const buckets = this.db.$client.prepare(`SELECT f_day AS day,
+                f_provider AS provider,
+                f_model AS model,
+                f_subagent AS subagent,
+                sum(f_input_tokens) AS input_tokens,
+                sum(f_output_tokens) AS output_tokens,
+                sum(f_cache_read_tokens) AS cache_read_tokens,
+                sum(f_reasoning_tokens) AS reasoning_tokens,
+                sum(f_total_tokens) AS total_tokens
+           FROM t_event_usage
+          WHERE f_referenced = 1${usageSince}
+          GROUP BY f_day, f_provider, f_model, f_subagent`).all(...params);
+		const tokenScope = this.db.$client.prepare(`SELECT f_subagent AS subagent,
+                sum(f_input_tokens) AS input_tokens,
+                sum(f_output_tokens) AS output_tokens,
+                sum(f_cache_read_tokens) AS cache_read_tokens,
+                sum(f_reasoning_tokens) AS reasoning_tokens,
+                sum(f_total_tokens) AS total_tokens
+           FROM t_event_usage
+          WHERE f_referenced = 1${usageSince}
+          GROUP BY f_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
+                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 t_session_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,
+          WHERE ${hasUsageSession("c.f_session_id")}${dayFilter("c.f_day")}
+          GROUP BY subagent`).all(...dayParams);
+		const tokenSessions = this.db.$client.prepare(`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,
@@ -1592,28 +1612,25 @@ var SqliteBackend = class SqliteBackend {
                 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_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${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);
+           FROM t_session_usage u
+           JOIN t_sessions 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`).all(...dayParams);
+		const activitySessions = this.db.$client.prepare(`SELECT f_session_id AS session_id,
+                sum(f_turns) AS turns,
+                sum(f_steps) AS steps,
+                sum(f_user_inputs) AS user_inputs,
+                sum(f_tool_calls) AS tool_calls
+           FROM t_session_counts
+          WHERE 1 = 1${dayFilter("f_day")}
+          GROUP BY f_session_id`).all(...dayParams);
 		const human = emptyTotals();
 		const subagent = emptyTotals();
 		for (const row of tokenScope) addTokenTotals(row.subagent === 1 ? subagent : human, tokenTotalsOf(row));
-		for (const row of activityScope) addActivityCount(row.subagent === 1 ? subagent : human, row.f_type, row.n ?? 0);
+		for (const row of activityScope) addActivityTotals(row.subagent === 1 ? subagent : human, activityTotalsOf(row));
 		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();
-			addActivityCount(target, row.f_type, row.n ?? 0);
-			activityBySession.set(row.session_id, target);
-		}
+		for (const row of activitySessions) activityBySession.set(row.session_id, activityTotalsOf(row));
 		return {
 			totals,
 			subagent,
@@ -1635,28 +1652,72 @@ var SqliteBackend = class SqliteBackend {
 			}))
 		};
 	}
-	/** 活动计数旁路累加：派生表 `t_event_counts`，不在写事务里（失败可丢，表可销毁重建）。 */
-	async incrementEventCounts(id, buckets) {
+	/** token 用量旁路累加：派生表 `t_session_usage`，不在写事务里（失败可丢，表可销毁重建）。 */
+	async incrementSessionUsage(id, buckets) {
+		if (buckets.length === 0) return;
+		const statement = this.db.$client.prepare(`INSERT INTO t_session_usage (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 (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(f_session_id, f_day, f_provider, f_model) DO UPDATE SET
+         f_input_tokens = f_input_tokens + excluded.f_input_tokens,
+         f_output_tokens = f_output_tokens + excluded.f_output_tokens,
+         f_cache_read_tokens = f_cache_read_tokens + excluded.f_cache_read_tokens,
+         f_reasoning_tokens = f_reasoning_tokens + excluded.f_reasoning_tokens,
+         f_total_tokens = f_total_tokens + excluded.f_total_tokens`);
+		for (const bucket of buckets) statement.run(id, bucket.day, bucket.provider ?? "", bucket.model ?? "", bucket.inputTokens, bucket.outputTokens, bucket.cacheReadTokens, bucket.reasoningTokens, bucket.totalTokens);
+	}
+	/** 活动计数旁路累加：派生表 `t_session_counts`，同上（四项计数一次落）。 */
+	async incrementSessionCounts(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);
+		const statement = this.db.$client.prepare(`INSERT INTO t_session_counts (f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(f_session_id, f_day) DO UPDATE SET
+         f_turns = f_turns + excluded.f_turns,
+         f_steps = f_steps + excluded.f_steps,
+         f_user_inputs = f_user_inputs + excluded.f_user_inputs,
+         f_tool_calls = f_tool_calls + excluded.f_tool_calls`);
+		for (const bucket of buckets) statement.run(id, bucket.day, bucket.turns, bucket.steps, bucket.userInputs, bucket.toolCalls);
 	}
-	/** 按会话重算活动计数（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)
+	/** 按会话重算两张汇总表（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
+	async rebuildSessionStats(id) {
+		this.db.$client.prepare("DELETE FROM t_session_usage WHERE f_session_id = ?").run(id);
+		this.db.$client.prepare(`INSERT INTO t_session_usage (
+             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 t_session_events b
+           JOIN t_event_usage u ON u.f_event_id = b.f_event_id
+          WHERE b.f_session_id = ?
+          GROUP BY b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, '')`).run(id);
+		this.db.$client.prepare("DELETE FROM t_session_counts WHERE f_session_id = ?").run(id);
+		this.db.$client.prepare(`INSERT INTO t_session_counts (
+             f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
          SELECT b.f_session_id,
                 date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
-                e.f_type,
-                count(*)
+                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 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})
-          GROUP BY 1, 2, 3`).run(id);
+          GROUP BY b.f_session_id, 2`).run(id);
+	}
+	/**
+	* 全量重算用量行的引用标记：rewind 截断 / fork 复用 / 会话删除都会让「引用」跨会话变化，
+	* 只按本会话判定不够。低频路径，一次全表 UPDATE（3 万行量级）。
+	*/
+	async refreshEventUsageFlags() {
+		const eventId = "t_event_usage.f_event_id";
+		this.db.$client.exec(`UPDATE t_event_usage SET
+         f_referenced = ${withEvent(EVENT_REFERENCED_SQL, eventId)},
+         f_subagent = ${withEvent(EVENT_SUBAGENT_SQL, eventId)}`);
 	}
-	async deleteEventCounts(id) {
-		this.db.$client.prepare("DELETE FROM t_event_counts WHERE f_session_id = ?").run(id);
+	async deleteSessionStats(id) {
+		this.db.$client.prepare("DELETE FROM t_session_usage WHERE f_session_id = ?").run(id);
+		this.db.$client.prepare("DELETE FROM t_session_counts WHERE f_session_id = ?").run(id);
 	}
 	async vacuum() {
 		await enqueueSqliteTx(this.dbPath, async () => {
@@ -1679,4 +1740,4 @@ var SqliteBackend = class SqliteBackend {
 	}
 };
 //#endregion
-export { WriteGuard as A, tSessions as C, tWorkspaces as D, tWorkspaceState as E, postgresTableDefs as O, tSessionProjcacheRows as S, tWorkspaceSessions as T, tEventUsage as _, addActivityCount as a, tSchemaMeta as b, emptyTotals as c, DEFAULT_BUSY_TIMEOUT_MS as d, EVENT_ENCODING as f, eventKind as g, eventDimensions as h, COUNTED_EVENT_TYPES as i, toPostgresSchema as k, localDayKey as l, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as m, openDatabase as n, addTokenTotals as o, SCHEMA_VERSION as p, createStorageRepository as r, addTotals as s, SqliteBackend as t, registerSessionUsage as u, tEvents as v, tStorageUnits as w, tSessionEvents as x, tPersistenceState as y };
+export { postgresTableDefs as C, tWorkspaces as S, WriteGuard as T, tSessionUsage as _, EVENT_ENCODING as a, tWorkspaceSessions as b, eventDimensions as c, tEvents as d, tPersistenceState as f, tSessionProjcacheRows as g, tSessionEvents as h, DEFAULT_BUSY_TIMEOUT_MS as i, eventKind as l, tSessionCounts as m, openDatabase as n, SCHEMA_VERSION as o, tSchemaMeta as p, createStorageRepository as r, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as s, SqliteBackend as t, tEventUsage as u, tSessions as v, toPostgresSchema as w, tWorkspaceState as x, tStorageUnits as y };