@morlay/ui-conversation-message-actions 0.0.19-alpha.7 → 0.0.19-alpha.9

package/dist/testing.mjs

@@ -20514,6 +20514,157 @@ createSessionFormatCatalog({
 	}
 });
 //#endregion
+//#region ../session-rdb/src/usage.ts
+const SESSION_USAGE_PATH = "/api/session.usage";
+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 本地时区的零点**——`day` / `week` 是
+* 今天 / 本周一的零点，`7d` / `30d` / `90d` 是「今天零点往前 N-1 天」（含今天共 N 个自然日）。
+* 对齐的意义：事件级表按毫秒过滤、会话汇总表按本地日过滤，两者因此严格等价。
+* @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: {
+			const start = localDayStart(now);
+			start.setDate(start.getDate() - (ROLLING_DAYS[range] - 1));
+			return start.getTime();
+		}
+	}
+}
+function parseUsageRange(value) {
+	return value === "day" || value === "week" || value === "7d" || value === "30d" || value === "90d" ? value : "all";
+}
+/** 计入活动计数的事件类型（轮次 / 步骤 / 用户输入 / 工具调用）。 */
+const COUNTED_EVENT_TYPES = [
+	"turn/start",
+	"step/start",
+	"user/message",
+	"tool/call"
+];
+/** 按事件类型把计数累加到活动指标上（表里按类型存，读的时候折成四项）。 */
+function addActivityCount(target, type, count) {
+	switch (type) {
+		case "turn/start":
+			target.turns += count;
+			return target;
+		case "step/start":
+			target.steps += count;
+			return target;
+		case "user/message":
+			target.userInputs += count;
+			return target;
+		case "tool/call":
+			target.toolCalls += count;
+			return target;
+		default: return target;
+	}
+}
+/** 毫秒时间戳 → host 本地日（`YYYY-MM-DD`，与 SQL 的 localtime 口径一致）。 */
+function localDayKey(ms) {
+	const date = new Date(ms);
+	const pad = (value) => String(value).padStart(2, "0");
+	return `${String(date.getFullYear())}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+function emptyTotals() {
+	return {
+		turns: 0,
+		steps: 0,
+		userInputs: 0,
+		toolCalls: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		reasoningTokens: 0,
+		totalTokens: 0
+	};
+}
+function addTokenTotals(target, row) {
+	target.inputTokens += row.inputTokens;
+	target.outputTokens += row.outputTokens;
+	target.cacheReadTokens += row.cacheReadTokens;
+	target.reasoningTokens += row.reasoningTokens;
+	target.totalTokens += row.totalTokens;
+	return target;
+}
+function addActivityTotals(target, row) {
+	target.turns += row.turns;
+	target.steps += row.steps;
+	target.userInputs += row.userInputs;
+	target.toolCalls += row.toolCalls;
+	return target;
+}
+/** 把一行的整套指标累加进目标（后端合并「是否子代理」两组时用）。 */
+function addTotals(target, row) {
+	addActivityTotals(target, row);
+	addTokenTotals(target, row);
+	return target;
+}
+/**
+* 用量统计通道：一次请求回报总览（含 subagent 拆分）、按天 × 模型的桶与按会话的行。
+* 聚合只算被会话引用的事件行——fork 共享行因此只计一次，已删会话留下的孤儿行不计。
+*/
+function registerSessionUsage(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_USAGE_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					res.writeHead(405, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "method not allowed" }));
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				const raw = Buffer.concat(chunks).toString("utf8");
+				let envelope = {};
+				if (raw !== "") try {
+					envelope = JSON.parse(raw);
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				try {
+					const report = await persistence.usageReport(resolveUsageSince(parseUsageRange(envelope.range), Date.now()));
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify(report));
+				} catch (error) {
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "usage report failed" }));
+				}
+			}
+		}), `session-rdb: ${SESSION_USAGE_PATH} route`);
+	});
+}
+//#endregion
 //#region ../session-rdb/src/log.ts
 function normalizeSurfaceOp(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
@@ -20868,15 +21019,15 @@ function renameLegacyPtcEvents(events) {
 *   （v4 起 system 消息只认这个 kind）；
 * - `tool/result` 的消息：v3 是 user 角色、结果块包在 `content[0]`；v4 是 `role: 'tool'` + 顶层
 *   `toolCallId` + `content` 就是结果块；
-* - 本仓库自己写过、上游已删除的事件类型（见 `LEGACY_OWN_EVENT_TYPES`）标 `ignorable: true`——v4 的
-*   校验对未知类型只接受可忽略信封。
+* - **本仓库自造、上游不认识的事件类型**（见 `OWN_EVENT_TYPES`：历史遗留的与我们当前在写的）标
+*   `ignorable: true`——v4 的校验对未知类型只接受可忽略信封。
 *
 * 只认这张白名单：**其它未知类型保持 fail loud**（那是「数据来自更新的 harness」的信号，不能吞掉）。
 */
 function normalizeToCurrentShape(events) {
 	for (const event of events) {
 		const type = event.type;
-		if (LEGACY_OWN_EVENT_TYPES.has(type)) {
+		if (OWN_EVENT_TYPES.has(type)) {
 			event.ignorable = true;
 			continue;
 		}
@@ -20919,16 +21070,36 @@ function liftToolResultMessage(message) {
 	};
 }
 /**
-* 本仓库写过、后来连同机制一起删除的事件类型：读的时候标 `ignorable: true` 让校验跳过它们。
-* 新增历史类型时登记到这里——**不要**用「所有未知类型」代替（那会掩盖更新版本的未知事件）。
+* 落库前给**本仓库自造的事件类型**补上 `ignorable: true` 信封。
+*
+* 上游的持久化校验（`validateStoredEvents`）只放行「已知类型」或「带可忽略信封的未知类型」，我们的类型
+* 按构造就在已知表之外——不补的话连**写入**都会被拒（`appendBatch` 里那道校验）。上游 `Session.append`
+* 没有承载这个信封的口子（第三个参数只服务 surface 事件），所以这一笔由持久化层补：canonical log 里的
+* 形状不变，落库的那一份带上信封。
+* @param events - 即将落库的批次（`materializeAppendBatch` 的 JSON 快照副本，可写）。
 */
-const LEGACY_OWN_EVENT_TYPES = /* @__PURE__ */ new Set(["session-branch/version"]);
-/** 行里是否还带着旧代消息形状（`session-branch/version` 这类自造事件也算）——写路径曾把回退视图的结果
-* 以当前版本号落库，所以**版本号不可信**，读之前要按内容判一次。 */
-function hasLegacyShape(events) {
+function sealOwnEvents(events) {
+	for (const event of events) if (OWN_EVENT_TYPES.has(event.type)) event.ignorable = true;
+}
+/**
+* 本仓库自造、上游不认识的事件类型：读的时候标 `ignorable: true`，v4 的持久化校验才肯跳过它们
+* （`validateStoredEvents` 只放行「已知类型」或「带可忽略信封的未知类型」）。
+*
+* 两类都在这张表里：
+* - **历史遗留**：写过、后来连同机制一起删除的（`session-branch/version`）；
+* - **当前在写**：本仓库的插件自己声明的事件类型（`session-mode/selected`）——上游的
+*   `KNOWN_SESSION_EVENT_TYPES` 由上游仓库的声明生成，外部插件的事件按构造就在它之外。
+*
+* 新增自造事件类型时**必须**登记到这里，否则读路径 fail loud（真回归：`session-mode/selected` 漏登记，
+* 会话打不开）。**不要**用「所有未知类型」代替（那会掩盖更新版本的未知事件——那种必须拒读）。
+*/
+const OWN_EVENT_TYPES = /* @__PURE__ */ new Set(["session-branch/version", "session-mode/selected"]);
+/** 这批事件是否需要按当前形状归一（旧代消息形状，或尚未标 `ignorable` 的自造事件类型）——写路径曾把回退
+* 视图的结果以当前版本号落库，所以**版本号不可信**，读之前要按内容判一次。 */
+function needsShapeAdoption(events) {
 	for (const event of events) {
 		const type = event.type;
-		if (LEGACY_OWN_EVENT_TYPES.has(type)) return true;
+		if (OWN_EVENT_TYPES.has(type)) return true;
 		if (type === "system/message") {
 			if ((event.data["message"]?.["source"])?.["kind"] === "plugin") return true;
 			continue;
@@ -21069,10 +21240,13 @@ function textField(value) {
 /**
 * 一条事件行的用量（只有带 `usage` 的 `assistant/message` 才有）：写路径据此记录
 * `t_event_usage`，统计因此不必逐行解析 JSON。两种 `f_data` 结构（带信封 / 老格式）都认。
+* 读侧维度一起物化：本地日由事件时间算，`f_referenced` 直接 1（这一批事件行与桥接行同事务，
+* 提交即被引用），`f_subagent` 取写入它的会话是否子代理。
 * @param event - 待写入的事件行。
+* @param subagent - 写入它的会话是否 `origin === 'subagent'`。
 * @returns 用量行，或该事件没有用量时的 undefined。
 */
-function usageRowOf(event) {
+function usageRowOf(event, subagent) {
 	if (event.fType !== "assistant/message") return void 0;
 	let parsed;
 	try {
@@ -21087,8 +21261,11 @@ function usageRowOf(event) {
 	return {
 		fEventId: event.fEventId,
 		fCreatedAt: event.fCreatedAt,
+		fDay: localDayKey(event.fCreatedAt),
 		fProvider: textField(source?.["provider"]),
 		fModel: textField(source?.["model"]),
+		fReferenced: 1,
+		fSubagent: subagent ? 1 : 0,
 		fInputTokens: numericField(usage["inputTokens"]),
 		fOutputTokens: numericField(usage["outputTokens"]),
 		fCacheReadTokens: numericField(usage["cacheReadTokens"]),
@@ -25025,7 +25202,9 @@ const sessionProjcacheRows = {
 //#region ../session-rdb/src/entities/v3/event-usage.ts
 /**
 * 用量日志：一条 `assistant/message` 事件一行（按事件行唯一，fork 共享行不重复）。
-* 统计只读这张表，不再逐行解析事件的 JSON；事件行本身仍留在 `t_events`。
+* 读侧维度全部物化在行上——本地日、是否被会话引用、是否被子代理会话引用——统计因此不做
+* `EXISTS` 判定、也不回连事件表；事件行本身仍留在 `t_events`。
+* 取舍见 ADR-统计衍生表物化归属与汇总。
 */
 const eventUsage = {
 	name: "t_event_usage",
@@ -25043,8 +25222,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,
@@ -25074,6 +25267,118 @@ const eventUsage = {
 	indexes: { idx_event_usage_created_at: { columns: ["f_created_at"] } }
 };
 //#endregion
+//#region ../session-rdb/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 ../session-rdb/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 ../session-rdb/src/entities/v3/index.ts
 const sqliteTableDefs = [
 	persistenceState,
@@ -25086,7 +25391,9 @@ const sqliteTableDefs = [
 	workspaceSessions,
 	workspaceState,
 	sessionProjcacheRows,
-	eventUsage
+	eventUsage,
+	sessionUsage,
+	sessionCounts
 ];
 const postgresTableDefs = [
 	persistenceState,
@@ -25099,7 +25406,9 @@ const postgresTableDefs = [
 	workspaceSessions,
 	workspaceState,
 	sessionProjcacheRows,
-	eventUsage
+	eventUsage,
+	sessionUsage,
+	sessionCounts
 ];
 ({ ...sessionEvents$1 }), { ...sessionEvents$1.columns };
 //#endregion
@@ -25118,6 +25427,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"];
+sqliteTables["t_session_usage"];
+sqliteTables["t_session_counts"];
 const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
 function eventKind(event) {
 	switch (event.type) {
@@ -25352,209 +25663,63 @@ var NodeSQLiteDatabase = class extends SQLiteAsyncDatabase {
 };
 function construct(client, config = {}) {
 	const dialect = new SQLiteDialect({ useJitMappers: jitCompatCheck(config.jit) });
-	let logger;
-	if (config.logger === true) logger = new DefaultLogger();
-	else if (config.logger !== false) logger = config.logger;
-	const relations = config.relations ?? {};
-	const db = new NodeSQLiteDatabase("sync", dialect, new NodeSQLiteSession(client, dialect, relations, { logger }), relations);
-	db.$client = client;
-	return db;
-}
-function drizzle(...params) {
-	if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new DatabaseSync(":memory:") : new DatabaseSync(params[0]), params[1]);
-	const { connection, client, ...config } = params[0];
-	if (client) return construct(client, config);
-	if (typeof connection === "object") {
-		const { path, ...options } = connection;
-		return construct(new DatabaseSync(path ?? ":memory:", options), config);
-	}
-	return construct(new DatabaseSync(connection ?? ":memory:"), config);
-}
-(function(_drizzle) {
-	function mock(config) {
-		return construct({}, config);
-	}
-	_drizzle.mock = mock;
-})(drizzle || (drizzle = {}));
-//#endregion
-//#region ../../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.5-ab785fc_@opentelemetry+api@1.9.1_@types+pg@8.23.1_pg@8.23.0_typebox@1.3.7_zod@4.6.5/node_modules/drizzle-orm/migrator.js
-function readMigrationFiles(config) {
-	if (fs.existsSync(`${config.migrationsFolder}/meta/_journal.json`)) throw Error("We detected that you have old drizzle-kit migration folders. You must upgrade drizzle-kit and run \"drizzle-kit up\"");
-	const migrationFolderTo = config.migrationsFolder;
-	const migrationQueries = [];
-	const migrations = readdirSync(migrationFolderTo).map((subdir) => ({
-		path: join(migrationFolderTo, subdir, "migration.sql"),
-		name: subdir
-	})).filter((it) => existsSync(it.path));
-	migrations.sort((a, b) => a.name.localeCompare(b.name));
-	for (const migration of migrations) {
-		const migrationPath = migration.path;
-		const migrationDate = migration.name.slice(0, 14);
-		const query = fs.readFileSync(migrationPath).toString();
-		const result = query.split("--> statement-breakpoint").map((it) => {
-			return it;
-		});
-		const millis = formatToMillis(migrationDate);
-		migrationQueries.push({
-			sql: result,
-			bps: true,
-			folderMillis: millis,
-			hash: crypto.createHash("sha256").update(query).digest("hex"),
-			name: migration.name
-		});
-	}
-	return migrationQueries;
-}
-//#endregion
-//#region ../../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.5-ab785fc_@opentelemetry+api@1.9.1_@types+pg@8.23.1_pg@8.23.0_typebox@1.3.7_zod@4.6.5/node_modules/drizzle-orm/node-sqlite/migrator.js
-function migrate$1(db, config) {
-	return migrateSync(readMigrationFiles(config), db.session, config);
-}
-//#endregion
-//#region ../session-rdb/src/usage.ts
-const SESSION_USAGE_PATH = "/api/session.usage";
-const DAY_MS = 864e5;
-const ROLLING_DAYS = {
-	"7d": 7,
-	"30d": 30,
-	"90d": 90
-};
-function localDayStart(now) {
-	const start = new Date(now);
-	start.setHours(0, 0, 0, 0);
-	return start;
-}
-/**
-* 范围起点（含），不限时为 undefined。自然日 / 自然周按 host 的本地时区算，周边界是周一 00:00。
-* @param range - 语义键。
-* @param now - 当前时刻。
-* @returns 起点毫秒时间戳，或 undefined。
-*/
-function resolveUsageSince(range, now) {
-	switch (range) {
-		case "all": return;
-		case "day": return localDayStart(now).getTime();
-		case "week": {
-			const start = localDayStart(now);
-			start.setDate(start.getDate() - (start.getDay() + 6) % 7);
-			return start.getTime();
-		}
-		default: return now - ROLLING_DAYS[range] * DAY_MS;
-	}
-}
-function parseUsageRange(value) {
-	return value === "day" || value === "week" || value === "7d" || value === "30d" || value === "90d" ? value : "all";
-}
-/** 计入活动计数的事件类型（轮次 / 步骤 / 用户输入 / 工具调用）。 */
-const COUNTED_EVENT_TYPES = [
-	"turn/start",
-	"step/start",
-	"user/message",
-	"tool/call"
-];
-/** 按事件类型把计数累加到活动指标上（表里按类型存，读的时候折成四项）。 */
-function addActivityCount(target, type, count) {
-	switch (type) {
-		case "turn/start":
-			target.turns += count;
-			return target;
-		case "step/start":
-			target.steps += count;
-			return target;
-		case "user/message":
-			target.userInputs += count;
-			return target;
-		case "tool/call":
-			target.toolCalls += count;
-			return target;
-		default: return target;
-	}
-}
-/** 毫秒时间戳 → host 本地日（`YYYY-MM-DD`，与 SQL 的 localtime 口径一致）。 */
-function localDayKey(ms) {
-	const date = new Date(ms);
-	const pad = (value) => String(value).padStart(2, "0");
-	return `${String(date.getFullYear())}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
-}
-function emptyTotals() {
-	return {
-		turns: 0,
-		steps: 0,
-		userInputs: 0,
-		toolCalls: 0,
-		inputTokens: 0,
-		outputTokens: 0,
-		cacheReadTokens: 0,
-		reasoningTokens: 0,
-		totalTokens: 0
-	};
-}
-function addTokenTotals(target, row) {
-	target.inputTokens += row.inputTokens;
-	target.outputTokens += row.outputTokens;
-	target.cacheReadTokens += row.cacheReadTokens;
-	target.reasoningTokens += row.reasoningTokens;
-	target.totalTokens += row.totalTokens;
-	return target;
+	let logger;
+	if (config.logger === true) logger = new DefaultLogger();
+	else if (config.logger !== false) logger = config.logger;
+	const relations = config.relations ?? {};
+	const db = new NodeSQLiteDatabase("sync", dialect, new NodeSQLiteSession(client, dialect, relations, { logger }), relations);
+	db.$client = client;
+	return db;
 }
-function addActivityTotals(target, row) {
-	target.turns += row.turns;
-	target.steps += row.steps;
-	target.userInputs += row.userInputs;
-	target.toolCalls += row.toolCalls;
-	return target;
+function drizzle(...params) {
+	if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new DatabaseSync(":memory:") : new DatabaseSync(params[0]), params[1]);
+	const { connection, client, ...config } = params[0];
+	if (client) return construct(client, config);
+	if (typeof connection === "object") {
+		const { path, ...options } = connection;
+		return construct(new DatabaseSync(path ?? ":memory:", options), config);
+	}
+	return construct(new DatabaseSync(connection ?? ":memory:"), config);
 }
-/** 把一行的整套指标累加进目标（后端合并「是否子代理」两组时用）。 */
-function addTotals(target, row) {
-	addActivityTotals(target, row);
-	addTokenTotals(target, row);
-	return target;
+(function(_drizzle) {
+	function mock(config) {
+		return construct({}, config);
+	}
+	_drizzle.mock = mock;
+})(drizzle || (drizzle = {}));
+//#endregion
+//#region ../../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.5-ab785fc_@opentelemetry+api@1.9.1_@types+pg@8.23.1_pg@8.23.0_typebox@1.3.7_zod@4.6.5/node_modules/drizzle-orm/migrator.js
+function readMigrationFiles(config) {
+	if (fs.existsSync(`${config.migrationsFolder}/meta/_journal.json`)) throw Error("We detected that you have old drizzle-kit migration folders. You must upgrade drizzle-kit and run \"drizzle-kit up\"");
+	const migrationFolderTo = config.migrationsFolder;
+	const migrationQueries = [];
+	const migrations = readdirSync(migrationFolderTo).map((subdir) => ({
+		path: join(migrationFolderTo, subdir, "migration.sql"),
+		name: subdir
+	})).filter((it) => existsSync(it.path));
+	migrations.sort((a, b) => a.name.localeCompare(b.name));
+	for (const migration of migrations) {
+		const migrationPath = migration.path;
+		const migrationDate = migration.name.slice(0, 14);
+		const query = fs.readFileSync(migrationPath).toString();
+		const result = query.split("--> statement-breakpoint").map((it) => {
+			return it;
+		});
+		const millis = formatToMillis(migrationDate);
+		migrationQueries.push({
+			sql: result,
+			bps: true,
+			folderMillis: millis,
+			hash: crypto.createHash("sha256").update(query).digest("hex"),
+			name: migration.name
+		});
+	}
+	return migrationQueries;
 }
-/**
-* 用量统计通道：一次请求回报总览（含 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 ../../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.5-ab785fc_@opentelemetry+api@1.9.1_@types+pg@8.23.1_pg@8.23.0_typebox@1.3.7_zod@4.6.5/node_modules/drizzle-orm/node-sqlite/migrator.js
+function migrate$1(db, config) {
+	return migrateSync(readMigrationFiles(config), db.session, config);
 }
 //#endregion
 //#region ../session-rdb/src/storage-takeover/repository.ts
@@ -25815,45 +25980,44 @@ function createStorageRepository(host) {
 }
 //#endregion
 //#region ../session-rdb/src/sqlite.ts
-/** 活动计数的派生表：可销毁重建（不在 drizzle schema / 迁移里，建表幂等）。 */
-function ensureEventCountsTable(db) {
-	db.exec(`CREATE TABLE IF NOT EXISTS t_event_counts (
-      f_id INTEGER PRIMARY KEY AUTOINCREMENT,
-      f_session_id TEXT NOT NULL,
-      f_day TEXT NOT NULL,
-      f_type TEXT NOT NULL,
-      f_count INTEGER NOT NULL DEFAULT 0
-    );
-    CREATE UNIQUE INDEX IF NOT EXISTS uq_event_counts_session_day_type
-      ON t_event_counts(f_session_id, f_day, f_type);
-    CREATE INDEX IF NOT EXISTS idx_event_counts_day ON t_event_counts(f_day);`);
-}
-/** 一次性回填活动计数（表为空时从事件表重算；幂等）。 */
-function backfillEventCounts(db) {
-	if (db.prepare("SELECT count(*) AS n FROM t_event_counts").get().n > 0) return;
-	db.exec(`INSERT OR IGNORE INTO t_event_counts (f_session_id, f_day, f_type, f_count)
-    SELECT b.f_session_id,
-           date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
-           e.f_type,
-           count(*)
-      FROM t_session_events b
-      JOIN t_events e ON e.f_event_id = b.f_event_id
-     WHERE e.f_type IN (${COUNTED_EVENT_TYPE_SQL$1})
-     GROUP BY 1, 2, 3`);
+/** 用量行的「被引用」物化表达式（`%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$1 = 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'),
@@ -25869,6 +26033,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$1})
+     GROUP BY b.f_session_id, 2`);
+}
 function sessionListRowOf(row) {
 	return {
 		sessionId: typeof row["session_id"] === "string" ? row["session_id"] : String(row["session_id"]),
@@ -25892,6 +26085,15 @@ function tokenTotalsOf$1(row) {
 		totalTokens: row.total_tokens ?? 0
 	};
 }
+/** `t_session_counts` 的原始行（列名是 SQL 别名）折成四项活动计数。 */
+function activityTotalsOf$1(row) {
+	return {
+		turns: row.turns ?? 0,
+		steps: row.steps ?? 0,
+		userInputs: row.user_inputs ?? 0,
+		toolCalls: row.tool_calls ?? 0
+	};
+}
 /** 一行的整套指标：token 用量 + 活动计数（轮次 / 步骤 / 用户输入 / 工具调用）。 */
 function emptyActivity$1() {
 	return {
@@ -25901,17 +26103,10 @@ function emptyActivity$1() {
 		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$1 = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
 const sqliteMigrationsDir = fileURLToPath(new URL("../drizzle/sqlite/", import.meta.url));
 const sqliteTxQueues = /* @__PURE__ */ new Map();
 function enqueueSqliteTx(path, fn) {
@@ -25934,9 +26129,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$1(dbx, { migrationsFolder: sqliteMigrationsDir });
-		ensureEventCountsTable(db);
-		backfillEventCounts(db);
-		backfillEventUsage(db);
+		backfillUsageTables(db);
 		dbx.insert(tPersistenceState).values({
 			fSingleton: 1,
 			fStoreId: randomUUID()
@@ -26107,7 +26300,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),
@@ -26140,14 +26333,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;
@@ -26257,41 +26446,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,
@@ -26300,28 +26497,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$1(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$1(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$1();
-			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$1(row));
 		return {
 			totals,
 			subagent,
@@ -26343,28 +26537,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);
-	}
-	/** 按会话重算活动计数（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)
+		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 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$1})
-          GROUP BY 1, 2, 3`).run(id);
+          GROUP BY b.f_session_id, 2`).run(id);
 	}
-	async deleteEventCounts(id) {
-		this.db.$client.prepare("DELETE FROM t_event_counts WHERE f_session_id = ?").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 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 () => {
@@ -26428,6 +26666,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 {
@@ -26481,9 +26728,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,
@@ -26544,7 +26789,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),
@@ -26581,14 +26826,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;
@@ -26658,21 +26899,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,
@@ -26688,6 +26949,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`，数值列回来是字符串。 */
@@ -26740,85 +27042,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,
@@ -26840,76 +27135,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 ${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
+    `);
+	}
+	/** 全量重算用量行的引用标记（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`
-      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
+      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 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 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({
@@ -27147,7 +27466,7 @@ var SessionBranchRdbProvider = class {
 			internals.dropReuseEventIds(childId);
 			throw error;
 		}
-		await this.persistence.rebuildEventCounts(childId);
+		await this.persistence.rebuildSessionStats(childId);
 		return childId;
 	}
 	async rewind(id, toBoundary, signal) {
@@ -27220,7 +27539,7 @@ var SessionBranchRdbProvider = class {
 			headSeq: keepLength - 1,
 			snapshotEvents: () => []
 		});
-		await this.persistence.rebuildEventCounts(id);
+		await this.persistence.rebuildSessionStats(id);
 		return {
 			header: rowToMeta(row),
 			revision: await internals.readStoredRevision(id)
@@ -35021,6 +35340,7 @@ var SessionObservationReader = class {
 	* @param sessionId - logical Session identity.
 	* @param options - cancellation and all-or-none projection computation for this read.
 	* @returns one exact immutable observation.
+	* @throws {@link SessionQueryError} with code `SESSION_QUERY_CORRUPT_SESSION` when live or prepared projection computation fails.
 	*/
 	async read(sessionId, options = {}) {
 		const { signal, projectionMode = "all" } = options;
@@ -35152,7 +35472,12 @@ var SessionObservationReader = class {
 	live(session, projectionMode) {
 		const seq = session.seq;
 		let materialized;
-		const projections = projectionMode === "none" ? void 0 : this.ctx.get("sessionProjections")?.snapshot(session);
+		let projections;
+		try {
+			projections = projectionMode === "none" ? void 0 : this.ctx.get("sessionProjections")?.snapshot(session);
+		} catch (error) {
+			throw new SessionQueryError(`failed to project session "${session.id}": ${errorMessage(error)}`, "SESSION_QUERY_CORRUPT_SESSION", { cause: error });
+		}
 		const lease = () => {
 			let disposed = false;
 			return {
@@ -36565,38 +36890,62 @@ var RdbSessionHandle = class RdbSessionHandle {
 	}
 	static LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
 };
+/**
+* 本地化说明：`description()` 的类型签名只声明 `string`，而 meta 本身接受 `Dict<string>`
+* （`vendor/schemastery/src/index.ts` 的 `mergeDesc` 就是按字典合并的），所以这里只做一次类型放行。
+*/
+const localized = (text) => text;
+/** 投影 checkpoint 的写回节流：两个分支共用。 */
+const projectionCacheSchema = Schema.object({
+	writeEveryEvents: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS).description(localized({
+		zh: "每累计这么多事件写回一次投影 checkpoint。",
+		en: "Write the projection checkpoint back after this many events."
+	})),
+	writeIntervalMs: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS).description(localized({
+		zh: "距离上次写回超过这个间隔（毫秒）时也写一次。",
+		en: "Also write back when this many ms passed since the last one."
+	}))
+}).default({
+	writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
+	writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
+});
 var SessionPersistenceRdb = class extends SessionPersistence {
-	config;
 	static inject = ["sessions"];
 	static Config = Schema.union([Schema.object({
 		type: Schema.const("sqlite"),
-		path: Schema.string().required(),
+		path: Schema.string().required().description(localized({
+			zh: "SQLite 数据库文件路径；`:memory:` 是内存库（进程结束即丢）。",
+			en: "SQLite database file path; `:memory:` keeps it in memory and loses it with the process."
+		})),
 		journalMode: Schema.union([
 			"wal",
 			"delete",
 			"truncate",
 			"persist"
-		]).default("wal"),
-		busyTimeout: Schema.number().step(1).min(0).default(DEFAULT_BUSY_TIMEOUT_MS),
-		projectionCache: Schema.object({
-			writeEveryEvents: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS),
-			writeIntervalMs: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS)
-		}).default({
-			writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
-			writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
-		})
+		]).default("wal").description(localized({
+			zh: "SQLite 日志模式；默认 wal（并发读最好）。",
+			en: "SQLite journal mode; `wal` by default (best concurrent reads)."
+		})),
+		busyTimeout: Schema.number().step(1).min(0).default(DEFAULT_BUSY_TIMEOUT_MS).description(localized({
+			zh: "写锁冲突时的忙等超时（毫秒）。",
+			en: "Busy timeout in ms while a write lock is contended."
+		})),
+		projectionCache: projectionCacheSchema
 	}), Schema.object({
 		type: Schema.const("postgres"),
-		connectionString: Schema.string().required(),
-		schema: Schema.string().default("public"),
-		projectionCache: Schema.object({
-			writeEveryEvents: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS),
-			writeIntervalMs: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS)
-		}).default({
-			writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
-			writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
-		})
-	})]);
+		connectionString: Schema.string().required().description(localized({
+			zh: "PostgreSQL 连接串（含库名与凭证）。",
+			en: "PostgreSQL connection string (database and credentials)."
+		})),
+		schema: Schema.string().default("public").description(localized({
+			zh: "库内的 schema 名；默认 public。",
+			en: "Schema name inside the database; `public` by default."
+		})),
+		projectionCache: projectionCacheSchema
+	})]).description(localized({
+		zh: "会话持久化后端：改这里的连接参数会在这一行重挂时生效（Loader 会重装被改的行）。",
+		en: "Session persistence backend: edits apply when this row is remounted (the Loader re-installs changed rows)."
+	})).volatile();
 	name = "session-rdb";
 	tracker = new RdbBackendTracker(this.name);
 	backend;
@@ -36606,10 +36955,12 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 	reuseEventIds = /* @__PURE__ */ new Map();
 	liveBuffers = /* @__PURE__ */ new Map();
 	liveReady = /* @__PURE__ */ new Map();
+	/** 本次装配用的配置快照（整段 Config 是 volatile，重挂会给新的）。 */
+	config;
 	constructor(ctx, config, injectedBackend) {
 		super(ctx);
-		this.config = config;
-		this.backend = injectedBackend ?? createBackend(config);
+		this.config = config.get();
+		this.backend = injectedBackend ?? createBackend(this.config);
 		this.ready = this.init();
 		this.installLiveRouting(ctx);
 		new SessionBranchRdb(this.ctx);
@@ -36755,7 +37106,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() {
@@ -36774,7 +37125,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;
 	}
@@ -36825,9 +37176,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);
@@ -36841,18 +37194,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) {
@@ -36890,7 +37244,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,
@@ -36915,32 +37269,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) {
@@ -36953,13 +37318,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();
@@ -37189,19 +37555,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
+		};
+		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.count += 1;
+		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()];
@@ -37233,6 +37626,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);
@@ -37240,7 +37634,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,
@@ -37254,7 +37648,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({
@@ -37266,12 +37663,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