@morlay/ui-conversation-message-actions 0.1.1 → 0.1.2

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { t as SESSION_EDITOR_PATH } from "./shared-BBbOTwy4.mjs";
+import { t as SESSION_EDITOR_PATHS } from "./shared-DG86bLrc.mjs";
 import { SessionEditor } from "./index.mjs";
 import { createRequire } from "node:module";
 import { Context, Service } from "@deepseek-ai/cordis";
@@ -14656,7 +14656,6 @@ var WriteGuard = class {
 	confirmHead(id, head) {
 		this.headSeqs.set(id, head);
 	}
-	/** 本实例有没有这条会话的 head 记录（迁移重写用它决定是"登记基准"还是"严格比较"）。 */
 	has(id) {
 		return this.headSeqs.has(id);
 	}
@@ -20514,8 +20513,16 @@ createSessionFormatCatalog({
 	}
 });
 //#endregion
+//#region ../session-rdb/src/routes.ts
+const MORLAY_SESSION_API_PREFIX = "/api/morlay/v1/session";
+const SESSION_ROWS_PATH = `${MORLAY_SESSION_API_PREFIX}/rows`;
+const SESSION_EXPORT_PATH = `${MORLAY_SESSION_API_PREFIX}/export`;
+const SESSION_IMPORT_PATH = `${MORLAY_SESSION_API_PREFIX}/import`;
+const SESSION_DELETE_PATH = `${MORLAY_SESSION_API_PREFIX}/delete`;
+const SESSION_GC_PATH = `${MORLAY_SESSION_API_PREFIX}/gc`;
+const SESSION_USAGE_PATH = `${MORLAY_SESSION_API_PREFIX}/usage`;
+//#endregion
 //#region ../session-rdb/src/usage.ts
-const SESSION_USAGE_PATH = "/api/session.usage";
 const ROLLING_DAYS = {
 	"7d": 7,
 	"30d": 30,
@@ -20526,14 +20533,6 @@ function localDayStart(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;
@@ -20553,14 +20552,12 @@ function resolveUsageSince(range, now) {
 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":
@@ -20578,7 +20575,6 @@ function addActivityCount(target, type, count) {
 		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");
@@ -20612,16 +20608,11 @@ function addActivityTotals(target, row) {
 	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;
@@ -20748,17 +20739,11 @@ const SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
 	"tool/result"
 ]);
 const METERING_EVENT_TYPES = /* @__PURE__ */ new Set(["compaction/summary", "compaction/prune"]);
-/**
-* 升序的 surface 事件 seq 索引：读视图修复里的溯源（replace 的 `sourceEventSeqs` 与
-* metering 的 `shadowedSeqs`）共用这一份，避免每个 replace 各扫一遍全量事件。
-* 前提是输入按 seq 有序（`readLog` 与 live snapshot 都如此）。
-*/
 function surfaceSeqIndex(events) {
 	const seqs = [];
 	for (const event of events) if (SURFACE_EVENT_TYPES.has(event.type)) seqs.push(event.seq);
 	return seqs;
 }
-/** `[startSeq, endSeq]` 内的 surface seq（含端点），二分定位后切片。 */
 function surfaceSeqsInRange(seqs, startSeq, endSeq) {
 	let low = 0;
 	let high = seqs.length;
@@ -21010,20 +20995,6 @@ function renameLegacyPtcEvents(events) {
 		}
 	}
 }
-/**
-* 把**旧代（v3 及更早）的消息形状**归一到当前格式（v4）：迁移链（严格）拒绝那些形状时，读路径仍要
-* 能把它们读出来——只动字段与标记，不改坐标、不改内容。
-*
-* 三件事：
-* - `system/message` 的 source：`{ kind: 'plugin', plugin: '@deepseek-ai/dsh-system-prompt' }` → `{ kind: 'system-prompt' }`
-*   （v4 起 system 消息只认这个 kind）；
-* - `tool/result` 的消息：v3 是 user 角色、结果块包在 `content[0]`；v4 是 `role: 'tool'` + 顶层
-*   `toolCallId` + `content` 就是结果块；
-* - **本仓库自造、上游不认识的事件类型**（见 `OWN_EVENT_TYPES`：历史遗留的与我们当前在写的）标
-*   `ignorable: true`——v4 的校验对未知类型只接受可忽略信封。
-*
-* 只认这张白名单：**其它未知类型保持 fail loud**（那是「数据来自更新的 harness」的信号，不能吞掉）。
-*/
 function normalizeToCurrentShape(events) {
 	for (const event of events) {
 		const type = event.type;
@@ -21069,33 +21040,10 @@ function liftToolResultMessage(message) {
 		callId
 	};
 }
-/**
-* 落库前给**本仓库自造的事件类型**补上 `ignorable: true` 信封。
-*
-* 上游的持久化校验（`validateStoredEvents`）只放行「已知类型」或「带可忽略信封的未知类型」，我们的类型
-* 按构造就在已知表之外——不补的话连**写入**都会被拒（`appendBatch` 里那道校验）。上游 `Session.append`
-* 没有承载这个信封的口子（第三个参数只服务 surface 事件），所以这一笔由持久化层补：canonical log 里的
-* 形状不变，落库的那一份带上信封。
-* @param events - 即将落库的批次（`materializeAppendBatch` 的 JSON 快照副本，可写）。
-*/
 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;
@@ -21237,15 +21185,6 @@ function numericField(value) {
 function textField(value) {
 	return typeof value === "string" && value !== "" ? value : null;
 }
-/**
-* 一条事件行的用量（只有带 `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, subagent) {
 	if (event.fType !== "assistant/message") return void 0;
 	let parsed;
@@ -25200,12 +25139,6 @@ const sessionProjcacheRows = {
 };
 //#endregion
 //#region ../session-rdb/src/entities/v3/event-usage.ts
-/**
-* 用量日志：一条 `assistant/message` 事件一行（按事件行唯一，fork 共享行不重复）。
-* 读侧维度全部物化在行上——本地日、是否被会话引用、是否被子代理会话引用——统计因此不做
-* `EXISTS` 判定、也不回连事件表；事件行本身仍留在 `t_events`。
-* 取舍见 ADR-统计衍生表物化归属与汇总。
-*/
 const eventUsage = {
 	name: "t_event_usage",
 	columns: {
@@ -25268,11 +25201,6 @@ const eventUsage = {
 };
 //#endregion
 //#region ../session-rdb/src/entities/v3/session-usage.ts
-/**
-* 会话 × 本地日 × 模型的 token 汇总（派生统计表）：**按会话的行**读它，因此保住
-* 「fork 子会话含继承前缀」的口径（各会话行之和 ≥ 总量）而不回连事件表。
-* 旁路累加、可按会话重建，读侧只读；取舍见 ADR-统计衍生表物化归属与汇总。
-*/
 const sessionUsage = {
 	name: "t_session_usage",
 	columns: {
@@ -25334,11 +25262,6 @@ const sessionUsage = {
 };
 //#endregion
 //#region ../session-rdb/src/entities/v3/session-counts.ts
-/**
-* 会话 × 本地日的活动计数（派生统计表）：轮次 / 步骤 / 用户输入 / 工具调用四列直接读，
-* 不再存事件类型、也不在读取时折。旁路累加、可按会话重建，读侧只读；
-* 取舍见 ADR-统计衍生表物化归属与汇总。
-*/
 const sessionCounts = {
 	name: "t_session_counts",
 	columns: {
@@ -25980,22 +25903,16 @@ function createStorageRepository(host) {
 }
 //#endregion
 //#region ../session-rdb/src/sqlite.ts
-/** 用量行的「被引用」物化表达式（`%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(", ");
+const REFRESH_FLAG_CHUNK$1 = 400;
 function withEvent(expression, column) {
 	return expression.replace("%EVENT%", column);
 }
-/**
-* 派生统计表的回填：任一表为空即按事件表全量重算（幂等；迁移删表重建后、手动清空后都靠它自愈）。
-* 顺序有依赖：用量行（带物化列）先落，两张会话汇总表再从它 / 事件表重算。
-*/
 function backfillUsageTables(db) {
 	backfillEventUsage(db);
 	backfillSessionUsage(db);
@@ -26004,7 +25921,6 @@ function backfillUsageTables(db) {
 function tableIsEmpty(db, table) {
 	return db.prepare(`SELECT count(*) AS n FROM ${table}`).get().n === 0;
 }
-/** 用量行：一条 `assistant/message` 事件行一行，物化本地日与两个归属标记。 */
 function backfillEventUsage(db) {
 	if (!tableIsEmpty(db, "t_event_usage")) return;
 	db.exec(`INSERT OR IGNORE INTO t_event_usage (
@@ -26033,7 +25949,6 @@ 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 (
@@ -26046,7 +25961,6 @@ function backfillSessionUsage(db) {
       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 (
@@ -26075,7 +25989,6 @@ function sessionListRowOf(row) {
 		workspace: typeof row["workspace"] === "string" ? row["workspace"] : null
 	};
 }
-/** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
 function tokenTotalsOf$1(row) {
 	return {
 		inputTokens: row.input_tokens ?? 0,
@@ -26085,7 +25998,6 @@ function tokenTotalsOf$1(row) {
 		totalTokens: row.total_tokens ?? 0
 	};
 }
-/** `t_session_counts` 的原始行（列名是 SQL 别名）折成四项活动计数。 */
 function activityTotalsOf$1(row) {
 	return {
 		turns: row.turns ?? 0,
@@ -26094,7 +26006,6 @@ function activityTotalsOf$1(row) {
 		toolCalls: row.tool_calls ?? 0
 	};
 }
-/** 一行的整套指标：token 用量 + 活动计数（轮次 / 步骤 / 用户输入 / 工具调用）。 */
 function emptyActivity$1() {
 	return {
 		turns: 0,
@@ -26103,7 +26014,6 @@ function emptyActivity$1() {
 		toolCalls: 0
 	};
 }
-/** 有 token 用量的会话：活动计数与列表都限定在这一批会话里，口径一致（读汇总表，几百行）。 */
 function hasUsageSession(column) {
 	return `EXISTS (SELECT 1 FROM t_session_usage ub WHERE ub.f_session_id = ${column})`;
 }
@@ -26366,7 +26276,7 @@ var SqliteBackend = class SqliteBackend {
 		}).where(eq(tSessions.fSessionId, id)).run();
 	}
 	async deleteBridgeTail(id, fromSequence) {
-		this.db.delete(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence))).run();
+		return this.db.$client.prepare("DELETE FROM t_session_events WHERE f_session_id = ? AND f_sequence >= ? RETURNING f_event_id").all(id, fromSequence).map((row) => row.f_event_id);
 	}
 	async getPrevBridge(id, sequence) {
 		return this.db.select({
@@ -26375,19 +26285,18 @@ var SqliteBackend = class SqliteBackend {
 		}).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();
+		const rows = this.db.$client.prepare("DELETE FROM t_session_events WHERE f_session_id = ? RETURNING f_event_id").all(id);
 		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();
+		return rows.map((row) => row.f_event_id);
 	}
-	/** 事件行可能被多个会话共享（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'
@@ -26395,18 +26304,20 @@ var SqliteBackend = class SqliteBackend {
                 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();
+		if (ids.length === 0) return {
+			deleted: 0,
+			eventIds: []
+		};
+		const placeholders = ids.map(() => "?").join(", ");
+		const rows = this.db.$client.prepare(`DELETE FROM t_session_events WHERE f_session_id IN (${placeholders}) RETURNING f_event_id`).all(...ids);
 		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);
+		return {
+			deleted: Number(info.changes),
+			eventIds: rows.map((row) => row.f_event_id)
+		};
 	}
-	/**
-	* 用量聚合：token 用量沿 `t_event_usage` 的用量行，活动计数（轮次 / 步骤 / 用户输入 / 工具调用）
-	* 沿 `t_events` 的事件类型数——两者限定在**有 token 用量的会话**里，时间范围各自按自己的
-	* `f_created_at`（同一时刻写入，口径一致）。
-	*/
 	async listSessionRows(query = {}) {
 		const needle = query.query?.trim().toLowerCase() ?? "";
 		const like = `%${needle}%`;
@@ -26446,12 +26357,6 @@ 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 f_created_at >= ?";
 		const params = sinceMs === void 0 ? [] : [sinceMs];
@@ -26537,7 +26442,6 @@ var SqliteBackend = class SqliteBackend {
 			}))
 		};
 	}
-	/** 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,
@@ -26551,7 +26455,6 @@ var SqliteBackend = class SqliteBackend {
          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_session_counts (f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
@@ -26563,7 +26466,6 @@ var SqliteBackend = class SqliteBackend {
          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 (
@@ -26590,15 +26492,15 @@ var SqliteBackend = class SqliteBackend {
           WHERE b.f_session_id = ? AND e.f_type IN (${COUNTED_EVENT_TYPE_SQL$1})
           GROUP BY b.f_session_id, 2`).run(id);
 	}
-	/**
-	* 全量重算用量行的引用标记：rewind 截断 / fork 复用 / 会话删除都会让「引用」跨会话变化，
-	* 只按本会话判定不够。低频路径，一次全表 UPDATE（3 万行量级）。
-	*/
-	async refreshEventUsageFlags() {
-		const eventId = "t_event_usage.f_event_id";
-		this.db.$client.exec(`UPDATE t_event_usage SET
-         f_referenced = ${withEvent(EVENT_REFERENCED_SQL, eventId)},
-         f_subagent = ${withEvent(EVENT_SUBAGENT_SQL, eventId)}`);
+	async refreshEventUsageFlags(eventIds) {
+		for (let at = 0; at < eventIds.length; at += REFRESH_FLAG_CHUNK$1) {
+			const chunk = eventIds.slice(at, at + REFRESH_FLAG_CHUNK$1);
+			const placeholders = chunk.map(() => "?").join(", ");
+			this.db.$client.prepare(`UPDATE t_event_usage SET
+             f_referenced = ${withEvent(EVENT_REFERENCED_SQL, "f_event_id")},
+             f_subagent = ${withEvent(EVENT_SUBAGENT_SQL, "f_event_id")}
+           WHERE f_event_id IN (${placeholders})`).run(...chunk);
+		}
 	}
 	async deleteSessionStats(id) {
 		this.db.$client.prepare("DELETE FROM t_session_usage WHERE f_session_id = ?").run(id);
@@ -26633,22 +26535,19 @@ async function migrate(db, config) {
 //#region ../session-rdb/src/postgres.ts
 const postgresMigrationsDir = fileURLToPath(new URL("../drizzle/postgres/", import.meta.url));
 const pgWriteQueues = /* @__PURE__ */ new Map();
-/** 按介质（连接串 + schema）串行化写事务，与 SQLite 侧的 `enqueueSqliteTx` 同形。 */
+const REFRESH_FLAG_CHUNK = 400;
 function enqueuePgWrite(key, fn) {
 	const run = (pgWriteQueues.get(key) ?? Promise.resolve()).then(fn);
 	pgWriteQueues.set(key, run.then(() => void 0, () => void 0));
 	return run;
 }
-/** pg 的 text 列窄化：非字符串（含 null）都不当作文本。 */
 function text(value) {
 	return typeof value === "string" ? value : null;
 }
-/** pg 的 count/sum 回落成字符串：统一转成有限数。 */
 function numeric(value) {
 	const parsed = typeof value === "number" ? value : Number(value ?? 0);
 	return Number.isFinite(parsed) ? parsed : 0;
 }
-/** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
 function tokenTotalsOf(row) {
 	return {
 		inputTokens: numeric(row["input_tokens"]),
@@ -26666,7 +26565,6 @@ function emptyActivity() {
 		toolCalls: 0
 	};
 }
-/** `t_session_counts` 的四项计数折成活动计数（pg 的 sum 回落成字符串）。 */
 function activityTotalsOf(row) {
 	return {
 		turns: numeric(row["turns"]),
@@ -26675,7 +26573,6 @@ function activityTotalsOf(row) {
 		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 {
 	db;
@@ -26862,15 +26759,21 @@ var PostgresBackend = class PostgresBackend {
 		}).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
 	}
 	async deleteBridgeTail(exec, id, fromSequence) {
-		await exec.delete(this.tables["t_session_events"]).where(and(eq(this.tables["t_session_events"].fSessionId, id), gte(this.tables["t_session_events"].fSequence, fromSequence))).execute();
+		const table = this.tables["t_session_events"];
+		return (await exec.execute(sql`
+      DELETE FROM ${table} WHERE f_session_id = ${id} AND f_sequence >= ${fromSequence}
+      RETURNING f_event_id
+    `)).rows.map((row) => row.f_event_id);
 	}
 	async deleteSession(exec, id) {
-		await exec.delete(this.tables["t_session_events"]).where(eq(this.tables["t_session_events"].fSessionId, id)).execute();
+		const result = await exec.execute(sql`
+      DELETE FROM ${this.tables["t_session_events"]} WHERE f_session_id = ${id} RETURNING f_event_id
+    `);
 		await exec.delete(this.tables["t_workspace_sessions"]).where(eq(this.tables["t_workspace_sessions"].fSessionId, id)).execute();
 		await exec.delete(this.tables["t_session_projcache_row"]).where(eq(this.tables["t_session_projcache_row"].fSessionId, id)).execute();
 		await exec.delete(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
+		return result.rows.map((row) => row.f_event_id);
 	}
-	/** 事件行可能被多个会话共享（fork 派生），所以孤儿只能在全库范围内判定。 */
 	async collectOrphans() {
 		const tEvents = this.tables["t_events"];
 		const tEventUsage = this.tables["t_event_usage"];
@@ -26879,7 +26782,6 @@ var PostgresBackend = class PostgresBackend {
 		await this.db.delete(tEventUsage).where(notInArray(tEventUsage.fEventId, this.db.select({ fEventId: tEvents.fEventId }).from(tEvents))).execute();
 		return result.rowCount ?? 0;
 	}
-	/** 父会话被删后留下的 subagent 会话：父已不在表里，或本来就没有父。 */
 	async listOrphanSubagentSessions() {
 		const tSessions = this.tables["t_sessions"];
 		return (await this.db.execute(sql`
@@ -26890,16 +26792,26 @@ var PostgresBackend = class PostgresBackend {
     `)).rows.map((row) => row.id);
 	}
 	async deleteSessions(exec, ids) {
-		if (ids.length === 0) return 0;
-		await exec.delete(this.tables["t_session_events"]).where(inArray(this.tables["t_session_events"].fSessionId, ids)).execute();
+		if (ids.length === 0) return {
+			deleted: 0,
+			eventIds: []
+		};
+		const removed = await exec.execute(sql`
+      DELETE FROM ${this.tables["t_session_events"]}
+       WHERE f_session_id IN (${sql.join(ids.map((id) => sql`${id}`), sql`, `)})
+      RETURNING f_event_id
+    `);
 		await exec.delete(this.tables["t_workspace_sessions"]).where(inArray(this.tables["t_workspace_sessions"].fSessionId, ids)).execute();
 		await exec.delete(this.tables["t_session_projcache_row"]).where(inArray(this.tables["t_session_projcache_row"].fSessionId, ids)).execute();
-		return (await exec.delete(this.tables["t_sessions"]).where(inArray(this.tables["t_sessions"].fSessionId, ids)).execute()).rowCount ?? 0;
+		const result = await exec.delete(this.tables["t_sessions"]).where(inArray(this.tables["t_sessions"].fSessionId, ids)).execute();
+		return {
+			deleted: Number(result.rowCount ?? 0),
+			eventIds: removed.rows.map((row) => row.f_event_id)
+		};
 	}
 	async vacuum() {
 		await this.db.execute(sql`VACUUM ANALYZE`);
 	}
-	/** 派生统计表的回填：任一表为空即按事件表全量重算（幂等，迁移删表重建后自愈）。 */
 	async backfillUsageTables() {
 		await this.backfillEventUsage();
 		await this.backfillSessionUsage();
@@ -26909,10 +26821,6 @@ var PostgresBackend = class PostgresBackend {
 		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"];
@@ -26951,7 +26859,6 @@ var PostgresBackend = class PostgresBackend {
       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"];
@@ -26970,7 +26877,6 @@ var PostgresBackend = class PostgresBackend {
       ON CONFLICT DO NOTHING
     `);
 	}
-	/** 会话 × 本地日的活动计数：从桥接行 × 事件类型重算。 */
 	async backfillSessionCounts() {
 		if (!await this.tableIsEmpty(this.qualifiedTable("t_session_counts"))) return;
 		const tSessionCounts = this.tables["t_session_counts"];
@@ -26992,7 +26898,6 @@ var PostgresBackend = class PostgresBackend {
       ON CONFLICT DO NOTHING
     `);
 	}
-	/** 用量聚合：与 SQLite 侧同形，读 `t_event_usage`，数值列回来是字符串。 */
 	async listSessionRows(query = {}) {
 		const needle = query.query?.trim().toLowerCase() ?? "";
 		const like = `%${needle}%`;
@@ -27042,10 +26947,6 @@ var PostgresBackend = class PostgresBackend {
 			total: numeric(counted.rows[0]?.["n"] ?? 0)
 		};
 	}
-	/**
-	* 用量聚合：与 SQLite 侧同形——只读三张派生统计表（用量行给去重口径的总量与「天 × 模型」桶，
-	* 两张会话汇总表给按会话的行），数值列回来是字符串。物化列让这里不做 `EXISTS`、不回连事件表。
-	*/
 	async usageReport(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)}`;
@@ -27135,12 +27036,10 @@ var PostgresBackend = class PostgresBackend {
 			}))
 		};
 	}
-	/** 表名限定到配置的 schema。 */
 	qualifiedTable(name) {
 		const schema = this.options.schema ?? "public";
 		return schema === "public" ? name : `"${schema}".${name}`;
 	}
-	/** token 用量旁路累加：派生表 `t_session_usage`，不在写事务里（失败可丢，表可销毁重建）。 */
 	async incrementSessionUsage(id, buckets) {
 		if (buckets.length === 0) return;
 		const tSessionUsage = this.tables["t_session_usage"];
@@ -27159,7 +27058,6 @@ var PostgresBackend = class PostgresBackend {
           f_total_tokens = ${tSessionUsage}.f_total_tokens + EXCLUDED.f_total_tokens
       `);
 	}
-	/** 活动计数旁路累加：派生表 `t_session_counts`，同上（四项计数一次落）。 */
 	async incrementSessionCounts(id, buckets) {
 		if (buckets.length === 0) return;
 		const tSessionCounts = this.tables["t_session_counts"];
@@ -27175,7 +27073,6 @@ var PostgresBackend = class PostgresBackend {
           f_tool_calls = ${tSessionCounts}.f_tool_calls + EXCLUDED.f_tool_calls
       `);
 	}
-	/** 按会话重算两张汇总表（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
 	async rebuildSessionStats(id) {
 		const tSessionUsage = this.tables["t_session_usage"];
 		const tSessionCounts = this.tables["t_session_counts"];
@@ -27211,20 +27108,23 @@ var PostgresBackend = class PostgresBackend {
        GROUP BY 1, 2
     `);
 	}
-	/** 全量重算用量行的引用标记（rewind / fork / 会话删除之后）。 */
-	async refreshEventUsageFlags() {
+	async refreshEventUsageFlags(eventIds) {
 		const tEventUsage = this.tables["t_event_usage"];
 		const tSessionEvents = this.tables["t_session_events"];
 		const tSessions = this.tables["t_sessions"];
-		await this.db.execute(sql`
-      UPDATE ${tEventUsage} SET
-        f_referenced = (EXISTS (SELECT 1 FROM ${tSessionEvents} rb
-                                 WHERE rb.f_event_id = ${tEventUsage}.f_event_id))::int,
-        f_subagent = (EXISTS (SELECT 1 FROM ${tSessionEvents} sb
-                                JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
-                               WHERE sb.f_event_id = ${tEventUsage}.f_event_id
-                                 AND ss.f_origin = 'subagent'))::int
-    `);
+		for (let at = 0; at < eventIds.length; at += REFRESH_FLAG_CHUNK) {
+			const chunk = eventIds.slice(at, at + REFRESH_FLAG_CHUNK);
+			await this.db.execute(sql`
+        UPDATE ${tEventUsage} SET
+          f_referenced = (EXISTS (SELECT 1 FROM ${tSessionEvents} rb
+                                   WHERE rb.f_event_id = ${tEventUsage}.f_event_id))::int,
+          f_subagent = (EXISTS (SELECT 1 FROM ${tSessionEvents} sb
+                                  JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
+                                 WHERE sb.f_event_id = ${tEventUsage}.f_event_id
+                                   AND ss.f_origin = 'subagent'))::int
+         WHERE f_event_id IN (${sql.join(chunk.map((id) => sql`${id}`), sql`, `)})
+      `);
+		}
 	}
 	async deleteSessionStats(id) {
 		await this.db.execute(sql`DELETE FROM ${this.tables["t_session_usage"]} WHERE f_session_id = ${id}`);
@@ -27284,11 +27184,6 @@ function physicalEvent(row) {
 		...row.fSurfaceOp !== null ? { surfaceOp: JSON.parse(row.fSurfaceOp) } : {}
 	};
 }
-/**
-* 读旧格式用的 catalog：v3→v4 这条边要求显式子会话证据（上游 0.1.7 起），本仓库声明
-* **无子会话证据**——v3 的目录事实由父会话自己在成功路径上写成 `subagent/catalog` 事件，
-* 迁移的 child evidence 只是补偿入口；我们没有更权威的子集合来源可给（见 ADR-跟随上游session-format-v4）。
-*/
 const restoreCatalog = createSessionFormatCatalogWithChildren([]);
 function convertLegacyRows(row, eventRows) {
 	const restore = restoreCatalog.createRestore(physicalHeader(row), {
@@ -27466,7 +27361,6 @@ var SessionBranchRdbProvider = class {
 			internals.dropReuseEventIds(childId);
 			throw error;
 		}
-		await this.persistence.rebuildSessionStats(childId);
 		return childId;
 	}
 	async rewind(id, toBoundary, signal) {
@@ -27539,7 +27433,6 @@ var SessionBranchRdbProvider = class {
 			headSeq: keepLength - 1,
 			snapshotEvents: () => []
 		});
-		await this.persistence.rebuildSessionStats(id);
 		return {
 			header: rowToMeta(row),
 			revision: await internals.readStoredRevision(id)
@@ -28814,7 +28707,6 @@ function unzip(data, opts, cb) {
 //#endregion
 //#region ../session-rdb/src/import.ts
 const SESSION_LOG_ARTIFACT_FILENAME = "session.jsonl";
-const SESSION_IMPORT_PATH = "/api/session.import";
 const MAX_IMPORT_ZIP_BYTES = 67108864;
 function parseJsonlArtifact(content) {
 	const lines = content.split("\n");
@@ -28875,11 +28767,6 @@ function parseJsonlArtifact(content) {
 		events
 	};
 }
-/**
-* fflate 的 `unzip` 是回调式异步 API（node 侧内部走 worker_threads，浏览器侧走 Web Worker），
-* 这里桥成 Promise。它与 `unzipSync` 的差异只在同步/异步：非法 zip 走的是同一段校验代码，
-* 拒绝的错误对象与同步版一致，因此上层文案无需区分。
-*/
 function unzipAsync(data) {
 	return new Promise((resolve, reject) => {
 		unzip(data, (error, entries) => {
@@ -29020,7 +28907,6 @@ function registerSessionImport(ctx, persistence) {
 }
 //#endregion
 //#region ../session-rdb/src/deletion.ts
-const SESSION_DELETE_PATH = "/api/session.delete";
 const STATUS_OF_DELETION_ERROR = {
 	SESSION_NOT_FOUND: 404,
 	SESSION_NOT_ARCHIVED: 409,
@@ -29083,12 +28969,9 @@ function registerSessionDeletion(ctx, persistence) {
 }
 //#endregion
 //#region ../session-rdb/src/export.ts
-const SESSION_EXPORT_PATH = "/api/session.export";
-/** 文件名只保留安全字符：会话 id 来自请求体，会写进 Content-Disposition。 */
 function safeFilename(sessionId) {
 	return sessionId.replace(/[^A-Za-z0-9._-]/gu, "_");
 }
-/** fflate 只给回调式异步 API（同步变体被 node/no-sync 禁止）。 */
 function zipBytes(files) {
 	return new Promise((resolve, reject) => {
 		zip(files, (error, data) => {
@@ -29097,7 +28980,6 @@ function zipBytes(files) {
 		});
 	});
 }
-/** 导出通道：直接把会话日志打成 zip 响应体，与导入通道读同一份 artifact。 */
 function registerSessionExport(ctx, persistence) {
 	ctx.inject(["webServer", "connection"], (webCtx) => {
 		const webServer = webCtx.webServer;
@@ -29157,15 +29039,12 @@ function registerSessionExport(ctx, persistence) {
 }
 //#endregion
 //#region ../session-rdb/src/gc.ts
-const SESSION_GC_PATH = "/api/session.gc";
-/** 让所有运行中的 agent 先退场：GC 要重写事件表，运行中的写路径必须停下来。 */
 async function stopRunningAgents(ctx) {
 	const running = ctx.get("agents")?.list() ?? [];
 	for (const agent of running) agent.cancel?.({ kind: "user" }, { keepInbox: true });
 	await Promise.all(running.map((agent) => agent.whenIdle()));
 	return running.length;
 }
-/** GC 通道：停 agent → 回收孤儿事件行 → VACUUM，一次请求完成。 */
 function registerSessionGc(ctx, persistence) {
 	ctx.inject(["webServer", "connection"], (webCtx) => {
 		const webServer = webCtx.webServer;
@@ -29207,15 +29086,6 @@ function registerSessionGc(ctx, persistence) {
 }
 //#endregion
 //#region ../session-rdb/src/rows.ts
-/**
-* 管理面的会话列表：**我们自己的**一条路由（完整语料，含归档），与官方 `session/list` 分开。
-*
-* 官方那条（`session/list` → `ctx.sessionQuery.listSessions`）按部署策略默认排除已归档——那是给上游
-* UI 用的。归档集的管理动作要有完整列表，所以这里单独给一条：标题直接从会话列取，最后活动时间用
-* 该会话最后一个事件的时间。
-*/
-const SESSION_ROWS_PATH = "/api/session.rows";
-/** 一页的条数上限：超过就按上限截断（这个接口给页面用，不是导出通道）。 */
 const MAX_PAGE_SIZE = 200;
 const DEFAULT_PAGE_SIZE = 20;
 function registerSessionRows(ctx, backend) {
@@ -36201,19 +36071,12 @@ var SessionQueryRdb = class extends SessionQueryEngine {
 	constructor(ctx, config = {}) {
 		super(ctx, config);
 	}
-	/**
-	* 官方列表（`session/list`）**默认不含已归档**：归档是「收起来」的会话，列表与搜索都不该把它混进
-	* 日常集合（上游 client 再用 workspace registry 的归档集做「只看归档」的派生）。
-	*
-	* 完整语料（含归档）走我们自己的管理面路由 `SESSION_ROWS_PATH`——两条路分开，不在一处混。
-	*/
 	async listSessions(signal) {
 		const records = await super.listSessions(signal);
 		const archived = this.archivedSessionIds();
 		if (archived.size === 0) return records;
 		return records.filter((record) => !archived.has(String(record.header.id)));
 	}
-	/** 归档集合来自 workspace registry；服务未就绪时保守返回空集（宁可多给，不可漏掉可见会话）。 */
 	archivedSessionIds() {
 		const registry = this.ctx.get("workspaceRegistry");
 		return new Set(registry?.archivedSessionIds ?? []);
@@ -36303,10 +36166,6 @@ var SessionProjectionCacheRdb = class extends Service {
 		if (record === void 0) return void 0;
 		return identityMatches(record.identity, expected) ? record : void 0;
 	}
-	/**
-	* header-only 读（会话列表这类）：上游 0.1.7 起只给 header 与 keys——它要求的是**生命周期**身份，
-	* 不再要求调用方提供 inherited cut（那个 cut 只有写路径与 hydration 用得上）。
-	*/
 	cachedSnapshot(meta, keys) {
 		const record = this.recordForLifecycle(meta);
 		const snapshot = record === void 0 ? void 0 : this.viewRecord(record, keys);
@@ -36449,7 +36308,6 @@ function detachJson(rows) {
 	if (text === void 0) throw new TypeError("projection checkpoint is not losslessly JSON-serializable");
 	return JSON.parse(text);
 }
-/** header 能证明的生命周期身份（不含 inherited cut）：header-only 读只比对它。 */
 function lifecycleIdentityOf(header) {
 	return {
 		formatVersion: header.version,
@@ -36622,7 +36480,6 @@ function installStorageTakeover(ctx, options) {
 //#endregion
 //#region ../session-rdb/src/index.ts
 init_esm();
-/** 一批事件里的最大时间：写路径据此推进会话行的「最后活动时间」。 */
 function maxEventTime(events) {
 	let max;
 	for (const event of events) {
@@ -36890,12 +36747,7 @@ 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。",
@@ -36955,7 +36807,6 @@ 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);
@@ -37098,27 +36949,24 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 		if (row.fArchivedAt === null) throw new SessionDeletionError(`session "${id}" is not archived; only archived sessions can be deleted`, "SESSION_NOT_ARCHIVED");
 		if (this.tracker.hasPending(id) || this.tracker.hasOpenHandle(id)) throw new SessionDeletionError(`session "${id}" is live; stop it before deleting`, "SESSION_LIVE");
 		await this.unarchiveBeforeDeletion(id);
-		await this.backend.transaction(async (tx) => {
-			await tx.deleteSession(id);
-		});
+		const referenced = await this.backend.transaction((tx) => tx.deleteSession(id));
 		this.liveBuffers.delete(id);
 		this.liveReady.delete(id);
 		this.liveFailures.delete(id);
 		this.liveDropWarned.delete(id);
 		this.reuseEventIds.delete(id);
 		await this.dropSessionStats(id);
+		await this.refreshEventUsageFlags(referenced);
 	}
-	/** GC 通道：回收已无桥接行引用的事件行（孤儿），返回删除行数。 */
 	async collectOrphans() {
 		await this.ready;
 		return this.backend.collectOrphans();
 	}
-	/** GC 通道：回收父已不存在的 subagent 会话（live 的跳过），返回删除的会话数。 */
 	async collectOrphanSessions() {
 		await this.ready;
 		const deletable = (await this.backend.listOrphanSubagentSessions()).filter((id) => !this.tracker.hasPending(id) && !this.tracker.hasOpenHandle(id));
 		if (deletable.length === 0) return 0;
-		const deleted = await this.backend.transaction((tx) => tx.deleteSessions(deletable));
+		const { deleted, eventIds } = await this.backend.transaction((tx) => tx.deleteSessions(deletable));
 		for (const id of deletable) {
 			this.liveBuffers.delete(id);
 			this.liveReady.delete(id);
@@ -37127,14 +36975,13 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 			this.reuseEventIds.delete(id);
 			await this.dropSessionStats(id);
 		}
+		await this.refreshEventUsageFlags(eventIds);
 		return deleted;
 	}
-	/** 用量统计：SQL 聚合的按天 × 模型桶与按会话行（事件行去重、排除孤儿行）。 */
 	async usageReport(sinceMs) {
 		await this.ready;
 		return this.backend.usageReport(sinceMs);
 	}
-	/** GC 通道：VACUUM；调用方需先停止运行中的写路径（见 `registerSessionGc`）。 */
 	async vacuum() {
 		await this.ready;
 		await this.backend.vacuum();
@@ -37268,11 +37115,6 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 			...tornFrom !== void 0 ? { tornFrom } : {}
 		};
 	}
-	/**
-	* 统计衍生表的**旁路累加**：不在写事务里、失败只 warn——两张会话汇总表都是可销毁重建的
-	* 派生表，丢几次累加不影响可用性（需要时用 `rebuildSessionStats` 重算）。
-	* token 走写路径已折好的用量行，活动计数走本批事件类型。
-	*/
 	async recordSessionStats(id, events, usageRows) {
 		const usageBuckets = sessionUsageBuckets(usageRows);
 		if (usageBuckets.length > 0) try {
@@ -37287,33 +37129,36 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 			this.ctx.logger.warn(`session-rdb: activity counts for "${id}" not updated (${describeError(error)})`);
 		}
 	}
-	/**
-	* 重算一个会话的统计（rewind / fork 之后；best-effort，同 `recordSessionStats`）：
-	* 两张汇总表按会话重算，用量行的引用标记全量重算（引用可能跨会话消失）。
-	*/
 	async rebuildSessionStats(id) {
 		try {
 			await this.backend.rebuildSessionStats(id);
-			await this.backend.refreshEventUsageFlags();
 		} catch (error) {
 			this.ctx.logger.warn(`session-rdb: session stats for "${id}" not rebuilt (${describeError(error)})`);
 		}
 	}
-	/** 会话删除时清掉它的汇总行，并重算用量行的引用标记（被删会话引用的行要立刻退出统计）。 */
+	async refreshEventUsageFlags(eventIds) {
+		const unique = [...new Set(eventIds)];
+		if (unique.length === 0) return;
+		try {
+			await this.backend.refreshEventUsageFlags(unique);
+		} catch (error) {
+			this.ctx.logger.warn(`session-rdb: usage reference flags not refreshed (${describeError(error)})`);
+		}
+	}
 	async dropSessionStats(id) {
 		try {
 			await this.backend.deleteSessionStats(id);
-			await this.backend.refreshEventUsageFlags();
 		} catch (error) {
 			this.ctx.logger.warn(`session-rdb: session stats for "${id}" not deleted (${describeError(error)})`);
 		}
 	}
 	async rewriteMigratedLog(id, log) {
+		let removed = [];
 		await this.backend.transaction(async (tx) => {
 			const head = await tx.getHead(id);
 			if (!this.writeGuard.has(id)) this.writeGuard.confirmHead(id, head.fHeadSequence);
 			this.writeGuard.assertNoConcurrentWriter(id, head.fHeadSequence);
-			await tx.deleteBridgeTail(id, 0);
+			removed = await tx.deleteBridgeTail(id, 0);
 			await tx.upsertSession({
 				meta: log.meta,
 				inheritedEventCount: SessionLogOffset(log.inheritedEventCount)
@@ -37326,6 +37171,7 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 			await tx.bumpRevision(id, maxEventTime(log.events));
 		});
 		await this.rebuildSessionStats(id);
+		await this.refreshEventUsageFlags(removed);
 	}
 	async listSnapshots(signal) {
 		signal?.throwIfAborted();
@@ -37415,7 +37261,6 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 	registerReuseEventIds(childId, map) {
 		this.reuseEventIds.set(childId, new Map(map));
 	}
-	/** 丢弃一个还没被消费的复用映射（fork 失败时）：留着会让同一个 childId 之后的落写复用父会话的事件行。 */
 	dropReuseEventIds(childId) {
 		this.reuseEventIds.delete(childId);
 	}
@@ -37555,7 +37400,6 @@ function seedCoversPrefix(seed, prefix) {
 		return seedEvent !== void 0 && JSON.stringify(seedEvent) === JSON.stringify(event);
 	});
 }
-/** 一批事件折成活动计数的桶：只数四种类型，按本地日聚合成四项。 */
 function sessionCountBuckets(events) {
 	const counted = /* @__PURE__ */ new Map();
 	for (const event of events) {
@@ -37573,7 +37417,6 @@ function sessionCountBuckets(events) {
 	}
 	return [...counted.values()];
 }
-/** 一批用量行折成 token 桶：按「本地日 × 模型」聚合（模型未知落空串，与表口径一致）。 */
 function sessionUsageBuckets(usageRows) {
 	const counted = /* @__PURE__ */ new Map();
 	for (const row of usageRows) {
@@ -37927,4 +37770,4 @@ function turnLog(base, turn, opts = {}) {
 	return events;
 }
 //#endregion
-export { SESSION_EDITOR_PATH, Session, SessionIdBrand, SessionSeq, SessionStore, TokenMeter, assistantMessage, createPersisted, harness, meta, oneTurnLog, parseJsonlArtifact, turnLog, twoTurnLog, userMessage };
+export { SESSION_EDITOR_PATHS, Session, SessionIdBrand, SessionSeq, SessionStore, TokenMeter, assistantMessage, createPersisted, harness, meta, oneTurnLog, parseJsonlArtifact, turnLog, twoTurnLog, userMessage };