@morlay/session-rdb 0.0.19 → 0.0.21-alpha.0

package/dist/{sqlite-DYExtbLo.mjs → sqlite-fpvm5Dzs.mjs}

@@ -1,11 +1,10 @@
-import { g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow } from "./log-DO69NQnn.mjs";
+import { g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow, v as usageRowOf } from "./log-CnYct2Dv.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";
 import { check, index, integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
 import { bigint, check as check$1, index as index$1, integer as integer$1, pgSchema, pgTable, serial, text as text$1, unique as unique$1 } from "drizzle-orm/pg-core";
-import { readdirSync, statSync } from "node:fs";
-import { mkdir, open } from "node:fs/promises";
+import { mkdir, open, readdir, stat } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DatabaseSync } from "node:sqlite";
@@ -198,11 +197,8 @@ const sessions = {
 			type: "integer",
 			notNull: true
 		},
-		/** 归档标记：非空即该会话已归档（毫秒时间戳），NULL 表示未归档。 */
 		f_archived_at: { type: "bigint" },
-		/** 最新会话标题（最后一条 `session/title` 事件的 title），NULL 表示尚无标题。 */
 		f_title: { type: "text" },
-		/** `f_title` 来源事件的稠密 seq（列表 hint 的水位）。 */
 		f_title_seq: { type: "integer" }
 	}
 };
@@ -310,7 +306,6 @@ const sessionEvents$1 = {
 };
 //#endregion
 //#region src/entities/v3/storage-units.ts
-/** storage 域版本账本：域首次打开时写入 descriptor version，其后按 accepted 集合校验。 */
 const storageUnits = {
 	name: "t_storage_units",
 	columns: {
@@ -326,11 +321,6 @@ const storageUnits = {
 };
 //#endregion
 //#region src/entities/v3/workspaces.ts
-/**
-* workspace 域记录表（上游 `workspace` 域 v2 的 `workspaces` 表）：
-* 记录本身拆成语义列；会话归属在 {@link workspaceSessions}（带顺序），
-* 显示顺序由 `f_position` 承载（未进入 `workspaceIds` 的记录为 -1）。
-*/
 const workspaces = {
 	name: "t_workspaces",
 	columns: {
@@ -368,11 +358,6 @@ const workspaces = {
 };
 //#endregion
 //#region src/entities/v3/workspace-sessions.ts
-/**
-* workspace 的会话归属（上游 `workspaceRecord.sessionIds` 的数组顺序）：
-* 一个会话一行，`f_position` 是归属显示顺序。会话 id 有独立索引，可按
-* session 反查归属 workspace。
-*/
 const workspaceSessions = {
 	name: "t_workspace_sessions",
 	columns: {
@@ -403,12 +388,6 @@ const workspaceSessions = {
 };
 //#endregion
 //#region src/entities/v3/workspace-state.ts
-/**
-* workspace 域 global 单例（上游 `workspaceDomainState`）：`initialized` 是
-* 引导标记，`pendingMutation` 拆成操作与目标两列（create / delete 的可恢复
-* 两写标记）。显示顺序（`workspaceIds`）在 `t_workspaces.f_position`，
-* 归档集由 `t_sessions.f_archived_at` 承载（归档不触碰归属槽位）。
-*/
 const workspaceState = {
 	name: "t_workspace_state",
 	columns: {
@@ -427,14 +406,6 @@ const workspaceState = {
 };
 //#endregion
 //#region src/entities/v3/session-projcache-rows.ts
-/**
-* 投影 checkpoint 行（上游 checkpoint 的 `(sessionId, key, ver, seq, val)`
-* 逐行落库）：`f_seq` 是该行的日志水位、`f_ver` 是投影单元的 stateVersion。
-* 行是折出捷径、非权威，版本不匹配时整行丢弃。
-*
-* checkpoint 的日志 identity 不另存一份：它与 `t_sessions` 的行是 1:1，直接
-* 复用该行的 `f_version` / `f_created_at` / `f_cwd` / `f_seed_length` 做校验。
-*/
 const sessionProjcacheRows = {
 	name: "t_session_projcache_row",
 	columns: {
@@ -472,6 +443,53 @@ const sessionProjcacheRows = {
 	indexes: { idx_session_projcache_row_key: { columns: ["f_key"] } }
 };
 //#endregion
+//#region src/entities/v3/event-usage.ts
+/**
+* 用量日志：一条 `assistant/message` 事件一行（按事件行唯一，fork 共享行不重复）。
+* 统计只读这张表，不再逐行解析事件的 JSON；事件行本身仍留在 `t_events`。
+*/
+const eventUsage = {
+	name: "t_event_usage",
+	columns: {
+		f_event_id: {
+			type: "text",
+			primaryKey: true,
+			references: {
+				table: "t_events",
+				column: "f_event_id",
+				onDelete: "cascade"
+			}
+		},
+		f_created_at: {
+			type: "integer",
+			notNull: true
+		},
+		f_provider: { type: "text" },
+		f_model: { type: "text" },
+		f_input_tokens: {
+			type: "integer",
+			notNull: true
+		},
+		f_output_tokens: {
+			type: "integer",
+			notNull: true
+		},
+		f_cache_read_tokens: {
+			type: "integer",
+			notNull: true
+		},
+		f_reasoning_tokens: {
+			type: "integer",
+			notNull: true
+		},
+		f_total_tokens: {
+			type: "integer",
+			notNull: true
+		}
+	},
+	indexes: { idx_event_usage_created_at: { columns: ["f_created_at"] } }
+};
+//#endregion
 //#region src/entities/v3/index.ts
 const sqliteTableDefs = [
 	persistenceState,
@@ -483,7 +501,8 @@ const sqliteTableDefs = [
 	workspaces,
 	workspaceSessions,
 	workspaceState,
-	sessionProjcacheRows
+	sessionProjcacheRows,
+	eventUsage
 ];
 const postgresTableDefs = [
 	persistenceState,
@@ -495,7 +514,8 @@ const postgresTableDefs = [
 	workspaces,
 	workspaceSessions,
 	workspaceState,
-	sessionProjcacheRows
+	sessionProjcacheRows,
+	eventUsage
 ];
 ({ ...sessionEvents$1 }), { ...sessionEvents$1.columns };
 //#endregion
@@ -514,6 +534,7 @@ const tWorkspaces = sqliteTables["t_workspaces"];
 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 DEFAULT_BUSY_TIMEOUT_MS = 5e3;
 function eventKind(event) {
 	switch (event.type) {
@@ -671,27 +692,16 @@ function eventDimensions(event) {
 }
 //#endregion
 //#region src/storage-takeover/repository.ts
-/**
-* storages 接管表的方言无关实现：SQLite 与 PostgreSQL 的 drizzle 查询构建器
-* 共享同一套调用形状（SQLite 走同步 `.all()`/`.get()`/`.run()`，PostgreSQL
-* 走 thenable），差别由本模块的执行 helper 吸收。
-*
-* workspace 域是权威数据：记录、归属、显示顺序与归档集都拆成语义表，每次写入
-* 在介质事务内完成（`host.writeAtomically`），不留部分应用的中间态。
-*/
-/** 多行查询：SQLite 同步 `.all()`，PostgreSQL await。 */
 async function allRows(query) {
 	const q = query;
 	if (typeof q.all === "function") return q.all();
 	return await query;
 }
-/** 单行查询：SQLite 同步 `.get()`，PostgreSQL await 后取首行。 */
 async function oneRow(query) {
 	const q = query;
 	if (typeof q.get === "function") return q.get();
 	return (await query)[0];
 }
-/** 写入语句：SQLite 同步 `.run()`，PostgreSQL await。 */
 async function runQuery(query) {
 	const q = query;
 	if (typeof q.run === "function") {
@@ -700,7 +710,6 @@ async function runQuery(query) {
 	}
 	await query;
 }
-/** 一行会话元数据 → 上游 `CheckpointIdentity`。 */
 function identityOfSession(row) {
 	return {
 		formatVersion: row.fVersion,
@@ -710,11 +719,9 @@ function identityOfSession(row) {
 		...row.fSeedLength === null ? {} : { inheritedEventCount: SessionLogOffset(row.fSeedLength) }
 	};
 }
-/** 存储的整数水位 → 上游 seq cursor（-1 是空日志哨兵）。 */
 function seqCursor(seq) {
 	return seq === -1 ? -1 : SessionSeq(seq);
 }
-/** 两写标记的两列 → 上游 `pendingMutation`（未知操作按缺失处理）。 */
 function pendingMutationOf(row) {
 	const operation = row.fPendingOperation;
 	if (operation !== "create" && operation !== "delete") return void 0;
@@ -723,11 +730,6 @@ function pendingMutationOf(row) {
 		workspaceId: row.fPendingWorkspaceId ?? ""
 	};
 }
-/**
-* 构建一个介质的 storages 接管访问层。
-* @param host - 介质句柄、方言表对象与事务执行器。
-* @returns 方言无关的访问层。
-*/
 function createStorageRepository(host) {
 	const tables = host.tables;
 	const tUnits = tables["t_storage_units"];
@@ -736,7 +738,6 @@ function createStorageRepository(host) {
 	const tWorkspaceSessions = tables["t_workspace_sessions"];
 	const tWorkspaceState = tables["t_workspace_state"];
 	const tProjcacheRows = tables["t_session_projcache_row"];
-	/** checkpoint identity 的列投影：直接复用会话行，不再单存记录头。 */
 	const sessionIdentity = {
 		fSessionId: tSessions.fSessionId,
 		fVersion: tSessions.fVersion,
@@ -905,9 +906,9 @@ function createStorageRepository(host) {
 			await runQuery(db.delete(tProjcacheRows).where(inArray(tProjcacheRows.fSessionId, stale.map((row) => row.fSessionId))));
 			return stale.length;
 		},
-		...host.dbSync === void 0 ? {} : {
-			readProjcacheSync: (sessionId) => {
-				const db = host.dbSync();
+		...host.dbDirect === void 0 ? {} : {
+			readProjcacheDirect: (sessionId) => {
+				const db = host.dbDirect();
 				const stored = db.select().from(tProjcacheRows).where(eq(tProjcacheRows.fSessionId, sessionId)).all();
 				if (stored.length === 0) return void 0;
 				const session = db.select(sessionIdentity).from(tSessions).where(eq(tSessions.fSessionId, sessionId)).get();
@@ -924,8 +925,8 @@ function createStorageRepository(host) {
 					rows
 				};
 			},
-			readSessionTitleSync: (sessionId) => {
-				const row = host.dbSync().select({
+			readSessionTitleDirect: (sessionId) => {
+				const row = host.dbDirect().select({
 					fTitle: tSessions.fTitle,
 					fTitleSeq: tSessions.fTitleSeq
 				}).from(tSessions).where(eq(tSessions.fSessionId, sessionId)).get();
@@ -940,7 +941,45 @@ function createStorageRepository(host) {
 }
 //#endregion
 //#region src/sqlite.ts
-/** drizzle-kit 生成的迁移目录（随包根 drizzle/ 发布；src/dist 形态经相对 URL 统一解析）。 */
+/**
+* 一次性回填：旧库的用量从未写过 `t_event_usage`，建表后按事件行补一次（幂等：表非空即跳过）。
+*/
+function backfillEventUsage(db) {
+	if (db.prepare("SELECT count(*) AS n FROM t_event_usage").get().n > 0) return;
+	db.exec(`INSERT OR IGNORE INTO t_event_usage (
+      f_event_id, f_created_at, f_provider, f_model,
+      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,
+           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')),
+           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'),
+                    json_extract(e.f_data, '$.usage.outputTokens'), 0),
+           coalesce(json_extract(e.f_data, '$.data.usage.cacheReadTokens'),
+                    json_extract(e.f_data, '$.usage.cacheReadTokens'), 0),
+           coalesce(json_extract(e.f_data, '$.data.usage.reasoningTokens'),
+                    json_extract(e.f_data, '$.usage.reasoningTokens'), 0),
+           coalesce(json_extract(e.f_data, '$.data.usage.totalTokens'),
+                    json_extract(e.f_data, '$.usage.totalTokens'), 0)
+      FROM t_events e
+     WHERE e.f_type = 'assistant/message'
+       AND (json_extract(e.f_data, '$.data.usage') IS NOT NULL
+            OR json_extract(e.f_data, '$.usage') IS NOT NULL)`);
+}
+/** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
+function totalsOf(row) {
+	return {
+		events: row.events,
+		inputTokens: row.input_tokens ?? 0,
+		outputTokens: row.output_tokens ?? 0,
+		cacheReadTokens: row.cache_read_tokens ?? 0,
+		reasoningTokens: row.reasoning_tokens ?? 0,
+		totalTokens: row.total_tokens ?? 0
+	};
+}
 const sqliteMigrationsDir = fileURLToPath(new URL("../drizzle/sqlite/", import.meta.url));
 const sqliteTxQueues = /* @__PURE__ */ new Map();
 function enqueueSqliteTx(path, fn) {
@@ -955,14 +994,15 @@ async function createDatabaseFile(path) {
 		if (error.code !== "EEXIST") throw error;
 	}
 }
-function openDatabase(path, journalMode, busyTimeout = DEFAULT_BUSY_TIMEOUT_MS) {
+async function openDatabase(path, journalMode, busyTimeout = DEFAULT_BUSY_TIMEOUT_MS) {
 	const db = new DatabaseSync(path);
 	try {
 		configureDatabase(db, path, journalMode, busyTimeout);
 		const dbx = drizzle({ client: db });
 		const { user_version: onDisk } = db.prepare("PRAGMA user_version").get();
-		if (onDisk === 2 && !hasMigrationsTable(db)) baselineV2(db);
+		if (onDisk === 2 && !hasMigrationsTable(db)) await baselineV2(db);
 		migrate(dbx, { migrationsFolder: sqliteMigrationsDir });
+		backfillEventUsage(db);
 		dbx.insert(tPersistenceState).values({
 			fSingleton: 1,
 			fStoreId: randomUUID()
@@ -978,9 +1018,8 @@ function openDatabase(path, journalMode, busyTimeout = DEFAULT_BUSY_TIMEOUT_MS)
 function hasMigrationsTable(db) {
 	return db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = '__drizzle_migrations'").get() !== void 0;
 }
-/** 标记 v2 baseline 已应用（迁移表 v1 结构：id/hash/created_at/name/applied_at）。 */
-function baselineV2(db) {
-	const dir = readdirSync(sqliteMigrationsDir).find((name) => name.endsWith("_v2_initial"));
+async function baselineV2(db) {
+	const dir = (await readdir(sqliteMigrationsDir)).find((name) => name.endsWith("_v2_initial"));
 	if (dir === void 0) throw new Error("missing v2 baseline migration in drizzle/sqlite");
 	db.exec(`
     CREATE TABLE __drizzle_migrations (
@@ -1013,7 +1052,6 @@ var SqliteBackend = class SqliteBackend {
 	options;
 	kind = "sqlite";
 	storeIdentity;
-	/** storages 接管表访问层；句柄在 open() 完成后解析。 */
 	storage;
 	dbPath = "";
 	db;
@@ -1029,7 +1067,7 @@ var SqliteBackend = class SqliteBackend {
 		this.dbReady.catch(() => {});
 		this.storage = createStorageRepository({
 			db: () => this.dbReady,
-			dbSync: () => {
+			dbDirect: () => {
 				if (this.db === void 0) throw new Error("sqlite session database is not open");
 				return this.db;
 			},
@@ -1077,16 +1115,15 @@ var SqliteBackend = class SqliteBackend {
 			await createDatabaseFile(actual);
 		}
 		await enqueueSqliteTx(actual, async () => {
-			this.db = drizzle({ client: openDatabase(actual, this.options.journalMode, this.options.busyTimeout) });
+			this.db = drizzle({ client: await openDatabase(actual, this.options.journalMode, this.options.busyTimeout) });
 			migrate(this.db, { migrationsFolder: sqliteMigrationsDir });
 		});
 		try {
 			const row = this.db.select({ fStoreId: tPersistenceState.fStoreId }).from(tPersistenceState).where(eq(tPersistenceState.fSingleton, 1)).get();
-			/* v8 ignore next -- openDatabase inserts the singleton before returning. */
 			if (row === void 0) throw new Error(`session database at "${actual}" has no store identity`);
 			if (row.fStoreId.length === 0) throw new Error(`session database at "${actual}" has no valid store identity`);
 			if (actual !== ":memory:") {
-				const identity = statSync(actual, { bigint: true });
+				const identity = await stat(actual, { bigint: true });
 				this.storeIdentity = `file:${identity.dev}:${identity.ino}:${identity.birthtimeNs}:store:${row.fStoreId}`;
 			} else this.storeIdentity = `memory:store:${row.fStoreId}`;
 		} catch (error) {
@@ -1104,6 +1141,12 @@ var SqliteBackend = class SqliteBackend {
 	async getEventRows(id, fromSequence) {
 		return (fromSequence === void 0 ? this.eventRows().where(eq(tSessionEvents.fSessionId, id)) : this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence)))).orderBy(tSessionEvents.fSequence).all();
 	}
+	async getEventTypeAt(id, sequence) {
+		return this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get()?.fType;
+	}
+	async getEventTypesBefore(id, beforeSequence, limit) {
+		return this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), lt(tSessionEvents.fSequence, beforeSequence))).orderBy(desc(tSessionEvents.fSequence)).limit(limit).all();
+	}
 	async listSessions() {
 		return this.db.select().from(tSessions).all();
 	}
@@ -1115,7 +1158,6 @@ var SqliteBackend = class SqliteBackend {
 				this.db.$client.exec("COMMIT");
 				return result;
 			} catch (error) {
-				/* v8 ignore start */
 				try {
 					this.db.$client.exec("ROLLBACK");
 				} catch {}
@@ -1134,7 +1176,9 @@ var SqliteBackend = class SqliteBackend {
 		bumpRevision: (id) => this.bumpRevision(id),
 		refreshTitle: (id) => this.refreshTitle(id),
 		deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(id, fromSequence),
-		getPrevBridge: (id, sequence) => this.getPrevBridge(id, sequence)
+		getPrevBridge: (id, sequence) => this.getPrevBridge(id, sequence),
+		deleteSession: (id) => this.deleteSession(id),
+		deleteSessions: (ids) => this.deleteSessions(ids)
 	};
 	async upsertSession(storage, incarnation) {
 		this.db.insert(tSessions).values(sessionInsertRow(storage, incarnation)).onConflictDoUpdate({
@@ -1147,13 +1191,11 @@ var SqliteBackend = class SqliteBackend {
 			fHeadEventId: tSessions.fHeadEventId,
 			fHeadSequence: tSessions.fHeadSequence
 		}).from(tSessions).where(eq(tSessions.fSessionId, id)).get();
-		/* v8 ignore next -- appendBatch/commitRepair always materialize the row before reading the head */
 		if (head === void 0) throw new Error(`session "${id}" has no materialized row`);
 		return head;
 	}
 	async getSeedLength(id) {
 		const row = this.db.select({ fSeedLength: tSessions.fSeedLength }).from(tSessions).where(eq(tSessions.fSessionId, id)).get();
-		/* v8 ignore next -- rewind always materializes the row before reading the seed length */
 		if (row === void 0) throw new Error(`session "${id}" has no materialized row`);
 		return row.fSeedLength;
 	}
@@ -1164,6 +1206,11 @@ var SqliteBackend = class SqliteBackend {
 	async insertEvents(events) {
 		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();
 	}
 	async insertBridges(rows) {
 		if (rows.length === 0) return;
@@ -1178,7 +1225,6 @@ var SqliteBackend = class SqliteBackend {
 	async bumpRevision(id) {
 		this.db.update(tSessions).set({ fRevision: sql`${tSessions.fRevision} + 1` }).where(eq(tSessions.fSessionId, id)).run();
 	}
-	/** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
 	async refreshTitle(id) {
 		const row = this.db.select({
 			fSequence: tSessionEvents.fSequence,
@@ -1199,6 +1245,90 @@ var SqliteBackend = class SqliteBackend {
 			fSequence: tSessionEvents.fSequence
 		}).from(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get();
 	}
+	async deleteSession(id) {
+		this.db.delete(tSessionEvents).where(eq(tSessionEvents.fSessionId, id)).run();
+		this.db.delete(tWorkspaceSessions).where(eq(tWorkspaceSessions.fSessionId, id)).run();
+		this.db.delete(tSessionProjcacheRows).where(eq(tSessionProjcacheRows.fSessionId, id)).run();
+		this.db.delete(tSessions).where(eq(tSessions.fSessionId, id)).run();
+	}
+	/** 事件行可能被多个会话共享（fork 派生），所以孤儿只能在全库范围内判定。 */
+	async collectOrphans() {
+		const referenced = this.db.select({ fEventId: tSessionEvents.fEventId }).from(tSessionEvents);
+		const info = this.db.delete(tEvents).where(notInArray(tEvents.fEventId, referenced)).run();
+		this.db.delete(tEventUsage).where(notInArray(tEventUsage.fEventId, this.db.select({ fEventId: tEvents.fEventId }).from(tEvents))).run();
+		return Number(info.changes);
+	}
+	/** 父会话被删后留下的 subagent 会话：父已不在表里，或本来就没有父。 */
+	async listOrphanSubagentSessions() {
+		return this.db.$client.prepare(`SELECT f_session_id AS id FROM t_sessions
+         WHERE f_origin = 'subagent'
+           AND (f_parent_session IS NULL
+                OR f_parent_session NOT IN (SELECT f_session_id FROM t_sessions))`).all().map((row) => row.id);
+	}
+	async deleteSessions(ids) {
+		if (ids.length === 0) return 0;
+		this.db.delete(tSessionEvents).where(inArray(tSessionEvents.fSessionId, ids)).run();
+		this.db.delete(tWorkspaceSessions).where(inArray(tWorkspaceSessions.fSessionId, ids)).run();
+		this.db.delete(tSessionProjcacheRows).where(inArray(tSessionProjcacheRows.fSessionId, ids)).run();
+		const info = this.db.delete(tSessions).where(inArray(tSessions.fSessionId, ids)).run();
+		return Number(info.changes);
+	}
+	/** 用量聚合：只读 `t_event_usage`；可选只算 `sinceMs` 之后的事件行。 */
+	async usageReport(sinceMs) {
+		const sinceClause = sinceMs === void 0 ? "" : " AND u.f_created_at >= ?";
+		const sinceParams = sinceMs === void 0 ? [] : [sinceMs];
+		const buckets = this.db.$client.prepare(`SELECT date(u.f_created_at / 1000, 'unixepoch', 'localtime') AS day,
+                u.f_provider AS provider,
+                u.f_model AS model,
+                EXISTS (SELECT 1 FROM t_session_events sb
+                          JOIN t_sessions ss ON ss.f_session_id = sb.f_session_id
+                         WHERE sb.f_event_id = u.f_event_id AND ss.f_origin = 'subagent') AS subagent,
+                count(*) AS events,
+                sum(u.f_input_tokens) AS input_tokens,
+                sum(u.f_output_tokens) AS output_tokens,
+                sum(u.f_cache_read_tokens) AS cache_read_tokens,
+                sum(u.f_reasoning_tokens) AS reasoning_tokens,
+                sum(u.f_total_tokens) AS total_tokens
+           FROM t_event_usage u
+          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${sinceClause}
+          GROUP BY day, provider, model, subagent`).all(...sinceParams);
+		const sessions = this.db.$client.prepare(`SELECT b.f_session_id AS session_id,
+                s.f_title AS title,
+                (s.f_origin = 'subagent') AS subagent,
+                (s.f_archived_at IS NOT NULL) AS archived,
+                count(*) AS events,
+                sum(u.f_input_tokens) AS input_tokens,
+                sum(u.f_output_tokens) AS output_tokens,
+                sum(u.f_cache_read_tokens) AS cache_read_tokens,
+                sum(u.f_reasoning_tokens) AS reasoning_tokens,
+                sum(u.f_total_tokens) AS total_tokens
+           FROM t_session_events b
+           JOIN t_event_usage u ON u.f_event_id = b.f_event_id
+           JOIN t_sessions s ON s.f_session_id = b.f_session_id
+          WHERE 1 = 1${sinceClause}
+          GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at`).all(...sinceParams);
+		return {
+			buckets: buckets.map((row) => ({
+				day: row.day,
+				provider: row.provider,
+				model: row.model,
+				subagent: row.subagent === 1,
+				...totalsOf(row)
+			})),
+			sessions: sessions.map((row) => ({
+				sessionId: row.session_id,
+				title: row.title,
+				subagent: row.subagent === 1,
+				archived: row.archived === 1,
+				...totalsOf(row)
+			}))
+		};
+	}
+	async vacuum() {
+		await enqueueSqliteTx(this.dbPath, async () => {
+			this.db.$client.exec("VACUUM");
+		});
+	}
 	eventRows() {
 		return this.db.select({
 			fEventId: tSessionEvents.fEventId,
@@ -1215,4 +1345,4 @@ var SqliteBackend = class SqliteBackend {
 	}
 };
 //#endregion
-export { WriteGuard as S, tWorkspaceSessions as _, EVENT_ENCODING as a, postgresTableDefs as b, eventDimensions as c, tPersistenceState as d, tSchemaMeta as f, tStorageUnits as g, tSessions as h, DEFAULT_BUSY_TIMEOUT_MS as i, eventKind as l, tSessionProjcacheRows as m, openDatabase as n, SCHEMA_VERSION as o, tSessionEvents as p, createStorageRepository as r, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as s, SqliteBackend as t, tEvents as u, tWorkspaceState as v, toPostgresSchema as x, tWorkspaces as y };
+export { WriteGuard as C, toPostgresSchema as S, tStorageUnits as _, EVENT_ENCODING as a, tWorkspaces as b, eventDimensions as c, tEvents as d, tPersistenceState as f, tSessions as g, tSessionProjcacheRows as h, DEFAULT_BUSY_TIMEOUT_MS as i, eventKind as l, tSessionEvents 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, tWorkspaceSessions as v, postgresTableDefs as x, tWorkspaceState as y };