@morlay/session-rdb 0.1.9 → 0.1.10-alpha.2

package/dist/backend-rdb-BDCntVDy.mjs

@@ -0,0 +1,1341 @@
+import { n as titleOfEventData, o as sessionHeaderColumns, s as sessionInsertColumns } from "./export-CfJQjQfr.mjs";
+import { COUNTED_EVENT_TYPES, localDayKey } from "./usage.mjs";
+import { E, and, count, defineCatalog, defineTable, eq, gte, isNull, lt, notInSubquery, or, sum } from "@morlay/rdbkit";
+// src/version.ts
+/** 库结构版本（写入 SQLite 的 `user_version`，不匹配即拒绝打开）。 */
+const SCHEMA_VERSION = 3;
+/** SQLite 文件头的 application id（`0x44534850` = "DSHP"），防止误开别的库。 */
+const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
+/** 事件 `f_data` 的编码（目前只有 JSON）。 */
+const EVENT_ENCODING = "json";
+/** SQLite 的默认 busy timeout（毫秒）。 */
+const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+// src/entities/v3/persistence-state.ts
+const persistenceState = defineTable({
+	name: "t_persistence_state",
+	columns: {
+		f_singleton: {
+			type: "integer",
+			primaryKey: true
+		},
+		f_store_id: {
+			type: "text",
+			notNull: true
+		}
+	},
+	checks: { ck_persistence_state_singleton: { expression: "f_singleton = 1" } }
+});
+// src/entities/v3/schema-meta.ts
+const schemaMeta = defineTable({
+	name: "t_schema_meta",
+	columns: {
+		f_key: {
+			type: "text",
+			primaryKey: true
+		},
+		f_value: {
+			type: "text",
+			notNull: true
+		}
+	}
+});
+// src/entities/v3/sessions.ts
+const sessions = defineTable({
+	name: "t_sessions",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_session_id: {
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		f_head_event_id: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_head_sequence: {
+			type: "integer",
+			notNull: true,
+			default: -1
+		},
+		f_version: {
+			type: "integer",
+			notNull: true
+		},
+		f_created_at: {
+			type: "bigint",
+			notNull: true
+		},
+		f_cwd: { type: "text" },
+		f_parent_session: { type: "text" },
+		f_seed_length: { type: "integer" },
+		f_origin: { type: "text" },
+		f_delegation_depth: { type: "integer" },
+		f_agent_preset: { type: "text" },
+		f_incarnation: {
+			type: "text",
+			notNull: true
+		},
+		f_revision: {
+			type: "integer",
+			notNull: true
+		},
+		f_archived_at: { type: "bigint" },
+		f_pinned_seq: { type: "integer" },
+		f_last_event_at: { type: "bigint" },
+		f_title: { type: "text" },
+		f_title_seq: { type: "integer" }
+	}
+});
+// src/entities/v3/events.ts
+const events = defineTable({
+	name: "t_events",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_event_id: {
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		f_parent_id: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_type: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_kind: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_role: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_name: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_action_id: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_encoding: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_data: {
+			type: "text",
+			notNull: true
+		},
+		f_created_at: {
+			type: "bigint",
+			notNull: true,
+			default: 0
+		}
+	},
+	indexes: {
+		idx_events_kind: { columns: ["f_kind"] },
+		idx_events_role: { columns: ["f_role"] },
+		idx_events_name: { columns: ["f_name"] },
+		idx_events_action_id: { columns: ["f_action_id"] }
+	}
+});
+// src/entities/v3/session-events.ts
+const sessionEvents = defineTable({
+	name: "t_session_events",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_session_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_sessions",
+				column: "f_session_id",
+				onDelete: "cascade"
+			}
+		},
+		f_event_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_events",
+				column: "f_event_id",
+				onDelete: "cascade"
+			}
+		},
+		f_sequence: {
+			type: "integer",
+			notNull: true
+		},
+		f_surface_op: { type: "text" }
+	},
+	uniques: { uq_session_events_session_sequence: { columns: ["f_session_id", "f_sequence"] } },
+	indexes: { idx_session_events_event_id: { columns: ["f_event_id"] } }
+});
+// src/entities/v3/storage-units.ts
+const storageUnits = defineTable({
+	name: "t_storage_units",
+	columns: {
+		f_name: {
+			type: "text",
+			primaryKey: true
+		},
+		f_version: {
+			type: "integer",
+			notNull: true
+		}
+	}
+});
+// src/entities/v3/storage-records.ts
+const storageRecords = defineTable({
+	name: "t_storage_records",
+	columns: {
+		f_domain: {
+			type: "text",
+			notNull: true
+		},
+		f_table: {
+			type: "text",
+			notNull: true
+		},
+		f_key: {
+			type: "text",
+			notNull: true
+		},
+		f_value: {
+			type: "text",
+			notNull: true
+		}
+	},
+	uniques: { uq_storage_records_domain_table_key: { columns: [
+		"f_domain",
+		"f_table",
+		"f_key"
+	] } }
+});
+// src/entities/v3/session-projcache-rows.ts
+const sessionProjcacheRows = defineTable({
+	name: "t_session_projcache_row",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_session_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_sessions",
+				column: "f_session_id",
+				onDelete: "cascade"
+			}
+		},
+		f_key: {
+			type: "text",
+			notNull: true
+		},
+		f_ver: {
+			type: "integer",
+			notNull: true
+		},
+		f_seq: {
+			type: "integer",
+			notNull: true
+		},
+		f_val: {
+			type: "text",
+			notNull: true
+		}
+	},
+	uniques: { uq_session_projcache_row_session_key: { columns: ["f_session_id", "f_key"] } },
+	indexes: { idx_session_projcache_row_key: { columns: ["f_key"] } }
+});
+// src/entities/v3/event-usage.ts
+const eventUsage = defineTable({
+	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: "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,
+			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
+		}
+	},
+	indexes: { idx_event_usage_created_at: { columns: ["f_created_at"] } }
+});
+// src/entities/v3/session-usage.ts
+const sessionUsage = defineTable({
+	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"
+	] } }
+});
+// src/entities/v3/session-counts.ts
+const sessionCounts = defineTable({
+	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"] } }
+});
+// src/entities/index.ts
+/** 库结构的唯一事实来源（DDL、迁移与表句柄都从它算出来）。 */
+const catalog = defineCatalog([
+	persistenceState,
+	schemaMeta,
+	sessions,
+	events,
+	sessionEvents,
+	storageUnits,
+	storageRecords,
+	sessionProjcacheRows,
+	eventUsage,
+	sessionUsage,
+	sessionCounts
+]);
+// src/session-ops.ts
+/**
+* 会话读的小操作：经 `Database` 句柄调用——或为打开后的 base 实例，或为事务内的 scoped 实例，
+* 执行面由调用方决定，这里不持有连接（与 Go 的 `session.T` 一致）。
+*/
+/**
+* upsert 累加：冲突时「列 = 列 + 新值」。
+*
+* 列引用必须带表名：PostgreSQL 的 `ON CONFLICT … DO UPDATE` 里裸列名会与 `excluded` 的同名列歧义
+*（`column reference "f_turns" is ambiguous`），SQLite 两种写法都认。
+*/
+function accumulated(table, column) {
+	return E.add(E.column(column, table), E.excluded(column));
+}
+/** 会话行的 head 指针（不存在时 fail loud）。 */
+async function readHead(rdb, id) {
+	const table = sessions.table(rdb);
+	for await (const row of table.select({
+		fHeadEventId: table.f_head_event_id,
+		fHeadSequence: table.f_head_sequence
+	}).where(E.eq(table.f_session_id, id))) return row;
+	throw new Error(`session "${id}" has no materialized row`);
+}
+/** 会话行的 seed 长度（不存在时 fail loud）。 */
+async function readSeedLength(rdb, id) {
+	const table = sessions.table(rdb);
+	for await (const row of table.select({ fSeedLength: table.f_seed_length }).where(E.eq(table.f_session_id, id))) return row.fSeedLength;
+	throw new Error(`session "${id}" has no materialized row`);
+}
+/** 指定序号上的桥接行（rewind 的边界探测）。 */
+async function readPrevBridge(rdb, id, sequence) {
+	const links = sessionEvents.table(rdb);
+	for await (const row of links.select({
+		fEventId: links.f_event_id,
+		fSequence: links.f_sequence
+	}).where(E.and(E.eq(links.f_session_id, id), E.eq(links.f_sequence, sequence))).limit(1)) return row;
+}
+/** 回收没有任何桥接行的事件行（以及跟着走的用量行），返回回收的事件行数。 */
+async function collectOrphans(rdb) {
+	const links = sessionEvents.table(rdb);
+	const eventsTable = events.table(rdb);
+	const orphans = [];
+	for await (const row of eventsTable.select({ id: eventsTable.f_event_id }).where(E.notInSubquery(eventsTable.f_event_id, links.select({ id: links.f_event_id }).toFragment()))) orphans.push(row.id);
+	if (orphans.length === 0) return 0;
+	await eventsTable.delete(E.inList(eventsTable.f_event_id, orphans));
+	const usageTable = eventUsage.table(rdb);
+	await usageTable.delete(E.notInSubquery(usageTable.f_event_id, eventsTable.select({ id: eventsTable.f_event_id }).toFragment()));
+	return orphans.length;
+}
+/**
+* 重算用量行的两个归属标记（`f_referenced` / `f_subagent`）。
+*
+* 表达式是方言相关的（SQLite 直接用 `EXISTS`，PG 要 `::int`），由调用方给；分批是为了绑定参数上限。
+*/
+async function refreshEventUsageFlags$1(rdb, eventIds, flags, chunkSize = 400) {
+	const usage = eventUsage.table(rdb);
+	for (let at = 0; at < eventIds.length; at += chunkSize) {
+		const chunk = eventIds.slice(at, at + chunkSize);
+		await usage.update({
+			f_referenced: flags.referenced,
+			f_subagent: flags.subagent
+		}, E.inList(usage.f_event_id, chunk));
+	}
+}
+/** 用量旁路累加：同键累加 token，不同键插新行（`ON CONFLICT … DO UPDATE SET 列 = 列 + excluded.列`）。 */
+async function incrementSessionUsage$1(rdb, id, buckets) {
+	if (buckets.length === 0) return;
+	const usage = sessionUsage.table(rdb);
+	for (const bucket of buckets) await usage.upsertExpr({
+		f_session_id: id,
+		f_day: bucket.day,
+		f_provider: bucket.provider ?? "",
+		f_model: bucket.model ?? "",
+		f_input_tokens: bucket.inputTokens,
+		f_output_tokens: bucket.outputTokens,
+		f_cache_read_tokens: bucket.cacheReadTokens,
+		f_reasoning_tokens: bucket.reasoningTokens,
+		f_total_tokens: bucket.totalTokens
+	}, [
+		"f_session_id",
+		"f_day",
+		"f_provider",
+		"f_model"
+	], {
+		f_input_tokens: accumulated(usage.name, "f_input_tokens"),
+		f_output_tokens: accumulated(usage.name, "f_output_tokens"),
+		f_cache_read_tokens: accumulated(usage.name, "f_cache_read_tokens"),
+		f_reasoning_tokens: accumulated(usage.name, "f_reasoning_tokens"),
+		f_total_tokens: accumulated(usage.name, "f_total_tokens")
+	});
+}
+/** 活动计数累加：同键累加，不同键插新行。 */
+async function incrementSessionCounts$1(rdb, id, buckets) {
+	if (buckets.length === 0) return;
+	const counts = sessionCounts.table(rdb);
+	for (const bucket of buckets) await counts.upsertExpr({
+		f_session_id: id,
+		f_day: bucket.day,
+		f_turns: bucket.turns,
+		f_steps: bucket.steps,
+		f_user_inputs: bucket.userInputs,
+		f_tool_calls: bucket.toolCalls
+	}, ["f_session_id", "f_day"], {
+		f_turns: accumulated(counts.name, "f_turns"),
+		f_steps: accumulated(counts.name, "f_steps"),
+		f_user_inputs: accumulated(counts.name, "f_user_inputs"),
+		f_tool_calls: accumulated(counts.name, "f_tool_calls")
+	});
+}
+/** 删掉一个会话的两张统计行（重建与删除路径共用）。 */
+async function deleteSessionStats$1(rdb, id) {
+	const usage = sessionUsage.table(rdb);
+	await usage.delete(E.eq(usage.f_session_id, id));
+	const counts = sessionCounts.table(rdb);
+	await counts.delete(E.eq(counts.f_session_id, id));
+}
+/**
+* 按事件行重算一个会话的两张统计表。
+*
+* 查询源由调用方按表句柄构造（本地日、JSON 提取都是 rdbkit 的表达式）；插入列来自表定义。
+*/
+async function rebuildSessionStats$1(rdb, id, selectSql) {
+	await deleteSessionStats$1(rdb, id);
+	await rdb.table(sessionUsage).insertFromSelect([
+		"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"
+	], selectSql.usage);
+	await rdb.table(sessionCounts).insertFromSelect([
+		"f_session_id",
+		"f_day",
+		"f_turns",
+		"f_steps",
+		"f_user_inputs",
+		"f_tool_calls"
+	], selectSql.counts);
+}
+/** 用量总览的第一段：按「本地日 × 模型 × 是否子代理」聚合 token（只算被引用的用量行）。 */
+async function usageBuckets(rdb, sinceMs) {
+	const usage = eventUsage.table(rdb);
+	const rows = [];
+	for await (const row of usage.select({
+		day: usage.f_day,
+		provider: usage.f_provider,
+		model: usage.f_model,
+		subagent: usage.f_subagent,
+		input_tokens: sum("f_input_tokens"),
+		output_tokens: sum("f_output_tokens"),
+		cache_read_tokens: sum("f_cache_read_tokens"),
+		reasoning_tokens: sum("f_reasoning_tokens"),
+		total_tokens: sum("f_total_tokens")
+	}).where(sinceMs === void 0 ? E.eq(usage.f_referenced, 1) : E.and(E.eq(usage.f_referenced, 1), E.gte(usage.f_created_at, sinceMs))).groupBy("f_day", "f_provider", "f_model", "f_subagent")) rows.push(row);
+	return rows;
+}
+/** 用量总览的第二段：按「是否子代理」聚合 token（人类 / 子代理两个口径）。 */
+async function usageTokenScope(rdb, sinceMs) {
+	const usage = eventUsage.table(rdb);
+	const rows = [];
+	for await (const row of usage.select({
+		subagent: usage.f_subagent,
+		input_tokens: sum("f_input_tokens"),
+		output_tokens: sum("f_output_tokens"),
+		cache_read_tokens: sum("f_cache_read_tokens"),
+		reasoning_tokens: sum("f_reasoning_tokens"),
+		total_tokens: sum("f_total_tokens")
+	}).where(sinceMs === void 0 ? E.eq(usage.f_referenced, 1) : E.and(E.eq(usage.f_referenced, 1), E.gte(usage.f_created_at, sinceMs))).groupBy("f_subagent")) rows.push(row);
+	return rows;
+}
+/** 用量总览的第四段：按会话聚合 token（带上标题 / 是否子代理 / 是否归档）。 */
+async function usageSessionTokens(rdb, sinceMs) {
+	const usage = sessionUsage.table(rdb);
+	const sessionsTable = sessions.table(rdb);
+	const rows = [];
+	for await (const row of usage.select({
+		session_id: usage.f_session_id,
+		title: sessionsTable.f_title,
+		subagent: E.toInt(E.eq(sessionsTable.f_origin, "subagent")),
+		archived: E.toInt(E.isNotNull(sessionsTable.f_archived_at)),
+		input_tokens: sum("f_input_tokens"),
+		output_tokens: sum("f_output_tokens"),
+		cache_read_tokens: sum("f_cache_read_tokens"),
+		reasoning_tokens: sum("f_reasoning_tokens"),
+		total_tokens: sum("f_total_tokens")
+	}).join(sessions, E.eq(usage.f_session_id, sessionsTable.f_session_id)).where(sinceMs === void 0 ? E.always() : E.gte(usage.f_day, localDayKey(sinceMs))).groupBy(usage.f_session_id, sessionsTable.f_title, sessionsTable.f_origin, sessionsTable.f_archived_at)) rows.push(row);
+	return rows;
+}
+/** 用量总览的第五段：按会话聚合活动计数。 */
+async function usageSessionCounts(rdb, sinceMs) {
+	const counts = sessionCounts.table(rdb);
+	const rows = [];
+	for await (const row of counts.select({
+		session_id: counts.f_session_id,
+		turns: sum("f_turns"),
+		steps: sum("f_steps"),
+		user_inputs: sum("f_user_inputs"),
+		tool_calls: sum("f_tool_calls")
+	}).where(sinceMs === void 0 ? E.always() : E.gte(counts.f_day, localDayKey(sinceMs))).groupBy("f_session_id")) rows.push(row);
+	return rows;
+}
+/** 用量总览的第三段：按「是否子代理」聚合活动计数（只算有用量行的会话）。 */
+async function usageActivityScope(rdb, sinceMs) {
+	const counts = sessionCounts.table(rdb);
+	const sessionsTable = sessions.table(rdb);
+	const usageSessions = sessionUsage.table(rdb);
+	const subagentExpr = E.toInt(E.eq(sessionsTable.f_origin, "subagent"));
+	const rows = [];
+	for await (const row of counts.select({
+		subagent: subagentExpr,
+		turns: sum("f_turns"),
+		steps: sum("f_steps"),
+		user_inputs: sum("f_user_inputs"),
+		tool_calls: sum("f_tool_calls")
+	}).join(sessions, E.eq(counts.f_session_id, sessionsTable.f_session_id)).where(E.and(E.exists(usageSessions.select({ one: usageSessions.f_session_id }).where(E.eq(usageSessions.f_session_id, counts.f_session_id)).toFragment()), sinceMs === void 0 ? E.always() : E.gte(counts.f_day, localDayKey(sinceMs)))).groupBy(sessionsTable.f_origin)) rows.push(row);
+	return rows;
+}
+/**
+* 会话列表：分页返回会话行（含 workspace 标题由调用方补），并给出总数。
+*
+* 搜索是「标题模糊匹配 或 workspace 标题命中的会话 id」，排序用物化列
+* `f_last_event_at`（没有事件的会话回落 createdAt）。
+*/
+async function listSessionRows$1(rdb, args) {
+	const table = sessions.table(rdb);
+	const like = `%${args.needle}%`;
+	const search = args.needle === "" ? E.always() : E.like(E.lower(E.coalesce(table.f_title, "")), like);
+	const titleHit = args.titleMatches.length === 0 ? [] : [E.inList(table.f_session_id, args.titleMatches)];
+	const where = E.and(E.or(search, ...titleHit), args.includeSubagents ? E.always() : E.ne(E.coalesce(table.f_origin, ""), "subagent"));
+	const items = [];
+	for await (const row of table.select({
+		session_id: table.f_session_id,
+		title: table.f_title,
+		origin: table.f_origin,
+		cwd: table.f_cwd,
+		created_at: table.f_created_at,
+		archived: E.toInt(E.isNotNull(table.f_archived_at)),
+		updated_at: E.coalesce(table.f_last_event_at, table.f_created_at)
+	}).where(where).orderBy(E.column("updated_at"), "desc").orderBy(table.f_session_id).limit(args.limit).offset(args.offset)) items.push(row);
+	let total = 0;
+	for await (const row of table.select({ n: count() }).where(where)) total = Number(row.n);
+	return {
+		items,
+		total
+	};
+}
+// src/storage-takeover/read-model.ts
+function createReadModel(database) {
+	const sessionsTable = sessions.table(database);
+	const eventsTable = events.table(database);
+	const links = sessionEvents.table(database);
+	return {
+		async getSession(id) {
+			for await (const row of sessionsTable.select().where(eq(sessionsTable.f_session_id, id))) return sessionRowOf(row);
+		},
+		async getEventRows(id, fromSequence) {
+			const rows = [];
+			const condition = fromSequence === void 0 ? eq(links.f_session_id, id) : and(eq(links.f_session_id, id), gte(links.f_sequence, fromSequence));
+			for await (const row of links.select({
+				fEventId: links.f_event_id,
+				fSequence: links.f_sequence,
+				fType: eventsTable.f_type,
+				fKind: eventsTable.f_kind,
+				fRole: eventsTable.f_role,
+				fName: eventsTable.f_name,
+				fActionId: eventsTable.f_action_id,
+				fCreatedAt: eventsTable.f_created_at,
+				fData: eventsTable.f_data,
+				fSurfaceOp: links.f_surface_op
+			}).join(events, eq(eventsTable.f_event_id, links.f_event_id)).where(condition).orderBy("f_sequence")) rows.push(eventRowOf(row));
+			return rows;
+		},
+		async getEventTypeAt(id, sequence) {
+			for await (const row of links.select({ fType: eventsTable.f_type }).join(events, eq(eventsTable.f_event_id, links.f_event_id)).where(and(eq(links.f_session_id, id), eq(links.f_sequence, sequence))).limit(1)) return row.fType;
+		},
+		async getEventTypesBefore(id, beforeSequence, limit) {
+			const rows = [];
+			for await (const row of links.select({
+				fSequence: links.f_sequence,
+				fType: eventsTable.f_type
+			}).join(events, eq(eventsTable.f_event_id, links.f_event_id)).where(and(eq(links.f_session_id, id), lt(links.f_sequence, beforeSequence))).orderBy("f_sequence", "desc").limit(limit)) rows.push({
+				fSequence: Number(row.fSequence),
+				fType: row.fType
+			});
+			return rows;
+		},
+		async listSessions() {
+			const rows = [];
+			for await (const row of sessionsTable.select()) rows.push(sessionRowOf(row));
+			return rows;
+		},
+		async latestTitleEvent(id) {
+			for await (const row of links.select({
+				fSequence: links.f_sequence,
+				fData: eventsTable.f_data
+			}).join(events, eq(eventsTable.f_event_id, links.f_event_id)).where(and(eq(links.f_session_id, id), eq(eventsTable.f_type, "session/title"))).orderBy("f_sequence", "desc").limit(1)) return {
+				fSequence: Number(row.fSequence),
+				fData: row.fData
+			};
+		},
+		async listOrphanSubagentSessions() {
+			const ids = [];
+			for await (const row of sessionsTable.select({ id: sessionsTable.f_session_id }).where(and(eq(sessionsTable.f_origin, "subagent"), or(isNull(sessionsTable.f_parent_session), notInSubquery(sessionsTable.f_parent_session, sessionsTable.select({ id: sessionsTable.f_session_id }).toFragment()))))) ids.push(row.id);
+			return ids;
+		}
+	};
+}
+/** `f_last_event_at` 的「只增不减」（两方言同一份表达式，值走绑定）。 */
+function lastEventAtExpr(value) {
+	return E.maxOf(E.column("f_last_event_at"), value);
+}
+/** header 的「变了才写」条件：逐列 `IS DISTINCT FROM` 的 OR（值全部走绑定参数）。 */
+function headerChangedCondition(header) {
+	return E.or(...Object.entries(header).map(([name, value]) => E.isDistinctFrom(E.column(name, "t_sessions"), value)));
+}
+/**
+* 事件行的数值列统一收回 number：`f_created_at` 在表定义里是 `bigint`（rdbkit 读回 BigInt），
+* 事件坐标与毫秒时间都在安全整数范围内。
+*/
+function eventRowOf(row) {
+	return {
+		fEventId: row.fEventId,
+		fSequence: Number(row.fSequence),
+		fType: row.fType,
+		fKind: row.fKind,
+		fRole: row.fRole,
+		fName: row.fName,
+		fActionId: row.fActionId,
+		fCreatedAt: Number(row.fCreatedAt),
+		fData: row.fData,
+		fSurfaceOp: row.fSurfaceOp
+	};
+}
+/** 列名原样 → 会话行的 camelCase（列名由表定义固定，这里是唯一一处映射）。 */
+function sessionRowOf(row) {
+	return {
+		fSessionId: String(row["f_session_id"]),
+		fHeadEventId: String(row["f_head_event_id"]),
+		fHeadSequence: Number(row["f_head_sequence"]),
+		fVersion: Number(row["f_version"]),
+		fCreatedAt: Number(row["f_created_at"]),
+		fCwd: row["f_cwd"] ?? null,
+		fParentSession: row["f_parent_session"] ?? null,
+		fSeedLength: row["f_seed_length"] === null ? null : Number(row["f_seed_length"]),
+		fOrigin: row["f_origin"] ?? null,
+		fDelegationDepth: row["f_delegation_depth"] === null ? null : Number(row["f_delegation_depth"]),
+		fAgentPreset: row["f_agent_preset"] ?? null,
+		fIncarnation: String(row["f_incarnation"]),
+		fRevision: Number(row["f_revision"]),
+		fArchivedAt: row["f_archived_at"] === null ? null : Number(row["f_archived_at"]),
+		fPinnedSeq: row["f_pinned_seq"] === null ? null : Number(row["f_pinned_seq"]),
+		fLastEventAt: row["f_last_event_at"] === null ? null : Number(row["f_last_event_at"])
+	};
+}
+// src/db/stats.ts
+function asText(value) {
+	return typeof value === "string" ? value : null;
+}
+async function usageReport(database, sinceMs) {
+	const buckets = await usageBuckets(database, sinceMs);
+	const tokenScope = await usageTokenScope(database, sinceMs);
+	const activityScope = await usageActivityScope(database, sinceMs);
+	const tokenSessions = await usageSessionTokens(database, sinceMs);
+	const activitySessions = await usageSessionCounts(database, sinceMs);
+	const toToken = (row) => ({
+		inputTokens: Number(row["input_tokens"] ?? 0),
+		outputTokens: Number(row["output_tokens"] ?? 0),
+		cacheReadTokens: Number(row["cache_read_tokens"] ?? 0),
+		reasoningTokens: Number(row["reasoning_tokens"] ?? 0),
+		totalTokens: Number(row["total_tokens"] ?? 0)
+	});
+	const toActivity = (row) => ({
+		turns: Number(row["turns"] ?? 0),
+		steps: Number(row["steps"] ?? 0),
+		userInputs: Number(row["user_inputs"] ?? 0),
+		toolCalls: Number(row["tool_calls"] ?? 0)
+	});
+	const emptyToken = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		reasoningTokens: 0,
+		totalTokens: 0
+	};
+	const emptyActivity = {
+		turns: 0,
+		steps: 0,
+		userInputs: 0,
+		toolCalls: 0
+	};
+	const addToken = (target, row) => {
+		const token = toToken(row);
+		target.inputTokens += token.inputTokens;
+		target.outputTokens += token.outputTokens;
+		target.cacheReadTokens += token.cacheReadTokens;
+		target.reasoningTokens += token.reasoningTokens;
+		target.totalTokens += token.totalTokens;
+	};
+	const addActivity = (target, row) => {
+		const activity = toActivity(row);
+		target.turns += activity.turns;
+		target.steps += activity.steps;
+		target.userInputs += activity.userInputs;
+		target.toolCalls += activity.toolCalls;
+	};
+	const sum = (left, right) => ({
+		inputTokens: left.inputTokens + right.inputTokens,
+		outputTokens: left.outputTokens + right.outputTokens,
+		cacheReadTokens: left.cacheReadTokens + right.cacheReadTokens,
+		reasoningTokens: left.reasoningTokens + right.reasoningTokens,
+		totalTokens: left.totalTokens + right.totalTokens,
+		turns: left.turns + right.turns,
+		steps: left.steps + right.steps,
+		userInputs: left.userInputs + right.userInputs,
+		toolCalls: left.toolCalls + right.toolCalls
+	});
+	const human = {
+		...emptyToken,
+		...emptyActivity
+	};
+	const subagent = {
+		...emptyToken,
+		...emptyActivity
+	};
+	for (const row of tokenScope) addToken(Number(row.subagent) === 1 ? subagent : human, row);
+	for (const row of activityScope) addActivity(Number(row["subagent"]) === 1 ? subagent : human, row);
+	const activityBySession = /* @__PURE__ */ new Map();
+	for (const row of activitySessions) activityBySession.set(String(row["session_id"]), toActivity(row));
+	return {
+		totals: sum(sum({
+			...emptyToken,
+			...emptyActivity
+		}, human), subagent),
+		subagent,
+		human,
+		buckets: buckets.map((row) => ({
+			day: String(row.day),
+			provider: row.provider,
+			model: row.model,
+			subagent: Number(row.subagent) === 1,
+			...toToken(row)
+		})),
+		sessions: tokenSessions.map((row) => ({
+			sessionId: String(row["session_id"]),
+			title: asText(row["title"]),
+			subagent: Number(row["subagent"]) === 1 || row["subagent"] === true,
+			archived: Number(row["archived"]) === 1 || row["archived"] === true,
+			...toToken(row),
+			...activityBySession.get(String(row["session_id"])) ?? emptyActivity
+		}))
+	};
+}
+async function listSessionRows(database, storage, query) {
+	const needle = query?.query?.trim().toLowerCase() ?? "";
+	const index = await storage.listWorkspaceIndex();
+	const { items, total } = await listSessionRows$1(database, {
+		needle,
+		titleMatches: needle === "" ? [] : [...new Set(index.filter((entry) => entry.title.toLowerCase().includes(needle)).flatMap((entry) => entry.sessionIds))],
+		includeSubagents: query?.includeSubagents === true,
+		limit: query?.limit ?? 20,
+		offset: query?.offset ?? 0
+	});
+	const workspaceOf = /* @__PURE__ */ new Map();
+	for (const entry of index) for (const sessionId of entry.sessionIds) if (!workspaceOf.has(sessionId)) workspaceOf.set(sessionId, entry.title);
+	return {
+		items: items.map((row) => ({
+			sessionId: String(row["session_id"]),
+			title: asText(row["title"]),
+			origin: asText(row["origin"]),
+			cwd: asText(row["cwd"]),
+			createdAt: Number(row["created_at"]),
+			updatedAt: Number(row["updated_at"]),
+			archived: Number(row["archived"]) === 1 || row["archived"] === true,
+			subagent: row["origin"] === "subagent",
+			workspace: workspaceOf.get(String(row["session_id"])) ?? null
+		})),
+		total
+	};
+}
+async function incrementSessionUsage(database, id, buckets) {
+	await incrementSessionUsage$1(database, id, buckets);
+}
+async function incrementSessionCounts(database, id, buckets) {
+	await incrementSessionCounts$1(database, id, buckets);
+}
+async function deleteSessionStats(database, id) {
+	await deleteSessionStats$1(database, id);
+}
+async function rebuildSessionStats(database, id) {
+	const links = sessionEvents.table(database);
+	const eventsTable = events.table(database);
+	const usageTable = eventUsage.table(database);
+	await rebuildSessionStats$1(database, id, {
+		usage: links.select({
+			f_session_id: links.f_session_id,
+			f_day: usageTable.f_day,
+			f_provider: E.coalesce(usageTable.f_provider, ""),
+			f_model: E.coalesce(usageTable.f_model, ""),
+			f_input_tokens: sum("f_input_tokens", "t_event_usage"),
+			f_output_tokens: sum("f_output_tokens", "t_event_usage"),
+			f_cache_read_tokens: sum("f_cache_read_tokens", "t_event_usage"),
+			f_reasoning_tokens: sum("f_reasoning_tokens", "t_event_usage"),
+			f_total_tokens: sum("f_total_tokens", "t_event_usage")
+		}).join(eventUsage, E.eq(usageTable.f_event_id, links.f_event_id)).where(E.eq(links.f_session_id, id)).groupBy(links.f_session_id, usageTable.f_day, usageTable.f_provider, usageTable.f_model).toFragment(),
+		counts: links.select({
+			f_session_id: links.f_session_id,
+			f_day: E.localDay(eventsTable.f_created_at),
+			f_turns: E.countIf(E.eq(eventsTable.f_type, "turn/start")),
+			f_steps: E.countIf(E.eq(eventsTable.f_type, "step/start")),
+			f_user_inputs: E.countIf(E.eq(eventsTable.f_type, "user/message")),
+			f_tool_calls: E.countIf(E.eq(eventsTable.f_type, "tool/call"))
+		}).join(events, E.eq(eventsTable.f_event_id, links.f_event_id)).where(E.and(E.eq(links.f_session_id, id), E.inList(eventsTable.f_type, [...COUNTED_EVENT_TYPES]))).groupBy(links.f_session_id, E.localDay(eventsTable.f_created_at)).toFragment()
+	});
+}
+async function refreshEventUsageFlags(database, eventIds) {
+	const links = sessionEvents.table(database);
+	const sessionsTable = sessions.table(database);
+	const refersTo = (eventId) => E.eq(links.f_event_id, eventId);
+	await refreshEventUsageFlags$1(database, eventIds, {
+		referenced: E.toInt(E.exists(links.select({ one: links.f_event_id }).where(refersTo(E.column("f_event_id", "t_event_usage"))).toFragment())),
+		subagent: E.toInt(E.exists(links.select({ one: links.f_event_id }).join(sessions, E.eq(sessionsTable.f_session_id, links.f_session_id)).where(E.and(refersTo(E.column("f_event_id", "t_event_usage")), E.eq(sessionsTable.f_origin, "subagent"))).toFragment()))
+	}, 400);
+}
+/** 统计表为空时按事件表全量回填（幂等；迁移删表重建、手动清空后自愈）。 */
+async function backfillUsageTables(database) {
+	const links = sessionEvents.table(database);
+	const eventsTable = events.table(database);
+	const sessionsTable = sessions.table(database);
+	const usageTable = eventUsage.table(database);
+	if (await isEmpty(database, eventUsage)) {
+		const hasUsage = (path) => E.isNotNull(E.jsonText(eventsTable.f_data, path));
+		const text = (path) => E.jsonText(eventsTable.f_data, path);
+		const int = (path) => E.coalesce(E.jsonInt(eventsTable.f_data, path), 0);
+		const usagePaths = (field) => [`$.data.usage.${field}`, `$.usage.${field}`];
+		const input = usagePaths("inputTokens");
+		const output = usagePaths("outputTokens");
+		const cacheRead = usagePaths("cacheReadTokens");
+		const reasoning = usagePaths("reasoningTokens");
+		const total = usagePaths("totalTokens");
+		const referenced = (eventId) => E.toInt(E.exists(links.select({ one: links.f_event_id }).where(E.eq(links.f_event_id, eventId)).toFragment()));
+		const subagent = (eventId) => E.toInt(E.exists(links.select({ one: links.f_event_id }).join(sessions, E.eq(sessionsTable.f_session_id, links.f_session_id)).where(E.and(E.eq(links.f_event_id, eventId), E.eq(sessionsTable.f_origin, "subagent"))).toFragment()));
+		const source = eventsTable.select({
+			f_event_id: eventsTable.f_event_id,
+			f_created_at: eventsTable.f_created_at,
+			f_day: E.localDay(eventsTable.f_created_at),
+			f_provider: E.coalesce(text("$.data.message.source.provider"), text("$.message.source.provider")),
+			f_model: E.coalesce(text("$.data.message.source.model"), text("$.message.source.model")),
+			f_referenced: referenced(E.column("f_event_id", "t_events")),
+			f_subagent: subagent(E.column("f_event_id", "t_events")),
+			f_input_tokens: E.coalesce(int(input[0]), int(input[1]), 0),
+			f_output_tokens: E.coalesce(int(output[0]), int(output[1]), 0),
+			f_cache_read_tokens: E.coalesce(int(cacheRead[0]), int(cacheRead[1]), 0),
+			f_reasoning_tokens: E.coalesce(int(reasoning[0]), int(reasoning[1]), 0),
+			f_total_tokens: E.coalesce(int(total[0]), int(total[1]), 0)
+		}).where(E.and(E.eq(eventsTable.f_type, "assistant/message"), E.or(hasUsage("$.data.usage"), hasUsage("$.usage")))).toFragment();
+		await usageTable.insertFromSelect([
+			"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"
+		], source, { conflict: ["f_event_id"] });
+	}
+	if (await isEmpty(database, sessionUsage)) {
+		const source = links.select({
+			f_session_id: links.f_session_id,
+			f_day: usageTable.f_day,
+			f_provider: E.coalesce(usageTable.f_provider, ""),
+			f_model: E.coalesce(usageTable.f_model, ""),
+			f_input_tokens: sum("f_input_tokens", "t_event_usage"),
+			f_output_tokens: sum("f_output_tokens", "t_event_usage"),
+			f_cache_read_tokens: sum("f_cache_read_tokens", "t_event_usage"),
+			f_reasoning_tokens: sum("f_reasoning_tokens", "t_event_usage"),
+			f_total_tokens: sum("f_total_tokens", "t_event_usage")
+		}).join(eventUsage, E.eq(usageTable.f_event_id, links.f_event_id)).groupBy(links.f_session_id, usageTable.f_day, usageTable.f_provider, usageTable.f_model).toFragment();
+		await sessionUsage.table(database).insertFromSelect([
+			"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"
+		], source, { conflict: [
+			"f_session_id",
+			"f_day",
+			"f_provider",
+			"f_model"
+		] });
+	}
+	if (await isEmpty(database, sessionCounts)) {
+		const source = links.select({
+			f_session_id: links.f_session_id,
+			f_day: E.localDay(eventsTable.f_created_at),
+			f_turns: E.countIf(E.eq(eventsTable.f_type, "turn/start")),
+			f_steps: E.countIf(E.eq(eventsTable.f_type, "step/start")),
+			f_user_inputs: E.countIf(E.eq(eventsTable.f_type, "user/message")),
+			f_tool_calls: E.countIf(E.eq(eventsTable.f_type, "tool/call"))
+		}).join(events, E.eq(eventsTable.f_event_id, links.f_event_id)).where(E.inList(eventsTable.f_type, [...COUNTED_EVENT_TYPES])).groupBy(links.f_session_id, E.localDay(eventsTable.f_created_at)).toFragment();
+		await sessionCounts.table(database).insertFromSelect([
+			"f_session_id",
+			"f_day",
+			"f_turns",
+			"f_steps",
+			"f_user_inputs",
+			"f_tool_calls"
+		], source, { conflict: ["f_session_id", "f_day"] });
+	}
+}
+async function isEmpty(database, definition) {
+	for await (const row of definition.table(database).select({ n: count() })) return Number(row.n) === 0;
+	return true;
+}
+/**
+* 整理数据的一步：三张派生统计表**清空后全量重算**。
+*
+* 这三张表本来就是可销毁重建的派生数据（见 ADR-统计衍生表物化归属与汇总），所以重算走「删了再回填」
+* 这条与打开时自愈相同的路径，不逐会话补差。
+* @param database - 执行面。
+* @returns 重建涉及的会话数。
+*/
+async function rebuildAllStats(database) {
+	await sessionUsage.table(database).delete();
+	await sessionCounts.table(database).delete();
+	await eventUsage.table(database).delete();
+	await backfillUsageTables(database);
+	let total = 0;
+	for await (const row of sessions.table(database).select({ n: count() })) total = Number(row.n);
+	return total;
+}
+// src/storage-takeover/workspace-documents.ts
+const WORKSPACE_DOMAIN = "workspace";
+const WORKSPACE_TABLE = "workspaces";
+const GLOBAL_TABLE = "";
+/**
+* 删除会话后清掉 workspace 文档里的归属与归档 / 钉住集合。
+*
+* 域存储只有 `t_storage_records` 一份，没有再 join 的归属表，所以删除路径得读改文档。调用方保证在
+* 写事务内：SQLite 用同一连接上的 `Database`，PG 用当前事务的 scoped `Database`。
+* @param database - 当前执行面（事务内就是 scoped 实例）。
+* @param ids - 刚删除的会话 id。
+*/
+async function pruneWorkspaceDocuments(database, ids) {
+	if (ids.length === 0) return;
+	const records = database.table(storageRecords);
+	const scope = E.and(E.eq(records.f_domain, WORKSPACE_DOMAIN), E.eq(records.f_table, WORKSPACE_TABLE));
+	const drop = new Set(ids);
+	for await (const row of records.select({
+		key: records.f_key,
+		value: records.f_value
+	}).where(scope)) {
+		const record = JSON.parse(row.value);
+		const kept = record.sessionIds.filter((sessionId) => !drop.has(sessionId));
+		if (kept.length === record.sessionIds.length) continue;
+		await records.update({ f_value: JSON.stringify({
+			...record,
+			sessionIds: kept
+		}) }, E.and(E.eq(records.f_domain, WORKSPACE_DOMAIN), E.eq(records.f_table, WORKSPACE_TABLE), E.eq(records.f_key, row.key)));
+	}
+	let globalValue;
+	for await (const row of records.select({ value: records.f_value }).where(E.and(E.eq(records.f_domain, WORKSPACE_DOMAIN), E.eq(records.f_table, GLOBAL_TABLE)))) globalValue = row.value;
+	if (globalValue === void 0) return;
+	const state = JSON.parse(globalValue);
+	const archivedSessionIds = state.archivedSessionIds.filter((sessionId) => !drop.has(sessionId));
+	const pinnedSessionIds = (state.pinnedSessionIds ?? []).filter((sessionId) => !drop.has(sessionId));
+	if (archivedSessionIds.length === state.archivedSessionIds.length && pinnedSessionIds.length === (state.pinnedSessionIds ?? []).length) return;
+	const next = {
+		...state,
+		archivedSessionIds,
+		pinnedSessionIds
+	};
+	await records.update({ f_value: JSON.stringify(next) }, E.and(E.eq(records.f_domain, WORKSPACE_DOMAIN), E.eq(records.f_table, GLOBAL_TABLE)));
+}
+// src/backend-rdb.ts
+const INSERT_BATCH_ROWS = 1e3;
+/**
+* 唯一的 backend 实现：读写方法收敛在这里（读模型 + `session-ops` + 表句柄）；打开流程在 `db/open.ts`，
+* 统计面在 `db/stats.ts`。方言差异全部由 rdbkit 的表达式承担，这里不出现任何 SQL 文本。
+*/
+var RdbBackend = class {
+	storage;
+	storeIdentity;
+	#database;
+	reads;
+	constructor(options) {
+		this.kind = options.kind;
+		this.#database = options.database;
+		this.storage = options.storage;
+		this.reads = options.readModel;
+		this.storeIdentity = options.storeIdentity;
+	}
+	kind;
+	async open() {}
+	async close() {
+		await this.#database.close();
+	}
+	async transaction(fn) {
+		return await this.#database.transaction(async (scoped) => fn(this.#txFor(scoped)));
+	}
+	async listOrphanSubagentSessions() {
+		return await this.reads.listOrphanSubagentSessions();
+	}
+	/** 当前 head 指针（分支 / 测试读路径用；写路径在 `BackendTx` 里）。 */
+	async getHead(id) {
+		return await readHead(this.#database, id);
+	}
+	async collectOrphans() {
+		return await collectOrphans(this.#database);
+	}
+	async usageReport(sinceMs) {
+		return await usageReport(this.#database, sinceMs);
+	}
+	async listSessionRows(query) {
+		return await listSessionRows(this.#database, this.storage, query);
+	}
+	async incrementSessionUsage(id, buckets) {
+		await incrementSessionUsage(this.#database, id, buckets);
+	}
+	async incrementSessionCounts(id, buckets) {
+		await incrementSessionCounts(this.#database, id, buckets);
+	}
+	async deleteSessionStats(id) {
+		await deleteSessionStats(this.#database, id);
+	}
+	async rebuildSessionStats(id) {
+		await rebuildSessionStats(this.#database, id);
+	}
+	async rebuildAllStats() {
+		return await rebuildAllStats(this.#database);
+	}
+	async refreshEventUsageFlags(eventIds) {
+		await refreshEventUsageFlags(this.#database, eventIds);
+	}
+	async vacuum() {
+		await this.#database.vacuum();
+	}
+	#txFor(rdb) {
+		return {
+			upsertSession: (storage, incarnation) => this.#upsertSession(rdb, storage, incarnation),
+			getHead: (id) => readHead(rdb, id),
+			getSeedLength: (id) => readSeedLength(rdb, id),
+			updateSeedLength: (id, seedLength) => this.#updateSeedLength(rdb, id, seedLength),
+			refreshTitle: (id) => this.#refreshTitle(rdb, id),
+			insertEvents: (events, usageRows) => this.#insertEvents(rdb, events, usageRows),
+			insertBridges: (rows) => this.#insertBridges(rdb, rows),
+			updateHead: (id, headEventId, headSequence) => this.#updateHead(rdb, id, headEventId, headSequence),
+			updateHeadAndRevision: (id, headEventId, headSequence, lastEventAt) => this.#updateHeadAndRevision(rdb, id, headEventId, headSequence, lastEventAt),
+			bumpRevision: (id, lastEventAt) => this.#bumpRevision(rdb, id, lastEventAt),
+			deleteBridgeTail: (id, fromSequence) => this.#deleteBridgeTail(rdb, id, fromSequence),
+			getPrevBridge: (id, sequence) => readPrevBridge(rdb, id, sequence),
+			deleteSession: (id) => this.#deleteSession(rdb, id),
+			deleteSessions: (ids) => this.#deleteSessions(rdb, ids)
+		};
+	}
+	async #upsertSession(rdb, storage, incarnation) {
+		const row = sessionInsertColumns(storage, incarnation);
+		const header = sessionHeaderColumns(storage);
+		const table = sessions.table(rdb);
+		await table.insertIgnore(row, ["f_session_id"]);
+		await table.update(header, E.and(E.eq(table.f_session_id, storage.meta.id), headerChangedCondition(header)));
+	}
+	async #updateSeedLength(rdb, id, seedLength) {
+		const table = sessions.table(rdb);
+		await table.update({ f_seed_length: seedLength }, E.eq(table.f_session_id, id));
+	}
+	async #refreshTitle(rdb, id) {
+		const latest = await this.reads.latestTitleEvent(id);
+		const title = latest === void 0 ? void 0 : titleOfEventData(latest.fData);
+		const nextTitle = title ?? null;
+		const nextSeq = title === void 0 ? null : latest.fSequence;
+		const table = sessions.table(rdb);
+		await table.update({
+			f_title: nextTitle,
+			f_title_seq: nextSeq
+		}, E.and(E.eq(table.f_session_id, id), E.or(E.isDistinctFrom(table.f_title, nextTitle), E.isDistinctFrom(table.f_title_seq, nextSeq))));
+	}
+	async #insertEvents(rdb, eventRows, usageRows) {
+		if (eventRows.length === 0) return;
+		const eventsTable = events.table(rdb);
+		for (let i = 0; i < eventRows.length; i += INSERT_BATCH_ROWS) await eventsTable.insertMany(eventRows.slice(i, i + INSERT_BATCH_ROWS).map((event) => ({
+			f_event_id: event.fEventId,
+			f_parent_id: event.fParentId,
+			f_type: event.fType,
+			f_kind: event.fKind,
+			f_role: event.fRole,
+			f_name: event.fName,
+			f_action_id: event.fActionId,
+			f_encoding: event.fEncoding,
+			f_data: event.fData,
+			f_created_at: event.fCreatedAt
+		})));
+		if (usageRows.length > 0) {
+			const usage = eventUsage.table(rdb);
+			for (let i = 0; i < usageRows.length; i += INSERT_BATCH_ROWS) await usage.insertMany(usageRows.slice(i, i + INSERT_BATCH_ROWS).map((row) => ({
+				f_event_id: row.fEventId,
+				f_created_at: row.fCreatedAt,
+				f_day: row.fDay,
+				f_provider: row.fProvider,
+				f_model: row.fModel,
+				f_referenced: row.fReferenced,
+				f_subagent: row.fSubagent,
+				f_input_tokens: row.fInputTokens,
+				f_output_tokens: row.fOutputTokens,
+				f_cache_read_tokens: row.fCacheReadTokens,
+				f_reasoning_tokens: row.fReasoningTokens,
+				f_total_tokens: row.fTotalTokens
+			})), { conflict: ["f_event_id"] });
+		}
+	}
+	async #insertBridges(rdb, rows) {
+		if (rows.length === 0) return;
+		const links = sessionEvents.table(rdb);
+		for (let i = 0; i < rows.length; i += INSERT_BATCH_ROWS) await links.insertMany(rows.slice(i, i + INSERT_BATCH_ROWS).map((row) => ({
+			f_session_id: row.fSessionId,
+			f_event_id: row.fEventId,
+			f_sequence: row.fSequence,
+			f_surface_op: row.fSurfaceOp
+		})));
+	}
+	async #updateHead(rdb, id, headEventId, headSequence) {
+		const table = sessions.table(rdb);
+		await table.update({
+			f_head_event_id: headEventId,
+			f_head_sequence: headSequence
+		}, E.eq(table.f_session_id, id));
+	}
+	async #updateHeadAndRevision(rdb, id, headEventId, headSequence, lastEventAt) {
+		const table = sessions.table(rdb);
+		await table.update({
+			f_head_event_id: headEventId,
+			f_head_sequence: headSequence,
+			f_revision: E.add(table.f_revision, 1),
+			...lastEventAt === void 0 ? {} : { f_last_event_at: lastEventAtExpr(lastEventAt) }
+		}, E.eq(table.f_session_id, id));
+	}
+	async #bumpRevision(rdb, id, lastEventAt) {
+		const table = sessions.table(rdb);
+		await table.update({
+			f_revision: E.add(table.f_revision, 1),
+			...lastEventAt === void 0 ? {} : { f_last_event_at: lastEventAtExpr(lastEventAt) }
+		}, E.eq(table.f_session_id, id));
+	}
+	async #deleteBridgeTail(rdb, id, fromSequence) {
+		const links = sessionEvents.table(rdb);
+		return (await links.delete(E.and(E.eq(links.f_session_id, id), E.gte(links.f_sequence, fromSequence)), ["f_event_id"])).map((row) => row.f_event_id);
+	}
+	async #deleteSession(rdb, id) {
+		const links = sessionEvents.table(rdb);
+		const rows = await links.delete(E.eq(links.f_session_id, id), ["f_event_id"]);
+		await this.#deleteSessionStatsRows(rdb, [id]);
+		const table = sessions.table(rdb);
+		await table.delete(E.eq(table.f_session_id, id));
+		await this.#pruneWorkspace(rdb, [id]);
+		return rows.map((row) => row.f_event_id);
+	}
+	async #deleteSessions(rdb, ids) {
+		if (ids.length === 0) return {
+			deleted: 0,
+			eventIds: []
+		};
+		const links = sessionEvents.table(rdb);
+		const removed = await links.delete(E.inList(links.f_session_id, ids), ["f_event_id"]);
+		await this.#deleteSessionStatsRows(rdb, ids);
+		const table = sessions.table(rdb);
+		let deleted = 0;
+		for await (const row of table.select({ n: count() }).where(E.inList(table.f_session_id, ids))) deleted = Number(row.n);
+		await table.delete(E.inList(table.f_session_id, ids));
+		await this.#pruneWorkspace(rdb, ids);
+		return {
+			deleted,
+			eventIds: removed.map((row) => row.f_event_id)
+		};
+	}
+	async #deleteSessionStatsRows(rdb, ids) {
+		for (const id of ids) await deleteSessionStats(rdb, id);
+	}
+	async #pruneWorkspace(rdb, ids) {
+		await pruneWorkspaceDocuments(rdb, ids);
+	}
+};
+export { sessionProjcacheRows as a, sessions as c, EVENT_ENCODING as d, SCHEMA_VERSION as f, catalog as i, persistenceState as l, backfillUsageTables as n, storageRecords as o, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as p, createReadModel as r, storageUnits as s, RdbBackend as t, DEFAULT_BUSY_TIMEOUT_MS as u };