@morlay/session-rdb 0.0.21-alpha.7 → 0.0.21-alpha.9

package/README.md

@@ -7,8 +7,8 @@ SQLite 或 PostgreSQL 后端。表结构、原样存储与各条流程的设计
 
 ## 配置
 
-配置**就是这一行的 config**（`cordis.patch.yml` 的 `session-rdb` 行，或 profile patch /
-设置页改的那份 entry config）：
+配置**就是这一行的 config**（聚合层 `@morlay/better-session` 的 `session-rdb` 行、profile patch，
+或设置页改的那份 entry config）：
 
 ```yaml
 - id: session-rdb
@@ -54,6 +54,18 @@ type Config =
     };
 ```
 
+### 设置页上的这一行
+
+`Config` **整段标了 `.volatile()`**（判别式 union 只能整段标：schemastery 不许在 union 分支内部标 volatile），
+所以 host 会描述这一行，插件管理页里按 `type` 展开当前后端的字段——与上面 YAML 里的字段一一对应。
+
+- **切后端**：`type` 是各分支的判别标签，页面上那一行给的是一个**切换控件**（`"sqlite"` ↔ `"postgres"`）；选另一支
+  就换成那一套字段（`path` ↔ `connectionString` / `schema`），页面结构与 host 侧校验的选支依据同一份。
+- **生效方式**：settings 写完 → Loader 重装这一行（`reconcileProfilePatches`）→ 用新 config 重新建连接。所以这里
+  装配时取一次快照（`this.config = config.get()`），没有运行期重连逻辑；换后端 = 换库，旧数据留在旧后端。
+- 默认值都在 schema 上（`journalMode: wal`、`busyTimeout`、`schema: public`、`projectionCache` 的节流），页面上
+  清空即回到这些默认。
+
 ## 分支能力（session-branch 闭环）
 
 除 `ctx.sessionPersistence` 外，本包还实现 `@morlay/session-branch` 的 provider
@@ -80,10 +92,10 @@ web 模式经 `POST /api/session.delete`（body `{ sessionId }`）暴露，状
 
 ## 会话列表（两条路）
 
-| 用途                  | 接缝                                                                                                            | 内容                                             |
-| --------------------- | --------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
-| 官方 UI（上游 `ui-*`）| `session/list` → `ctx.sessionQuery.listSessions`（本包接管，**默认排除已归档**）                                 | 未归档的可见语料，标题走投影（`projections.title`） |
-| 我们自己的管理面      | `POST /api/session.rows`（本包路由）                                                                            | **完整语料（含归档）** + 标题 + 最后活动时间 + 工作区归属，**搜索 / 子代理过滤 / 分页都在后端** |
+| 用途                   | 接缝                                                                             | 内容                                                                                            |
+| ---------------------- | -------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
+| 官方 UI（上游 `ui-*`） | `session/list` → `ctx.sessionQuery.listSessions`（本包接管，**默认排除已归档**） | 未归档的可见语料，标题走投影（`projections.title`）                                             |
+| 我们自己的管理面       | `POST /api/session.rows`（本包路由）                                             | **完整语料（含归档）** + 标题 + 最后活动时间 + 工作区归属，**搜索 / 子代理过滤 / 分页都在后端** |
 
 排除归档是本部署的策略：归档是「收起来」的会话，不该混进日常列表与搜索。管理动作（取消归档 / 删除 /
 导入）需要完整集合，所以另给一条自有路由，两条路不混。决策与取舍见
@@ -118,13 +130,20 @@ subagent 会话**（`origin = 'subagent'`、父不在表里；有 open handle /
 ## 用量统计
 
 `POST /api/session.usage` 一次回报三份数据：`totals`（含 `subagent` / `human` 拆分）、按
-天 × provider/model × subagent 的桶、按会话的行。
+天 × provider/model × subagent 的桶、按会话的行（活动计数：轮次 / 步骤 / 用户输入 / 工具调用）。
+
+统计读侧只读三张**可销毁重建的派生表**，读侧维度（会话 / 模型 / 本地日 / 是否被引用 / 是否子代理）
+全部在写入时物化，查询不做 `EXISTS`、也不回连事件表：
+
+- `t_event_usage`——一条 `assistant/message` 事件行一行（去重口径的总量与「天 × 模型」桶读它）；
+- `t_session_usage`——会话 × 本地日 × 模型的 token 汇总（按会话的行读它，含 fork 继承前缀）；
+- `t_session_counts`——会话 × 本地日的四项活动计数。
 
-用量写在**专用表 `t_event_usage`**（写路径顺带记录，一条 `assistant/message` 事件行一行），统计只读它，
-不再逐行解析事件 JSON——真实库实测 **1.6s → ~140ms**。老库在首次打开时**一次性回填**（表为空才跑，
-约 2.2s / 1.99 万行），两种 `f_data` 结构都认。口径不变：只算被会话引用的事件行（fork 共享行计一次、
-孤儿行不计），GC 顺带回收不再有事件行的用量行。口径与取舍见
-[ADR-用量统计走专用用量日志表](.agents/adrs/20260918-用量统计走专用用量日志表.md)。
+写入时在事务内落用量行、事务后**旁路累加**两张汇总表；rewind / fork / 删除会话之后按会话重算并全量重算
+引用标记；表为空（首次 / 迁移后 / 手动清空）在打开库时全量回填——迁移对这三张表先删后建。真实库实测
+单次统计从 **1.6s → ~140ms → ~30ms**（口径不变，旧口径逐项交叉核对一致），升级后首次打开付一次回填
+（2.4s / 3.09 万用量行，此后不再发生）。口径与取舍见
+[ADR-统计衍生表物化归属与汇总](.agents/adrs/20260923-统计衍生表物化归属与汇总.md)。
 
 ## 查询接管（`ctx.sessionQuery`）
 

package/dist/artifact.d.mts

@@ -1,102 +1,3 @@
-import { i as EventRow, s as SessionRow } from "./backend-E0bmTXpz.mjs";
+import { C as usageRowOf, S as toJsonlArtifact, _ as sealOwnEvents, a as normalizeToCurrentShape, b as syncMeteringRanges, c as renameLegacyPtcEvents, d as repairReadView, f as repairRequestHeaders, g as scanRows, h as rowToMeta, i as needsShapeAdoption, l as repairAssistantSettlement, m as rowToEvent, n as OWN_EVENT_TYPES, o as orphanInboxSpliceSeqs, p as repairSurfaceOps, r as findSurfaceRepairs, s as recomputeReplaceProvenance, t as EventUsageRow, u as repairOrphanInboxSplices, v as sessionConflictRow, x as titleOfEventData, y as sessionInsertRow } from "./log-CUjKQbOR.mjs";
 import { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport } from "./import.mjs";
-import { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
-import { SessionEvent, SessionHeader } from "@deepseek-ai/dsh-session";
-//#region src/log.d.ts
-declare function rowToMeta(row: SessionRow): SessionHeader;
-declare function sessionInsertRow(storage: SessionStorageMetadata, incarnation: string): {
-  fSessionId: string;
-  fHeadEventId: string;
-  fHeadSequence: number;
-  fVersion: number;
-  fCreatedAt: number;
-  fCwd: string | null;
-  fParentSession: string | null;
-  fSeedLength: number | null;
-  fOrigin: string | null;
-  fDelegationDepth: number | null;
-  fAgentPreset: string | null;
-  fIncarnation: string;
-  fRevision: number;
-};
-declare function sessionConflictRow(storage: SessionStorageMetadata): {
-  fVersion: number;
-  fCreatedAt: number;
-  fCwd: string | null;
-  fParentSession: string | null;
-  fSeedLength: number | null;
-  fOrigin: string | null;
-  fDelegationDepth: number | null;
-  fAgentPreset: string | null;
-};
-declare function rowToEvent(row: EventRow): SessionEvent;
-declare function recomputeReplaceProvenance(events: SessionEvent[]): void;
-declare function findSurfaceRepairs(events: readonly SessionEvent[]): {
-  degradeToAppend: Set<number>;
-  addAppendMarker: Set<number>;
-  clearSurfaceOp: Set<number>;
-  clampEnd: Map<number, number>;
-};
-declare function repairSurfaceOps(events: SessionEvent[]): void;
-declare function repairAssistantSettlement(events: SessionEvent[]): void;
-declare function repairRequestHeaders(events: SessionEvent[]): void;
-declare function syncMeteringRanges(events: SessionEvent[]): void;
-declare function renameLegacyPtcEvents(events: SessionEvent[]): void;
-/**
- * 把**旧代（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` 就是结果块；
- * - 本仓库自己写过、上游已删除的事件类型（见 `LEGACY_OWN_EVENT_TYPES`）标 `ignorable: true`——v4 的
- *   校验对未知类型只接受可忽略信封。
- *
- * 只认这张白名单：**其它未知类型保持 fail loud**（那是「数据来自更新的 harness」的信号，不能吞掉）。
- */
-declare function normalizeToCurrentShape(events: SessionEvent[]): void;
-/**
- * 本仓库写过、后来连同机制一起删除的事件类型：读的时候标 `ignorable: true` 让校验跳过它们。
- * 新增历史类型时登记到这里——**不要**用「所有未知类型」代替（那会掩盖更新版本的未知事件）。
- */
-declare const LEGACY_OWN_EVENT_TYPES: ReadonlySet<string>;
-/** 行里是否还带着旧代消息形状（`session-branch/version` 这类自造事件也算）——写路径曾把回退视图的结果
- * 以当前版本号落库，所以**版本号不可信**，读之前要按内容判一次。 */
-declare function hasLegacyShape(events: readonly SessionEvent[]): boolean;
-declare function repairReadView(events: SessionEvent[]): void;
-declare function orphanInboxSpliceSeqs(events: readonly SessionEvent[]): Set<number>;
-declare function repairOrphanInboxSplices(events: SessionEvent[]): void;
-declare function scanRows(rows: readonly EventRow[], base?: number): {
-  preserved: SessionEvent[];
-  tornFrom?: number;
-};
-declare function toJsonlArtifact(meta: SessionHeader, inheritedEventCount: number, events: readonly SessionEvent[]): string;
-declare function titleOfEventData(data: string): string | undefined;
-/** 用量行的列（`t_event_usage`）。 */
-interface EventUsageRow {
-  fEventId: string;
-  fCreatedAt: number;
-  fProvider: string | null;
-  fModel: string | null;
-  fInputTokens: number;
-  fOutputTokens: number;
-  fCacheReadTokens: number;
-  fReasoningTokens: number;
-  fTotalTokens: number;
-}
-/**
- * 一条事件行的用量（只有带 `usage` 的 `assistant/message` 才有）：写路径据此记录
- * `t_event_usage`，统计因此不必逐行解析 JSON。两种 `f_data` 结构（带信封 / 老格式）都认。
- * @param event - 待写入的事件行。
- * @returns 用量行，或该事件没有用量时的 undefined。
- */
-declare function usageRowOf(event: {
-  fEventId: string;
-  fCreatedAt: number;
-  fType: string;
-  fData: string;
-}): EventUsageRow | undefined;
-//#endregion
-export { EventUsageRow, LEGACY_OWN_EVENT_TYPES, SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, hasLegacyShape, normalizeToCurrentShape, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, renameLegacyPtcEvents, repairAssistantSettlement, repairOrphanInboxSplices, repairReadView, repairRequestHeaders, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, syncMeteringRanges, titleOfEventData, toJsonlArtifact, usageRowOf };
+export { EventUsageRow, OWN_EVENT_TYPES, SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, needsShapeAdoption, normalizeToCurrentShape, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, renameLegacyPtcEvents, repairAssistantSettlement, repairOrphanInboxSplices, repairReadView, repairRequestHeaders, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sealOwnEvents, sessionConflictRow, sessionInsertRow, syncMeteringRanges, titleOfEventData, toJsonlArtifact, usageRowOf };

package/dist/artifact.mjs

@@ -1,3 +1,3 @@
-import { _ as sessionInsertRow, a as orphanInboxSpliceSeqs, b as toJsonlArtifact, c as repairAssistantSettlement, d as repairRequestHeaders, f as repairSurfaceOps, g as sessionConflictRow, h as scanRows, i as normalizeToCurrentShape, l as repairOrphanInboxSplices, m as rowToMeta, n as findSurfaceRepairs, o as recomputeReplaceProvenance, p as rowToEvent, r as hasLegacyShape, s as renameLegacyPtcEvents, t as LEGACY_OWN_EVENT_TYPES, u as repairReadView, v as syncMeteringRanges, x as usageRowOf, y as titleOfEventData } from "./log-qCNkDjh5.mjs";
+import { S as usageRowOf, _ as sessionConflictRow, a as orphanInboxSpliceSeqs, b as titleOfEventData, c as repairAssistantSettlement, d as repairRequestHeaders, f as repairSurfaceOps, g as sealOwnEvents, h as scanRows, i as normalizeToCurrentShape, l as repairOrphanInboxSplices, m as rowToMeta, n as findSurfaceRepairs, o as recomputeReplaceProvenance, p as rowToEvent, r as needsShapeAdoption, s as renameLegacyPtcEvents, t as OWN_EVENT_TYPES, u as repairReadView, v as sessionInsertRow, x as toJsonlArtifact, y as syncMeteringRanges } from "./log-BWVFYAh5.mjs";
 import { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport } from "./import.mjs";
-export { LEGACY_OWN_EVENT_TYPES, SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, hasLegacyShape, normalizeToCurrentShape, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, renameLegacyPtcEvents, repairAssistantSettlement, repairOrphanInboxSplices, repairReadView, repairRequestHeaders, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, syncMeteringRanges, titleOfEventData, toJsonlArtifact, usageRowOf };
+export { OWN_EVENT_TYPES, SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, needsShapeAdoption, normalizeToCurrentShape, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, renameLegacyPtcEvents, repairAssistantSettlement, repairOrphanInboxSplices, repairReadView, repairRequestHeaders, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sealOwnEvents, sessionConflictRow, sessionInsertRow, syncMeteringRanges, titleOfEventData, toJsonlArtifact, usageRowOf };

package/dist/{branch-BjUR6wfe.mjs → branch-D4nVzQQM.mjs}

@@ -1,4 +1,4 @@
-import { d as repairRequestHeaders, h as scanRows, i as normalizeToCurrentShape, m as rowToMeta } from "./log-qCNkDjh5.mjs";
+import { d as repairRequestHeaders, h as scanRows, i as normalizeToCurrentShape, m as rowToMeta } from "./log-BWVFYAh5.mjs";
 import { randomUUID } from "node:crypto";
 import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
 import { createSessionFormatCatalogWithChildren } from "@deepseek-ai/dsh-session-format-catalog";
@@ -217,7 +217,7 @@ var SessionBranchRdbProvider = class {
 			internals.dropReuseEventIds(childId);
 			throw error;
 		}
-		await this.persistence.rebuildEventCounts(childId);
+		await this.persistence.rebuildSessionStats(childId);
 		return childId;
 	}
 	async rewind(id, toBoundary, signal) {
@@ -290,7 +290,7 @@ var SessionBranchRdbProvider = class {
 			headSeq: keepLength - 1,
 			snapshotEvents: () => []
 		});
-		await this.persistence.rebuildEventCounts(id);
+		await this.persistence.rebuildSessionStats(id);
 		return {
 			header: rowToMeta(row),
 			revision: await internals.readStoredRevision(id)

package/dist/deletion.d.mts

@@ -1,4 +1,4 @@
-import { p as SessionPersistenceRdb } from "./backend-E0bmTXpz.mjs";
+import { tt as SessionPersistenceRdb } from "./log-CUjKQbOR.mjs";
 import { Context } from "@deepseek-ai/cordis";
 //#region src/deletion.d.ts
 declare const SESSION_DELETE_PATH = "/api/session.delete";

package/dist/deletion.mjs

@@ -1,2 +1,2 @@
-import { a as registerSessionDeletion, i as SESSION_DELETE_PATH } from "./src-B9X8BKyh.mjs";
+import { a as registerSessionDeletion, i as SESSION_DELETE_PATH } from "./src-BZ1tffd5.mjs";
 export { SESSION_DELETE_PATH, registerSessionDeletion };

package/dist/{dist-vIVO6bA-.mjs → dist-DHer1cql.mjs}

@@ -93,7 +93,7 @@ function encode(decoded) {
 	return writer.flush();
 }
 //#endregion
-//#region ../../../node_modules/.pnpm/magic-string@1.4.1/node_modules/magic-string/dist/index.mjs
+//#region ../../../node_modules/.pnpm/magic-string@1.4.2/node_modules/magic-string/dist/index.mjs
 var BitSet = class BitSet {
 	constructor(arg) {
 		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
@@ -187,7 +187,7 @@ var Chunk = class Chunk {
 		this.outro = "";
 		this.end = index;
 		if (this.edited) {
-			newChunk.edit("", false);
+			newChunk.edit("", false, true);
 			this.content = "";
 		} else this.content = originalBefore;
 		newChunk.next = this.next;
@@ -1149,7 +1149,7 @@ var MagicString = class MagicString {
 	* Content appended or prepended at positions strictly inside the range is removed with it, while
 	* content attached at `start` or `end` is preserved — use `s.overwrite(start, end, '')` to remove
 	* the range including its edge inserts.
-	* Removing the same content twice, or making removals that partially overlap, will cause an error.
+	* Repeated removals and removals with partially overlapping ranges are allowed.
 	*/
 	remove(start, end) {
 		start = start + this.offset;
@@ -1431,10 +1431,16 @@ var MagicString = class MagicString {
 	* @internal
 	*/
 	_hasRemovedContent(start, end) {
-		let chunk = this.firstChunk;
-		while (chunk) {
-			if (chunk.content === "" && chunk.start < end && chunk.end > start) return true;
-			chunk = chunk.next;
+		let chunk = this.byStart.get(start);
+		if (!chunk) {
+			chunk = this.lastSearchedChunk;
+			const searchForward = start >= chunk.end;
+			while (chunk && !chunk.contains(start)) chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
+			if (chunk) this.lastSearchedChunk = chunk;
+		}
+		while (chunk && chunk.start < end) {
+			if (chunk.content === "") return true;
+			chunk = this.byStart.get(chunk.end);
 		}
 		return false;
 	}
@@ -1498,6 +1504,7 @@ var MagicString = class MagicString {
 		const stringLength = string.length;
 		if (stringLength === 0) {
 			for (let index = 0; index <= original.length; index += 1) {
+				if (this._hasRemovedContent(index, index)) continue;
 				const _replacement = typeof replacement === "function" ? replacement("", index, original) : expandReplacement(replacement, "", index, original, [], void 0);
 				if (_replacement !== "") this.appendRight(index, _replacement);
 			}

package/dist/export.d.mts

@@ -0,0 +1,8 @@
+import { tt as SessionPersistenceRdb } from "./log-CUjKQbOR.mjs";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/export.d.ts
+declare const SESSION_EXPORT_PATH = "/api/session.export";
+/** 导出通道：直接把会话日志打成 zip 响应体，与导入通道读同一份 artifact。 */
+declare function registerSessionExport(ctx: Context, persistence: SessionPersistenceRdb): void;
+//#endregion
+export { SESSION_EXPORT_PATH, registerSessionExport };

package/dist/export.mjs

@@ -0,0 +1,76 @@
+import { strToU8, zip } from "fflate";
+//#region 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) => {
+			if (error === null) resolve(data);
+			else reject(error);
+		});
+	});
+}
+/** 导出通道：直接把会话日志打成 zip 响应体，与导入通道读同一份 artifact。 */
+function registerSessionExport(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_EXPORT_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					res.writeHead(405, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "method not allowed" }));
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				let envelope;
+				try {
+					envelope = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				if (typeof envelope.sessionId !== "string" || envelope.sessionId === "") {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "missing sessionId field" }));
+					return;
+				}
+				const sessionId = envelope.sessionId;
+				try {
+					const raw = await persistence.readRaw(sessionId);
+					if (raw === void 0) {
+						res.writeHead(404, { "content-type": "application/json" });
+						res.end(JSON.stringify({ error: `session "${sessionId}" not found` }));
+						return;
+					}
+					const zipFile = await zipBytes({ [raw.filename]: strToU8(raw.content) });
+					res.writeHead(200, {
+						"content-type": "application/zip",
+						"content-length": String(zipFile.byteLength),
+						"content-disposition": `attachment; filename="${safeFilename(sessionId)}.zip"`
+					});
+					res.end(Buffer.from(zipFile));
+				} catch (error) {
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "session export failed" }));
+				}
+			}
+		}), `session-rdb: ${SESSION_EXPORT_PATH} route`);
+	});
+}
+//#endregion
+export { SESSION_EXPORT_PATH, registerSessionExport };

package/dist/gc.d.mts

@@ -0,0 +1,8 @@
+import { tt as SessionPersistenceRdb } from "./log-CUjKQbOR.mjs";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/gc.d.ts
+declare const SESSION_GC_PATH = "/api/session.gc";
+/** GC 通道：停 agent → 回收孤儿事件行 → VACUUM，一次请求完成。 */
+declare function registerSessionGc(ctx: Context, persistence: SessionPersistenceRdb): void;
+//#endregion
+export { SESSION_GC_PATH, registerSessionGc };

package/dist/gc.mjs

@@ -0,0 +1,51 @@
+//#region 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;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_GC_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					res.writeHead(405, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "method not allowed" }));
+					return;
+				}
+				try {
+					const stoppedAgents = await stopRunningAgents(webCtx);
+					const orphanSessions = await persistence.collectOrphanSessions();
+					const orphanEvents = await persistence.collectOrphans();
+					await persistence.vacuum();
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify({
+						orphanSessions,
+						orphanEvents,
+						stoppedAgents,
+						vacuumed: true
+					}));
+				} catch (error) {
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "gc failed" }));
+				}
+			}
+		}), `session-rdb: ${SESSION_GC_PATH} route`);
+	});
+}
+//#endregion
+export { SESSION_GC_PATH, registerSessionGc };

package/dist/import.d.mts

@@ -1,4 +1,4 @@
-import { p as SessionPersistenceRdb } from "./backend-E0bmTXpz.mjs";
+import { tt as SessionPersistenceRdb } from "./log-CUjKQbOR.mjs";
 import { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
 import { Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
 import { Context } from "@deepseek-ai/cordis";

package/dist/import.mjs

@@ -1,4 +1,4 @@
-import { i as replaceLiveSessionLog, l as restoreCatalog } from "./branch-BjUR6wfe.mjs";
+import { i as replaceLiveSessionLog, l as restoreCatalog } from "./branch-D4nVzQQM.mjs";
 import { randomUUID } from "node:crypto";
 import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
 import { parseSessionFormatLogFilename } from "@deepseek-ai/dsh-session-format";

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { D as SCHEMA_VERSION, _ as locateTurnEnd, b as SessionRowsItem, d as SessionDeletionError, f as SessionDeletionErrorCode, g as SessionBranchRdbProvider, h as SessionBranchRdb, l as Config, m as SessionPersistenceRdbInternals, p as SessionPersistenceRdb, u as ProjectionCacheOptions, x as SessionRowsValue, y as SESSION_ROWS_PATH } from "./backend-E0bmTXpz.mjs";
-export { Config, ProjectionCacheOptions, SCHEMA_VERSION, SESSION_ROWS_PATH, SessionBranchRdb, SessionBranchRdbProvider, SessionDeletionError, SessionDeletionErrorCode, SessionPersistenceRdb, SessionPersistenceRdb as default, SessionPersistenceRdbInternals, type SessionRowsItem, type SessionRowsValue, locateTurnEnd };
+import { $ as SessionDeletionError, Q as ResolvedConfig, X as Config, Z as ProjectionCacheOptions, at as locateTurnEnd, ct as SessionRowsItem, et as SessionDeletionErrorCode, ht as SCHEMA_VERSION, it as SessionBranchRdbProvider, lt as SessionRowsValue, nt as SessionPersistenceRdbInternals, rt as SessionBranchRdb, st as SESSION_ROWS_PATH, tt as SessionPersistenceRdb } from "./log-CUjKQbOR.mjs";
+export { Config, ProjectionCacheOptions, ResolvedConfig, SCHEMA_VERSION, SESSION_ROWS_PATH, SessionBranchRdb, SessionBranchRdbProvider, SessionDeletionError, SessionDeletionErrorCode, SessionPersistenceRdb, SessionPersistenceRdb as default, SessionPersistenceRdbInternals, type SessionRowsItem, type SessionRowsValue, locateTurnEnd };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { p as SCHEMA_VERSION } from "./sqlite-zcXVyMxr.mjs";
-import { n as SessionPersistenceRdb, r as SESSION_ROWS_PATH, t as SessionDeletionError } from "./src-B9X8BKyh.mjs";
-import { n as SessionBranchRdbProvider, r as locateTurnEnd, t as SessionBranchRdb } from "./branch-BjUR6wfe.mjs";
+import { o as SCHEMA_VERSION } from "./sqlite-SCiSnwaz.mjs";
+import { n as SessionPersistenceRdb, r as SESSION_ROWS_PATH, t as SessionDeletionError } from "./src-BZ1tffd5.mjs";
+import { n as SessionBranchRdbProvider, r as locateTurnEnd, t as SessionBranchRdb } from "./branch-D4nVzQQM.mjs";
 export { SCHEMA_VERSION, SESSION_ROWS_PATH, SessionBranchRdb, SessionBranchRdbProvider, SessionDeletionError, SessionPersistenceRdb, SessionPersistenceRdb as default, locateTurnEnd };

package/dist/{log-qCNkDjh5.mjs → log-BWVFYAh5.mjs}

@@ -1,3 +1,4 @@
+import { localDayKey } from "./usage.mjs";
 import { SessionSeq } from "@deepseek-ai/dsh-session";
 import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
 //#region src/log.ts
@@ -354,15 +355,15 @@ function renameLegacyPtcEvents(events) {
 *   （v4 起 system 消息只认这个 kind）；
 * - `tool/result` 的消息：v3 是 user 角色、结果块包在 `content[0]`；v4 是 `role: 'tool'` + 顶层
 *   `toolCallId` + `content` 就是结果块；
-* - 本仓库自己写过、上游已删除的事件类型（见 `LEGACY_OWN_EVENT_TYPES`）标 `ignorable: true`——v4 的
-*   校验对未知类型只接受可忽略信封。
+* - **本仓库自造、上游不认识的事件类型**（见 `OWN_EVENT_TYPES`：历史遗留的与我们当前在写的）标
+*   `ignorable: true`——v4 的校验对未知类型只接受可忽略信封。
 *
 * 只认这张白名单：**其它未知类型保持 fail loud**（那是「数据来自更新的 harness」的信号，不能吞掉）。
 */
 function normalizeToCurrentShape(events) {
 	for (const event of events) {
 		const type = event.type;
-		if (LEGACY_OWN_EVENT_TYPES.has(type)) {
+		if (OWN_EVENT_TYPES.has(type)) {
 			event.ignorable = true;
 			continue;
 		}
@@ -405,16 +406,36 @@ function liftToolResultMessage(message) {
 	};
 }
 /**
-* 本仓库写过、后来连同机制一起删除的事件类型：读的时候标 `ignorable: true` 让校验跳过它们。
-* 新增历史类型时登记到这里——**不要**用「所有未知类型」代替（那会掩盖更新版本的未知事件）。
+* 落库前给**本仓库自造的事件类型**补上 `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 LEGACY_OWN_EVENT_TYPES = /* @__PURE__ */ new Set(["session-branch/version"]);
-/** 行里是否还带着旧代消息形状（`session-branch/version` 这类自造事件也算）——写路径曾把回退视图的结果
-* 以当前版本号落库，所以**版本号不可信**，读之前要按内容判一次。 */
-function hasLegacyShape(events) {
+const OWN_EVENT_TYPES = /* @__PURE__ */ new Set(["session-branch/version", "session-mode/selected"]);
+/** 这批事件是否需要按当前形状归一（旧代消息形状，或尚未标 `ignorable` 的自造事件类型）——写路径曾把回退
+* 视图的结果以当前版本号落库，所以**版本号不可信**，读之前要按内容判一次。 */
+function needsShapeAdoption(events) {
 	for (const event of events) {
 		const type = event.type;
-		if (LEGACY_OWN_EVENT_TYPES.has(type)) return true;
+		if (OWN_EVENT_TYPES.has(type)) return true;
 		if (type === "system/message") {
 			if ((event.data["message"]?.["source"])?.["kind"] === "plugin") return true;
 			continue;
@@ -555,10 +576,13 @@ function textField(value) {
 /**
 * 一条事件行的用量（只有带 `usage` 的 `assistant/message` 才有）：写路径据此记录
 * `t_event_usage`，统计因此不必逐行解析 JSON。两种 `f_data` 结构（带信封 / 老格式）都认。
+* 读侧维度一起物化：本地日由事件时间算，`f_referenced` 直接 1（这一批事件行与桥接行同事务，
+* 提交即被引用），`f_subagent` 取写入它的会话是否子代理。
 * @param event - 待写入的事件行。
+* @param subagent - 写入它的会话是否 `origin === 'subagent'`。
 * @returns 用量行，或该事件没有用量时的 undefined。
 */
-function usageRowOf(event) {
+function usageRowOf(event, subagent) {
 	if (event.fType !== "assistant/message") return void 0;
 	let parsed;
 	try {
@@ -573,8 +597,11 @@ function usageRowOf(event) {
 	return {
 		fEventId: event.fEventId,
 		fCreatedAt: event.fCreatedAt,
+		fDay: localDayKey(event.fCreatedAt),
 		fProvider: textField(source?.["provider"]),
 		fModel: textField(source?.["model"]),
+		fReferenced: 1,
+		fSubagent: subagent ? 1 : 0,
 		fInputTokens: numericField(usage["inputTokens"]),
 		fOutputTokens: numericField(usage["outputTokens"]),
 		fCacheReadTokens: numericField(usage["cacheReadTokens"]),
@@ -583,4 +610,4 @@ function usageRowOf(event) {
 	};
 }
 //#endregion
-export { sessionInsertRow as _, orphanInboxSpliceSeqs as a, toJsonlArtifact as b, repairAssistantSettlement as c, repairRequestHeaders as d, repairSurfaceOps as f, sessionConflictRow as g, scanRows as h, normalizeToCurrentShape as i, repairOrphanInboxSplices as l, rowToMeta as m, findSurfaceRepairs as n, recomputeReplaceProvenance as o, rowToEvent as p, hasLegacyShape as r, renameLegacyPtcEvents as s, LEGACY_OWN_EVENT_TYPES as t, repairReadView as u, syncMeteringRanges as v, usageRowOf as x, titleOfEventData as y };
+export { usageRowOf as S, sessionConflictRow as _, orphanInboxSpliceSeqs as a, titleOfEventData as b, repairAssistantSettlement as c, repairRequestHeaders as d, repairSurfaceOps as f, sealOwnEvents as g, scanRows as h, normalizeToCurrentShape as i, repairOrphanInboxSplices as l, rowToMeta as m, findSurfaceRepairs as n, recomputeReplaceProvenance as o, rowToEvent as p, needsShapeAdoption as r, renameLegacyPtcEvents as s, OWN_EVENT_TYPES as t, repairReadView as u, sessionInsertRow as v, toJsonlArtifact as x, syncMeteringRanges as y };