@morlay/session-rdb 0.1.1 → 0.1.3

package/dist/{src-BZ1tffd5.mjs → src-BmogreEz.mjs}

@@ -1,7 +1,8 @@
-import { C as postgresTableDefs, T as WriteGuard, a as EVENT_ENCODING, c as eventDimensions, i as DEFAULT_BUSY_TIMEOUT_MS, r as createStorageRepository, t as SqliteBackend, w as toPostgresSchema } from "./sqlite-SCiSnwaz.mjs";
+import { C as postgresTableDefs, T as WriteGuard, a as EVENT_ENCODING, c as eventDimensions, i as DEFAULT_BUSY_TIMEOUT_MS, r as createStorageRepository, t as SqliteBackend, w as toPostgresSchema } from "./sqlite-YCr2-Fov.mjs";
+import { a as SESSION_ROWS_PATH, t as SESSION_DELETE_PATH } from "./routes-DGBlBE_I.mjs";
 import { COUNTED_EVENT_TYPES, addActivityCount, addActivityTotals, addTokenTotals, addTotals, emptyTotals, localDayKey, registerSessionUsage } from "./usage.mjs";
-import { S as usageRowOf, _ as sessionConflictRow, b as titleOfEventData, g as sealOwnEvents, h as scanRows, m as rowToMeta, r as needsShapeAdoption, u as repairReadView, v as sessionInsertRow, x as toJsonlArtifact } from "./log-BWVFYAh5.mjs";
-import { c as isLegacyVersion, o as adoptLegacyRows, s as convertLegacyRows, t as SessionBranchRdb } from "./branch-D4nVzQQM.mjs";
+import { S as usageRowOf, _ as sessionConflictRow, b as titleOfEventData, g as sealOwnEvents, h as scanRows, m as rowToMeta, r as needsShapeAdoption, u as repairReadView, v as sessionInsertRow, x as toJsonlArtifact } from "./log-DYxdjJ-l.mjs";
+import { c as isLegacyVersion, o as adoptLegacyRows, s as convertLegacyRows, t as SessionBranchRdb } from "./branch-aiXPmnKC.mjs";
 import { registerSessionImport } from "./import.mjs";
 import { registerSessionExport } from "./export.mjs";
 import { registerSessionGc } from "./gc.mjs";
@@ -23,22 +24,19 @@ import { Service } from "@deepseek-ai/cordis";
 //#region 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"]),
@@ -56,7 +54,6 @@ function emptyActivity() {
 		toolCalls: 0
 	};
 }
-/** `t_session_counts` 的四项计数折成活动计数（pg 的 sum 回落成字符串）。 */
 function activityTotalsOf(row) {
 	return {
 		turns: numeric(row["turns"]),
@@ -65,7 +62,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;
@@ -252,15 +248,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"];
@@ -269,7 +271,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`
@@ -280,16 +281,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();
@@ -299,10 +310,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"];
@@ -341,7 +348,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"];
@@ -360,7 +366,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"];
@@ -382,7 +387,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}%`;
@@ -432,10 +436,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)}`;
@@ -525,12 +525,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"];
@@ -549,7 +547,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"];
@@ -565,7 +562,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"];
@@ -601,20 +597,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}`);
@@ -643,7 +642,6 @@ var PostgresBackend = class PostgresBackend {
 };
 //#endregion
 //#region src/deletion.ts
-const SESSION_DELETE_PATH = "/api/session.delete";
 const STATUS_OF_DELETION_ERROR = {
 	SESSION_NOT_FOUND: 404,
 	SESSION_NOT_ARCHIVED: 409,
@@ -706,15 +704,6 @@ function registerSessionDeletion(ctx, persistence) {
 }
 //#endregion
 //#region 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) {
@@ -778,19 +767,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 ?? []);
@@ -840,10 +822,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);
@@ -986,7 +964,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,
@@ -1158,7 +1135,6 @@ function installStorageTakeover(ctx, options) {
 }
 //#endregion
 //#region src/index.ts
-/** 一批事件里的最大时间：写路径据此推进会话行的「最后活动时间」。 */
 function maxEventTime(events) {
 	let max;
 	for (const event of events) {
@@ -1426,12 +1402,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 = z.object({
 	writeEveryEvents: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS).description(localized({
 		zh: "每累计这么多事件写回一次投影 checkpoint。",
@@ -1491,7 +1462,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);
@@ -1634,27 +1604,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);
@@ -1663,14 +1630,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();
@@ -1804,11 +1770,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 {
@@ -1823,33 +1784,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)
@@ -1862,6 +1826,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();
@@ -1951,7 +1916,6 @@ var SessionPersistenceRdb = class extends SessionPersistence {
 	registerReuseEventIds(childId, map) {
 		this.reuseEventIds.set(childId, new Map(map));
 	}
-	/** 丢弃一个还没被消费的复用映射（fork 失败时）：留着会让同一个 childId 之后的落写复用父会话的事件行。 */
 	dropReuseEventIds(childId) {
 		this.reuseEventIds.delete(childId);
 	}
@@ -2091,7 +2055,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) {
@@ -2109,7 +2072,6 @@ function sessionCountBuckets(events) {
 	}
 	return [...counted.values()];
 }
-/** 一批用量行折成 token 桶：按「本地日 × 模型」聚合（模型未知落空串，与表口径一致）。 */
 function sessionUsageBuckets(usageRows) {
 	const counted = /* @__PURE__ */ new Map();
 	for (const row of usageRows) {
@@ -2209,4 +2171,4 @@ async function appendEventTail(tx, meta, events, anchor, reuse) {
 	};
 }
 //#endregion
-export { registerSessionDeletion as a, SESSION_DELETE_PATH as i, SessionPersistenceRdb as n, SESSION_ROWS_PATH as r, SessionDeletionError as t };
+export { SessionPersistenceRdb as n, registerSessionDeletion as r, SessionDeletionError as t };

package/dist/storage.d.mts

@@ -1,14 +1,14 @@
-import { A as SessionRow, At as tWorkspaceState, Ct as tSessionCounts, D as SessionCountBucket, Dt as tSessions, E as EventRow, Et as tSessionUsage, I as UsageAggregate, Mt as WriteGuard, Nt as StorageRepository, O as SessionListRowsPage, Ot as tStorageUnits, St as tSchemaMeta, T as BackendTx, Tt as tSessionProjcacheRows, _t as eventDimensions, bt as tEvents, dt as EVENT_ENCODING, ft as EventKind, gt as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, ht as SCHEMA_VERSION, j as SessionUsageBucket, jt as tWorkspaces, k as SessionListRowsQuery, kt as tWorkspaceSessions, mt as JournalMode, pt as EventRole, ut as DEFAULT_BUSY_TIMEOUT_MS, vt as eventKind, w as Backend, wt as tSessionEvents, xt as tPersistenceState, yt as tEventUsage } from "./log-CUjKQbOR.mjs";
+import { A as SessionRow, At as WriteGuard, Ct as tSessionProjcacheRows, D as SessionCountBucket, Dt as tWorkspaceSessions, E as EventRow, Et as tStorageUnits, F as UsageAggregate, Lt as StorageRepository, O as SessionListRowsPage, Ot as tWorkspaceState, St as tSessionEvents, T as BackendTx, Tt as tSessions, _t as tEventUsage, bt as tSchemaMeta, ct as DEFAULT_BUSY_TIMEOUT_MS, dt as EventRole, ft as JournalMode, gt as eventKind, ht as eventDimensions, j as SessionUsageBucket, k as SessionListRowsQuery, kt as tWorkspaces, lt as EVENT_ENCODING, mt as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, pt as SCHEMA_VERSION, ut as EventKind, vt as tEvents, w as Backend, wt as tSessionUsage, xt as tSessionCounts, yt as tPersistenceState } from "./log-DYyxRh7j.mjs";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { DatabaseSync } from "node:sqlite";
 //#region src/sqlite.d.ts
-declare function openDatabase(path: string, journalMode: JournalMode, busyTimeout?: number): Promise<DatabaseSync>;
-interface SqliteBackendOptions {
+export declare function openDatabase(path: string, journalMode: JournalMode, busyTimeout?: number): Promise<DatabaseSync>;
+export interface SqliteBackendOptions {
   path: string;
   journalMode: JournalMode;
   busyTimeout: number;
 }
-declare class SqliteBackend implements Backend {
+export declare class SqliteBackend implements Backend {
   private readonly options;
   readonly kind: "sqlite";
   storeIdentity: string;
@@ -42,38 +42,18 @@ declare class SqliteBackend implements Backend {
   private deleteBridgeTail;
   private getPrevBridge;
   private deleteSession;
-  /** 事件行可能被多个会话共享（fork 派生），所以孤儿只能在全库范围内判定。 */
   collectOrphans(): Promise<number>;
-  /** 父会话被删后留下的 subagent 会话：父已不在表里，或本来就没有父。 */
   listOrphanSubagentSessions(): Promise<SessionId[]>;
   private deleteSessions;
-  /**
-   * 用量聚合：token 用量沿 `t_event_usage` 的用量行，活动计数（轮次 / 步骤 / 用户输入 / 工具调用）
-   * 沿 `t_events` 的事件类型数——两者限定在**有 token 用量的会话**里，时间范围各自按自己的
-   * `f_created_at`（同一时刻写入，口径一致）。
-   */
   listSessionRows(query?: SessionListRowsQuery): Promise<SessionListRowsPage>;
-  /**
-   * 用量聚合：只读三张派生统计表——事件级用量行给去重口径的总量与「天 × 模型」桶，
-   * `t_session_usage` / `t_session_counts` 给按会话的行（含 fork 继承前缀）。
-   * 归属、本地日与「是否被引用」都是物化列，这里不再现算、也不回连事件表。
-   * 事件级按毫秒时间戳过滤、汇总表按本地日过滤——`sinceMs` 对齐到本地零点时两者等价。
-   */
   usageReport(sinceMs?: number): Promise<UsageAggregate>;
-  /** token 用量旁路累加：派生表 `t_session_usage`，不在写事务里（失败可丢，表可销毁重建）。 */
   incrementSessionUsage(id: SessionId, buckets: readonly SessionUsageBucket[]): Promise<void>;
-  /** 活动计数旁路累加：派生表 `t_session_counts`，同上（四项计数一次落）。 */
   incrementSessionCounts(id: SessionId, buckets: readonly SessionCountBucket[]): Promise<void>;
-  /** 按会话重算两张汇总表（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
   rebuildSessionStats(id: SessionId): Promise<void>;
-  /**
-   * 全量重算用量行的引用标记：rewind 截断 / fork 复用 / 会话删除都会让「引用」跨会话变化，
-   * 只按本会话判定不够。低频路径，一次全表 UPDATE（3 万行量级）。
-   */
-  refreshEventUsageFlags(): Promise<void>;
+  refreshEventUsageFlags(eventIds: readonly string[]): Promise<void>;
   deleteSessionStats(id: SessionId): Promise<void>;
   vacuum(): Promise<void>;
   private eventRows;
 }
 //#endregion
-export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, EventKind, EventRole, type EventRow, JournalMode, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, type SessionRow, SqliteBackend, SqliteBackendOptions, WriteGuard, eventDimensions, eventKind, openDatabase, tEventUsage, tEvents, tPersistenceState, tSchemaMeta, tSessionCounts, tSessionEvents, tSessionProjcacheRows, tSessionUsage, tSessions, tStorageUnits, tWorkspaceSessions, tWorkspaceState, tWorkspaces };
+export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, EventKind, EventRole, type EventRow, JournalMode, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, type SessionRow, WriteGuard, eventDimensions, eventKind, tEventUsage, tEvents, tPersistenceState, tSchemaMeta, tSessionCounts, tSessionEvents, tSessionProjcacheRows, tSessionUsage, tSessions, tStorageUnits, tWorkspaceSessions, tWorkspaceState, tWorkspaces };

package/dist/storage.mjs

@@ -1,2 +1,2 @@
-import { S as tWorkspaces, T as WriteGuard, _ as tSessionUsage, a as EVENT_ENCODING, b as tWorkspaceSessions, c as eventDimensions, d as tEvents, f as tPersistenceState, g as tSessionProjcacheRows, h as tSessionEvents, i as DEFAULT_BUSY_TIMEOUT_MS, l as eventKind, m as tSessionCounts, n as openDatabase, o as SCHEMA_VERSION, p as tSchemaMeta, s as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, t as SqliteBackend, u as tEventUsage, v as tSessions, x as tWorkspaceState, y as tStorageUnits } from "./sqlite-SCiSnwaz.mjs";
+import { S as tWorkspaces, T as WriteGuard, _ as tSessionUsage, a as EVENT_ENCODING, b as tWorkspaceSessions, c as eventDimensions, d as tEvents, f as tPersistenceState, g as tSessionProjcacheRows, h as tSessionEvents, i as DEFAULT_BUSY_TIMEOUT_MS, l as eventKind, m as tSessionCounts, n as openDatabase, o as SCHEMA_VERSION, p as tSchemaMeta, s as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, t as SqliteBackend, u as tEventUsage, v as tSessions, x as tWorkspaceState, y as tStorageUnits } from "./sqlite-YCr2-Fov.mjs";
 export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, SqliteBackend, WriteGuard, eventDimensions, eventKind, openDatabase, tEventUsage, tEvents, tPersistenceState, tSchemaMeta, tSessionCounts, tSessionEvents, tSessionProjcacheRows, tSessionUsage, tSessions, tStorageUnits, tWorkspaceSessions, tWorkspaceState, tWorkspaces };

package/dist/testing.d.mts

@@ -1,4 +1,4 @@
-import { ot as truncateLiveSession } from "./log-CUjKQbOR.mjs";
+import { at as truncateLiveSession } from "./log-DYyxRh7j.mjs";
 import { SessionPersistence } from "@deepseek-ai/dsh-session-persistence";
 import { Session, SessionEvent, SessionHeader, SessionId } from "@deepseek-ai/dsh-session";
 import { Context, Fiber } from "@deepseek-ai/cordis";
@@ -11,10 +11,10 @@ interface ContractBackend extends ContractBackendInstance {
   reopen?: () => Promise<ContractBackendInstance>;
   corruptTail?: (id: SessionId, cwd: string | undefined) => Promise<void>;
 }
-declare function meta(id: string, cwd?: string): SessionHeader;
-declare function oneTurnLog(): SessionEvent[];
-declare function appendLog(session: Session, events: readonly SessionEvent[]): void;
-declare function runPersistenceContract(name: string, make: () => Promise<ContractBackend>): void;
+export declare function meta(id: string, cwd?: string): SessionHeader;
+export declare function oneTurnLog(): SessionEvent[];
+export declare function appendLog(session: Session, events: readonly SessionEvent[]): void;
+export declare function runPersistenceContract(name: string, make: () => Promise<ContractBackend>): void;
 //#endregion
 //#region src/testing/coordinator-contract.d.ts
 interface CoordinatorFixture {
@@ -22,6 +22,6 @@ interface CoordinatorFixture {
   corruptTail?: (id: SessionId, cwd: string | undefined) => Promise<void>;
   cleanup: () => Promise<void>;
 }
-declare function runCoordinatorContract(name: string, makeFixture: () => Promise<CoordinatorFixture>): void;
+export declare function runCoordinatorContract(name: string, makeFixture: () => Promise<CoordinatorFixture>): void;
 //#endregion
-export { type ContractBackend, type CoordinatorFixture, appendLog, meta, oneTurnLog, runCoordinatorContract, runPersistenceContract, truncateLiveSession };
+export { type ContractBackend, type CoordinatorFixture, truncateLiveSession };

package/dist/testing.mjs

@@ -1,11 +1,9 @@
-import { a as truncateLiveSession } from "./branch-D4nVzQQM.mjs";
+import { t as __commonJSMin } from "./rolldown-runtime-EAsCxrDo.mjs";
+import { a as truncateLiveSession } from "./branch-aiXPmnKC.mjs";
 import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionFormatUnsupportedError, SessionHandleClosedError, SessionPersistenceNotFoundError, SessionReadOnlyError } from "@deepseek-ai/dsh-session-persistence";
 import SessionStore, { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
 import { Context } from "@deepseek-ai/cordis";
 import { MessageId, createUserMessage, freezeMessage } from "@deepseek-ai/dsh-llm";
-//#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-//#endregion
 //#region ../../../node_modules/.pnpm/vitest@5.0.2_@opentelemetry+api@1.9.1_@types+node@26.6.3_happy-dom@20.14.5_jsdom@30.1.1_5bd35cff0016eb681427af506a019366/node_modules/vitest/dist/chunks/tinyrainbow.Ht9iggcq.js
 var b$1 = {
 	reset: [0, 0],

package/dist/usage.d.mts

@@ -1,2 +1,2 @@
-import { B as UsageTokenTotals, F as UsageActivityTotals, G as addTotals, H as addActivityCount, I as UsageAggregate, J as registerSessionUsage, K as emptyTotals, L as UsageBucket, M as COUNTED_EVENT_TYPES, N as SESSION_USAGE_PATH, P as SessionUsageReport, R as UsageRangeKey, U as addActivityTotals, V as UsageTotals, W as addTokenTotals, Y as resolveUsageSince, q as localDayKey, z as UsageSessionRow } from "./log-CUjKQbOR.mjs";
+import { B as UsageTotals, F as UsageAggregate, G as emptyTotals, H as addActivityTotals, I as UsageBucket, It as SESSION_USAGE_PATH, J as resolveUsageSince, K as localDayKey, L as UsageRangeKey, M as COUNTED_EVENT_TYPES, N as SessionUsageReport, P as UsageActivityTotals, R as UsageSessionRow, U as addTokenTotals, V as addActivityCount, W as addTotals, q as registerSessionUsage, z as UsageTokenTotals } from "./log-DYyxRh7j.mjs";
 export { COUNTED_EVENT_TYPES, SESSION_USAGE_PATH, SessionUsageReport, UsageActivityTotals, UsageAggregate, UsageBucket, UsageRangeKey, UsageSessionRow, UsageTokenTotals, UsageTotals, addActivityCount, addActivityTotals, addTokenTotals, addTotals, emptyTotals, localDayKey, registerSessionUsage, resolveUsageSince };

package/dist/usage.mjs

@@ -1,5 +1,5 @@
+import { o as SESSION_USAGE_PATH } from "./routes-DGBlBE_I.mjs";
 //#region src/usage.ts
-const SESSION_USAGE_PATH = "/api/session.usage";
 const ROLLING_DAYS = {
 	"7d": 7,
 	"30d": 30,
@@ -10,14 +10,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;
@@ -37,14 +29,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":
@@ -62,7 +52,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");
@@ -96,16 +85,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/session-rdb",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "RDB durable session backend for DeepSeek Harness: implements both session-persistence and session-branch (rewind / retry / fork) providers.",
   "keywords": [
     "branch",
@@ -39,7 +39,7 @@
     "./locale/*.json": "./locale/*.json"
   },
   "dependencies": {
-    "@morlay/session-branch": "0.1.1",
+    "@morlay/session-branch": "0.1.3",
     "drizzle-orm": "^1.0.0-rc.5-ab785fc",
     "fflate": "^0.8.2",
     "pg": "^8.23.0"