@morlay/ui-conversation-message-actions 0.0.14 → 0.0.15

package/dist/testing.mjs

@@ -19191,6 +19191,21 @@ function toJsonlArtifact(meta, inheritedEventCount, events) {
 	for (const event of events) lines.push(JSON.stringify(sessionFormatCatalog.encodeCurrentEvent(event)));
 	return lines.join("\n");
 }
+/**
+* 事件行 JSON → `session/title` 的标题文本。存储层写路径保证 `f_data` 是完整
+* 事件 JSON；形状不符（或损坏）按「无标题」处理——标题是派生显示数据。
+* @param data - `t_events.f_data` 原文。
+* @returns 标题文本，或 `undefined`。
+*/
+function titleOfEventData(data) {
+	try {
+		const value = JSON.parse(data);
+		const title = value.data?.title ?? value.title;
+		return typeof title === "string" ? title : void 0;
+	} catch {
+		return;
+	}
+}
 //#endregion
 //#region ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.5-ab785fc_@opentelemetry+api@1.9.1_@types+pg@8.23.1_pg@8.23.0_typebox@1.3.7_zod@4.6.1/node_modules/drizzle-orm/column-builder.js
 var ColumnBuilder = class {
@@ -22867,7 +22882,13 @@ const sessions = {
 		f_revision: {
 			type: "integer",
 			notNull: true
-		}
+		},
+		/** 归档标记：非空即该会话已归档（毫秒时间戳），NULL 表示未归档。 */
+		f_archived_at: { type: "bigint" },
+		/** 最新会话标题（最后一条 `session/title` 事件的 title），NULL 表示尚无标题。 */
+		f_title: { type: "text" },
+		/** `f_title` 来源事件的稠密 seq（列表 hint 的水位）。 */
+		f_title_seq: { type: "integer" }
 	}
 };
 //#endregion
@@ -22973,20 +22994,193 @@ const sessionEvents$1 = {
 	indexes: { idx_session_events_event_id: { columns: ["f_event_id"] } }
 };
 //#endregion
+//#region ../session-rdb/src/entities/v3/storage-units.ts
+/** storage 域版本账本：域首次打开时写入 descriptor version，其后按 accepted 集合校验。 */
+const storageUnits = {
+	name: "t_storage_units",
+	columns: {
+		f_name: {
+			type: "text",
+			primaryKey: true
+		},
+		f_version: {
+			type: "integer",
+			notNull: true
+		}
+	}
+};
+//#endregion
+//#region ../session-rdb/src/entities/v3/workspaces.ts
+/**
+* workspace 域记录表（上游 `workspace` 域 v2 的 `workspaces` 表）：
+* 记录本身拆成语义列；会话归属在 {@link workspaceSessions}（带顺序），
+* 显示顺序由 `f_position` 承载（未进入 `workspaceIds` 的记录为 -1）。
+*/
+const workspaces = {
+	name: "t_workspaces",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_workspace_id: {
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		f_path: {
+			type: "text",
+			notNull: true
+		},
+		f_title: {
+			type: "text",
+			notNull: true
+		},
+		f_created_at: {
+			type: "text",
+			notNull: true
+		},
+		f_updated_at: {
+			type: "text",
+			notNull: true
+		},
+		f_position: {
+			type: "integer",
+			notNull: true,
+			default: -1
+		}
+	}
+};
+//#endregion
+//#region ../session-rdb/src/entities/v3/workspace-sessions.ts
+/**
+* workspace 的会话归属（上游 `workspaceRecord.sessionIds` 的数组顺序）：
+* 一个会话一行，`f_position` 是归属显示顺序。会话 id 有独立索引，可按
+* session 反查归属 workspace。
+*/
+const workspaceSessions = {
+	name: "t_workspace_sessions",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_workspace_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_workspaces",
+				column: "f_workspace_id",
+				onDelete: "cascade"
+			}
+		},
+		f_session_id: {
+			type: "text",
+			notNull: true
+		},
+		f_position: {
+			type: "integer",
+			notNull: true
+		}
+	},
+	uniques: { uq_workspace_sessions_workspace_session: { columns: ["f_workspace_id", "f_session_id"] } },
+	indexes: { idx_workspace_sessions_session_id: { columns: ["f_session_id"] } }
+};
+//#endregion
+//#region ../session-rdb/src/entities/v3/workspace-state.ts
+/**
+* workspace 域 global 单例（上游 `workspaceDomainState`）：`initialized` 是
+* 引导标记，`pendingMutation` 拆成操作与目标两列（create / delete 的可恢复
+* 两写标记）。显示顺序（`workspaceIds`）在 `t_workspaces.f_position`，
+* 归档集在 `t_session_archives`。
+*/
+const workspaceState = {
+	name: "t_workspace_state",
+	columns: {
+		f_singleton: {
+			type: "integer",
+			primaryKey: true
+		},
+		f_initialized: {
+			type: "integer",
+			notNull: true
+		},
+		f_pending_operation: { type: "text" },
+		f_pending_workspace_id: { type: "text" }
+	},
+	checks: { ck_workspace_state_singleton: { expression: "f_singleton = 1" } }
+};
+//#endregion
+//#region ../session-rdb/src/entities/v3/session-projcache-rows.ts
+/**
+* 投影 checkpoint 行（上游 checkpoint 的 `(sessionId, key, ver, seq, val)`
+* 逐行落库）：`f_seq` 是该行的日志水位、`f_ver` 是投影单元的 stateVersion。
+* 行是折出捷径、非权威，版本不匹配时整行丢弃。
+*
+* checkpoint 的日志 identity 不另存一份：它与 `t_sessions` 的行是 1:1，直接
+* 复用该行的 `f_version` / `f_created_at` / `f_cwd` / `f_seed_length` 做校验。
+*/
+const sessionProjcacheRows = {
+	name: "t_session_projcache_row",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_session_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_sessions",
+				column: "f_session_id",
+				onDelete: "cascade"
+			}
+		},
+		f_key: {
+			type: "text",
+			notNull: true
+		},
+		f_ver: {
+			type: "integer",
+			notNull: true
+		},
+		f_seq: {
+			type: "integer",
+			notNull: true
+		},
+		f_val: {
+			type: "text",
+			notNull: true
+		}
+	},
+	uniques: { uq_session_projcache_row_session_key: { columns: ["f_session_id", "f_key"] } },
+	indexes: { idx_session_projcache_row_key: { columns: ["f_key"] } }
+};
+//#endregion
 //#region ../session-rdb/src/entities/v3/index.ts
 const sqliteTableDefs = [
 	persistenceState,
 	schemaMeta,
 	sessions,
 	events,
-	sessionEvents$1
+	sessionEvents$1,
+	storageUnits,
+	workspaces,
+	workspaceSessions,
+	workspaceState,
+	sessionProjcacheRows
 ];
 const postgresTableDefs = [
 	persistenceState,
 	schemaMeta,
 	sessions,
 	events,
-	sessionEvents$1
+	sessionEvents$1,
+	storageUnits,
+	workspaces,
+	workspaceSessions,
+	workspaceState,
+	sessionProjcacheRows
 ];
 ({ ...sessionEvents$1 }), { ...sessionEvents$1.columns };
 //#endregion
@@ -22999,6 +23193,11 @@ sqliteTables["t_schema_meta"];
 const tSessions = sqliteTables["t_sessions"];
 const tEvents = sqliteTables["t_events"];
 const tSessionEvents = sqliteTables["t_session_events"];
+const tStorageUnits = sqliteTables["t_storage_units"];
+const tWorkspaces = sqliteTables["t_workspaces"];
+const tWorkspaceSessions = sqliteTables["t_workspace_sessions"];
+const tWorkspaceState = sqliteTables["t_workspace_state"];
+const tSessionProjcacheRows = sqliteTables["t_session_projcache_row"];
 const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
 function eventKind(event) {
 	switch (event.type) {
@@ -23013,6 +23212,8 @@ function eventKind(event) {
 		case "session/end-seed": return "turn";
 		case "tool/call":
 		case "tool/result":
+		case "tool/ptc-dispatch-start":
+		case "tool/ptc-dispatch":
 		case "tool/code-dispatch-start":
 		case "tool/code-dispatch": return "tool";
 		case "request/header":
@@ -23086,6 +23287,8 @@ function eventDimensions(event) {
 			name: typeof data["name"] === "string" ? data["name"] : "",
 			actionId: typeof data["callId"] === "string" ? data["callId"] : ""
 		};
+		case "tool/ptc-dispatch-start":
+		case "tool/ptc-dispatch":
 		case "tool/code-dispatch-start":
 		case "tool/code-dispatch": return {
 			kind,
@@ -23288,6 +23491,254 @@ function migrate$1(db, config) {
 	return migrateSync(readMigrationFiles(config), db.session, config);
 }
 //#endregion
+//#region ../session-rdb/src/storage-takeover/repository.ts
+/**
+* storages 接管表的方言无关实现：SQLite 与 PostgreSQL 的 drizzle 查询构建器
+* 共享同一套调用形状（SQLite 走同步 `.all()`/`.get()`/`.run()`，PostgreSQL
+* 走 thenable），差别由本模块的执行 helper 吸收。
+*
+* workspace 域是权威数据：记录、归属、显示顺序与归档集都拆成语义表，每次写入
+* 在介质事务内完成（`host.writeAtomically`），不留部分应用的中间态。
+*/
+/** 多行查询：SQLite 同步 `.all()`，PostgreSQL await。 */
+async function allRows(query) {
+	const q = query;
+	if (typeof q.all === "function") return q.all();
+	return await query;
+}
+/** 单行查询：SQLite 同步 `.get()`，PostgreSQL await 后取首行。 */
+async function oneRow(query) {
+	const q = query;
+	if (typeof q.get === "function") return q.get();
+	return (await query)[0];
+}
+/** 写入语句：SQLite 同步 `.run()`，PostgreSQL await。 */
+async function runQuery(query) {
+	const q = query;
+	if (typeof q.run === "function") {
+		q.run();
+		return;
+	}
+	await query;
+}
+/** 一行会话元数据 → 上游 `CheckpointIdentity`。 */
+function identityOfSession(row) {
+	return {
+		formatVersion: row.fVersion,
+		createdAt: row.fCreatedAt,
+		...row.fCwd === null ? {} : { cwd: row.fCwd },
+		isSeeded: row.fSeedLength !== null,
+		...row.fSeedLength === null ? {} : { inheritedEventCount: SessionLogOffset(row.fSeedLength) }
+	};
+}
+/** 存储的整数水位 → 上游 seq cursor（-1 是空日志哨兵）。 */
+function seqCursor(seq) {
+	return seq === -1 ? -1 : SessionSeq$1(seq);
+}
+/** 两写标记的两列 → 上游 `pendingMutation`（未知操作按缺失处理）。 */
+function pendingMutationOf(row) {
+	const operation = row.fPendingOperation;
+	if (operation !== "create" && operation !== "delete") return void 0;
+	return {
+		operation,
+		workspaceId: row.fPendingWorkspaceId ?? ""
+	};
+}
+/**
+* 构建一个介质的 storages 接管访问层。
+* @param host - 介质句柄、方言表对象与事务执行器。
+* @returns 方言无关的访问层。
+*/
+function createStorageRepository(host) {
+	const tables = host.tables;
+	const tUnits = tables["t_storage_units"];
+	const tSessions = tables["t_sessions"];
+	const tWorkspaces = tables["t_workspaces"];
+	const tWorkspaceSessions = tables["t_workspace_sessions"];
+	const tWorkspaceState = tables["t_workspace_state"];
+	const tProjcacheRows = tables["t_session_projcache_row"];
+	/** checkpoint identity 的列投影：直接复用会话行，不再单存记录头。 */
+	const sessionIdentity = {
+		fSessionId: tSessions.fSessionId,
+		fVersion: tSessions.fVersion,
+		fCreatedAt: tSessions.fCreatedAt,
+		fCwd: tSessions.fCwd,
+		fSeedLength: tSessions.fSeedLength
+	};
+	const dbx = async () => await host.db();
+	return {
+		async readUnitVersion(name) {
+			return (await oneRow((await dbx()).select().from(tUnits).where(eq(tUnits.fName, name))))?.fVersion;
+		},
+		async insertUnitVersion(name, version) {
+			await runQuery((await dbx()).insert(tUnits).values({
+				fName: name,
+				fVersion: version
+			}).onConflictDoNothing());
+		},
+		async listWorkspaces() {
+			const db = await dbx();
+			const rows = await allRows(db.select().from(tWorkspaces));
+			const links = await allRows(db.select().from(tWorkspaceSessions));
+			const sessions = /* @__PURE__ */ new Map();
+			for (const link of links) {
+				const owned = sessions.get(link.fWorkspaceId) ?? [];
+				owned.push({
+					id: link.fSessionId,
+					position: link.fPosition
+				});
+				sessions.set(link.fWorkspaceId, owned);
+			}
+			return rows.map((row) => ({
+				id: row.fWorkspaceId,
+				record: {
+					path: row.fPath,
+					title: row.fTitle,
+					sessionIds: (sessions.get(row.fWorkspaceId) ?? []).sort((left, right) => left.position - right.position).map((entry) => SessionId(entry.id)),
+					createdAt: row.fCreatedAt,
+					updatedAt: row.fUpdatedAt
+				}
+			}));
+		},
+		async putWorkspace(id, record) {
+			await host.writeAtomically(async () => {
+				const db = await dbx();
+				const values = {
+					fWorkspaceId: id,
+					fPath: record.path,
+					fTitle: record.title,
+					fCreatedAt: record.createdAt,
+					fUpdatedAt: record.updatedAt
+				};
+				await runQuery(db.insert(tWorkspaces).values(values).onConflictDoUpdate({
+					target: tWorkspaces.fWorkspaceId,
+					set: values
+				}));
+				await runQuery(db.delete(tWorkspaceSessions).where(eq(tWorkspaceSessions.fWorkspaceId, id)));
+				const links = record.sessionIds.map((sessionId, position) => ({
+					fWorkspaceId: id,
+					fSessionId: sessionId,
+					fPosition: position
+				}));
+				if (links.length > 0) await runQuery(db.insert(tWorkspaceSessions).values(links));
+			});
+		},
+		async deleteWorkspace(id) {
+			await host.writeAtomically(async () => {
+				const db = await dbx();
+				await runQuery(db.delete(tWorkspaceSessions).where(eq(tWorkspaceSessions.fWorkspaceId, id)));
+				await runQuery(db.delete(tWorkspaces).where(eq(tWorkspaces.fWorkspaceId, id)));
+			});
+		},
+		async readWorkspaceState() {
+			const db = await dbx();
+			const row = await oneRow(db.select().from(tWorkspaceState).where(eq(tWorkspaceState.fSingleton, 1)));
+			if (row === void 0) return null;
+			const ordered = await allRows(db.select().from(tWorkspaces).where(gte(tWorkspaces.fPosition, 0)).orderBy(tWorkspaces.fPosition));
+			const archives = await allRows(db.select({ fSessionId: tSessions.fSessionId }).from(tSessions).where(isNotNull(tSessions.fArchivedAt)).orderBy(tSessions.fArchivedAt));
+			const pendingMutation = pendingMutationOf(row);
+			return {
+				initialized: row.fInitialized !== 0,
+				workspaceIds: ordered.map((entry) => entry.fWorkspaceId),
+				archivedSessionIds: archives.map((entry) => entry.fSessionId),
+				...pendingMutation === void 0 ? {} : { pendingMutation }
+			};
+		},
+		async writeWorkspaceState(state) {
+			await host.writeAtomically(async () => {
+				const db = await dbx();
+				const pending = state.pendingMutation;
+				const values = {
+					fSingleton: 1,
+					fInitialized: state.initialized ? 1 : 0,
+					fPendingOperation: pending === void 0 || typeof pending.operation !== "string" ? null : pending.operation,
+					fPendingWorkspaceId: pending === void 0 || typeof pending.workspaceId !== "string" ? null : pending.workspaceId
+				};
+				await runQuery(db.insert(tWorkspaceState).values(values).onConflictDoUpdate({
+					target: tWorkspaceState.fSingleton,
+					set: values
+				}));
+				await runQuery(db.update(tWorkspaces).set({ fPosition: -1 }));
+				for (const [position, workspaceId] of state.workspaceIds.entries()) await runQuery(db.update(tWorkspaces).set({ fPosition: position }).where(eq(tWorkspaces.fWorkspaceId, workspaceId)));
+				const archived = state.archivedSessionIds;
+				await runQuery(archived.length === 0 ? db.update(tSessions).set({ fArchivedAt: null }).where(isNotNull(tSessions.fArchivedAt)) : db.update(tSessions).set({ fArchivedAt: null }).where(and(isNotNull(tSessions.fArchivedAt), notInArray(tSessions.fSessionId, archived))));
+				const stamp = Date.now();
+				for (const sessionId of archived) await runQuery(db.update(tSessions).set({ fArchivedAt: sql`COALESCE(${tSessions.fArchivedAt}, ${stamp})` }).where(eq(tSessions.fSessionId, sessionId)));
+			});
+		},
+		async loadProjcache() {
+			const db = await dbx();
+			const rows = await allRows(db.select().from(tProjcacheRows));
+			if (rows.length === 0) return [];
+			const sessions = await allRows(db.select(sessionIdentity).from(tSessions));
+			const entries = /* @__PURE__ */ new Map();
+			for (const session of sessions) entries.set(session.fSessionId, {
+				sessionId: SessionId(session.fSessionId),
+				identity: identityOfSession(session),
+				rows: {}
+			});
+			for (const row of rows) {
+				const entry = entries.get(row.fSessionId);
+				if (entry === void 0) continue;
+				entry.rows[row.fKey] = {
+					ver: row.fVer,
+					seq: seqCursor(row.fSeq),
+					val: JSON.parse(row.fVal)
+				};
+			}
+			return [...entries.values()].filter((entry) => Object.keys(entry.rows).length > 0);
+		},
+		async putProjcache(sessionId, rows) {
+			await host.writeAtomically(async () => {
+				const db = await dbx();
+				await runQuery(db.delete(tProjcacheRows).where(eq(tProjcacheRows.fSessionId, sessionId)));
+				const values = Object.entries(rows).map(([key, row]) => ({
+					fSessionId: sessionId,
+					fKey: key,
+					fVer: row.ver,
+					fSeq: row.seq,
+					fVal: JSON.stringify(row.val)
+				}));
+				if (values.length > 0) await runQuery(db.insert(tProjcacheRows).values(values));
+			});
+		},
+		async deleteProjcache(sessionId) {
+			await runQuery((await dbx()).delete(tProjcacheRows).where(eq(tProjcacheRows.fSessionId, sessionId)));
+		},
+		...host.dbSync === void 0 ? {} : {
+			readProjcacheSync: (sessionId) => {
+				const db = host.dbSync();
+				const stored = db.select().from(tProjcacheRows).where(eq(tProjcacheRows.fSessionId, sessionId)).all();
+				if (stored.length === 0) return void 0;
+				const session = db.select(sessionIdentity).from(tSessions).where(eq(tSessions.fSessionId, sessionId)).get();
+				if (session === void 0) return void 0;
+				const rows = {};
+				for (const row of stored) rows[row.fKey] = {
+					ver: row.fVer,
+					seq: seqCursor(row.fSeq),
+					val: JSON.parse(row.fVal)
+				};
+				return {
+					sessionId: SessionId(sessionId),
+					identity: identityOfSession(session),
+					rows
+				};
+			},
+			readSessionTitleSync: (sessionId) => {
+				const row = host.dbSync().select({
+					fTitle: tSessions.fTitle,
+					fTitleSeq: tSessions.fTitleSeq
+				}).from(tSessions).where(eq(tSessions.fSessionId, sessionId)).get();
+				if (row === void 0 || row.fTitle === null || row.fTitleSeq === null) return void 0;
+				return {
+					title: row.fTitle,
+					seq: row.fTitleSeq
+				};
+			}
+		}
+	};
+}
+//#endregion
 //#region ../session-rdb/src/sqlite.ts
 /** drizzle-kit 生成的迁移目录（随包根 drizzle/ 发布；src/dist 形态经相对 URL 统一解析）。 */
 const sqliteMigrationsDir = fileURLToPath(new URL("../drizzle/sqlite/", import.meta.url));
@@ -23362,12 +23813,60 @@ var SqliteBackend = class SqliteBackend {
 	options;
 	kind = "sqlite";
 	storeIdentity;
+	/** storages 接管表访问层；句柄在 open() 完成后解析。 */
+	storage;
 	dbPath = "";
 	db;
+	dbReady;
+	resolveDb;
+	rejectDb;
 	constructor(options) {
 		this.options = options;
+		this.dbReady = new Promise((resolve, reject) => {
+			this.resolveDb = resolve;
+			this.rejectDb = reject;
+		});
+		this.dbReady.catch(() => {});
+		this.storage = createStorageRepository({
+			db: () => this.dbReady,
+			dbSync: () => {
+				if (this.db === void 0) throw new Error("sqlite session database is not open");
+				return this.db;
+			},
+			writeAtomically: (fn) => enqueueSqliteTx(this.dbPath, async () => {
+				const db = await this.dbReady;
+				db.$client.exec("BEGIN IMMEDIATE");
+				try {
+					const result = await fn();
+					db.$client.exec("COMMIT");
+					return result;
+				} catch (error) {
+					try {
+						db.$client.exec("ROLLBACK");
+					} catch {}
+					throw error;
+				}
+			}),
+			tables: {
+				t_sessions: tSessions,
+				t_storage_units: tStorageUnits,
+				t_workspaces: tWorkspaces,
+				t_workspace_sessions: tWorkspaceSessions,
+				t_workspace_state: tWorkspaceState,
+				t_session_projcache_row: tSessionProjcacheRows
+			}
+		});
 	}
 	async open() {
+		try {
+			await this.doOpen();
+			this.resolveDb(this.db);
+		} catch (error) {
+			this.rejectDb(error);
+			throw error;
+		}
+	}
+	async doOpen() {
 		const actual = this.options.path === ":memory:" ? this.options.path : resolve(this.options.path);
 		this.dbPath = actual;
 		if (actual !== ":memory:") {
@@ -23433,6 +23932,7 @@ var SqliteBackend = class SqliteBackend {
 		insertBridges: (rows) => this.insertBridges(rows),
 		updateHead: (id, headEventId, headSequence) => this.updateHead(id, headEventId, headSequence),
 		bumpRevision: (id) => this.bumpRevision(id),
+		refreshTitle: (id) => this.refreshTitle(id),
 		deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(id, fromSequence),
 		getPrevBridge: (id, sequence) => this.getPrevBridge(id, sequence)
 	};
@@ -23478,6 +23978,18 @@ var SqliteBackend = class SqliteBackend {
 	async bumpRevision(id) {
 		this.db.update(tSessions).set({ fRevision: sql`${tSessions.fRevision} + 1` }).where(eq(tSessions.fSessionId, id)).run();
 	}
+	/** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
+	async refreshTitle(id) {
+		const row = this.db.select({
+			fSequence: tSessionEvents.fSequence,
+			fData: tEvents.fData
+		}).from(tSessionEvents).innerJoin(tEvents, eq(tEvents.fEventId, tSessionEvents.fEventId)).where(and(eq(tSessionEvents.fSessionId, id), eq(tEvents.fType, "session/title"))).orderBy(desc(tSessionEvents.fSequence)).limit(1).get();
+		const title = row === void 0 ? void 0 : titleOfEventData(row.fData);
+		this.db.update(tSessions).set({
+			fTitle: title ?? null,
+			fTitleSeq: title === void 0 ? null : row.fSequence
+		}).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();
 	}
@@ -23517,12 +24029,46 @@ var PostgresBackend = class PostgresBackend {
 	kind = "postgres";
 	storeIdentity;
 	tables;
+	/** storages 接管表访问层；句柄在 open()（含迁移）完成后解析。 */
+	storage;
+	opened;
+	resolveOpened;
+	rejectOpened;
+	/** 事务期间的连接覆盖：storage 写方法经它加入当前事务。 */
+	txOverride;
 	constructor(db, options) {
 		this.db = db;
 		this.options = options;
 		this.tables = toPostgresSchema(postgresTableDefs, this.options.schema ?? "public");
+		this.opened = new Promise((resolve, reject) => {
+			this.resolveOpened = resolve;
+			this.rejectOpened = reject;
+		});
+		this.opened.catch(() => {});
+		this.storage = createStorageRepository({
+			db: () => this.opened.then(() => this.txOverride ?? this.db),
+			writeAtomically: (fn) => this.db.transaction(async (tx) => {
+				const previous = this.txOverride;
+				this.txOverride = tx;
+				try {
+					return await fn();
+				} finally {
+					this.txOverride = previous;
+				}
+			}),
+			tables: this.tables
+		});
 	}
 	async open() {
+		try {
+			await this.doOpen();
+			this.resolveOpened();
+		} catch (error) {
+			this.rejectOpened(error);
+			throw error;
+		}
+	}
+	async doOpen() {
 		const schema = this.options.schema ?? "public";
 		const qualifiedMeta = schema === "public" ? "t_schema_meta" : `"${schema}".t_schema_meta`;
 		if ((await this.db.execute(sql`SELECT to_regclass(${qualifiedMeta}) IS NOT NULL AS exists`)).rows[0]?.exists === true) {
@@ -23583,6 +24129,7 @@ var PostgresBackend = class PostgresBackend {
 			insertBridges: (rows) => this.insertBridges(tx, rows),
 			updateHead: (id, headEventId, headSequence) => this.updateHead(tx, id, headEventId, headSequence),
 			bumpRevision: (id) => this.bumpRevision(tx, id),
+			refreshTitle: (id) => this.refreshTitle(tx, id),
 			deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
 			getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence)
 		};
@@ -23632,6 +24179,20 @@ var PostgresBackend = class PostgresBackend {
 	async bumpRevision(exec, id) {
 		await exec.update(this.tables["t_sessions"]).set({ fRevision: sql`${this.tables["t_sessions"].fRevision} + 1` }).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
 	}
+	/** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
+	async refreshTitle(exec, id) {
+		const bridges = this.tables["t_session_events"];
+		const entities = this.tables["t_events"];
+		const row = (await exec.select({
+			fSequence: bridges.fSequence,
+			fData: entities.fData
+		}).from(bridges).innerJoin(entities, eq(entities.fEventId, bridges.fEventId)).where(and(eq(bridges.fSessionId, id), eq(entities.fType, "session/title"))).orderBy(desc(bridges.fSequence)).limit(1).execute())[0];
+		const title = row === void 0 ? void 0 : titleOfEventData(row.fData);
+		await exec.update(this.tables["t_sessions"]).set({
+			fTitle: title ?? null,
+			fTitleSeq: title === void 0 ? null : row.fSequence
+		}).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();
 	}
@@ -23824,6 +24385,7 @@ var SessionBranchRdbProvider = class {
 				await tx.updateSeedLength(id, denseBoundary + 1);
 				shrunk = denseBoundary + 1;
 			}
+			await tx.refreshTitle(id);
 			await tx.bumpRevision(id);
 			return shrunk;
 		});
@@ -24641,7 +25203,476 @@ function adoptLegacyRows(row, eventRows) {
 	};
 }
 //#endregion
+//#region ../../vendor/deepseek-harness/packages/storage/storage/lib/index.js
+/**
+* Error vocabulary for the storage hub and its backends.
+* @module @deepseek-ai/dsh-storage/src/error
+*/
+/**
+* Error thrown by the hub and by backend implementations. The `code` is the
+* stable contract consumers may switch on; `message` is diagnostic prose.
+*/
+var StorageError = class extends Error {
+	code;
+	name = "StorageError";
+	/**
+	* @param code - Stable discriminant for the failure class.
+	* @param message - Human-readable diagnostic detail.
+	* @param options - Standard error options (`cause`).
+	*/
+	constructor(code, message, options) {
+		super(message, options);
+		this.code = code;
+	}
+};
+/**
+* Storage hub (`ctx.storage`): a named backend registry plus mounted
+* data-form facilities. The hub itself performs no IO — backends own media,
+* data forms (the domain layer first) own semantics.
+* @module @deepseek-ai/dsh-storage
+*/
+/**
+* Derive the Cordis lifecycle service that one named backend plugin provides.
+* Domain-form providers inject these keys so activation cannot race backend
+* registration even though callers continue resolving backends through the
+* storage registry.
+* @param name - Backend registry name.
+* @returns the corresponding lifecycle-only service key.
+*/
+function storageBackendServiceKey(name) {
+	return `storage.backend.${name}`;
+}
+//#endregion
+//#region ../session-rdb/src/storage-takeover/projection-cache.ts
+/**
+* 投影 checkpoint 服务（`ctx.sessionProjectionCache`）的 rdb 实现：替换上游
+* `@deepseek-ai/dsh-session-projection-cache` 插件，公开面与语义逐一对齐
+* （cachedSnapshot / cachedPredecessorTitle / hydratePrepared / write /
+* coldSnapshot，以及三个强制写点与计数/定时节流），持久层换成 session-rdb
+* 的语义专用表 `t_session_projcache` / `t_session_projcache_row`。
+*
+* 读方法是同步签名（session 列表在请求路径上直接调用），所以服务持有启动时
+* 从表中加载的内存 checkpoint 表；写先落库、后更新内存，保证读到的内存值
+* 磁盘上一定存在。
+*/
+/** 服务注册名（与上游插件一致，消费者经 `ctx.get` 解析）。 */
+const SESSION_PROJECTION_CACHE_SERVICE = "sessionProjectionCache";
+/** 只认 title 的前代提示（与上游一致）。 */
+const PREDECESSOR_TITLE_KEY = "title";
+/** rdb 持久化的投影 checkpoint 服务：同步驱动直读介质，异步驱动用写穿镜像支撑同步签名。 */
+var SessionProjectionCacheRdb = class extends Service {
+	config;
+	repository;
+	ready;
+	static inject = ["sessionProjections", "sessions"];
+	/** 异步驱动（PostgreSQL）的同步读镜像：同步驱动（SQLite）直读介质，这里恒为空。 */
+	records = /* @__PURE__ */ new Map();
+	dirty = /* @__PURE__ */ new Map();
+	/** 读路径是否直读介质（`readProjcacheSync` 存在即同步驱动）。 */
+	directReads;
+	/**
+	* @param ctx - 插件上下文（须已注入 sessionProjections 与 sessions）。
+	* @param config - 写节流参数。
+	* @param repository - storages 接管表访问层。
+	* @param ready - 介质就绪信号（直读介质前必须等到）。
+	*/
+	constructor(ctx, config, repository, ready) {
+		super(ctx, SESSION_PROJECTION_CACHE_SERVICE);
+		this.config = config;
+		this.repository = repository;
+		this.ready = ready;
+		this.directReads = repository.readProjcacheSync !== void 0;
+	}
+	/**
+	* Wait for the medium, then install the write path. Only the async driver
+	* needs a startup mirror: the sync driver serves every read from the table.
+	*/
+	async [Service.init]() {
+		await this.ready;
+		if (!this.directReads) for (const entry of await this.repository.loadProjcache()) this.records.set(entry.sessionId, entry);
+		this.installWritePath();
+	}
+	/** Read one session's stored record: straight from the medium, or from the async mirror. */
+	lookup(id) {
+		if (this.directReads) return this.repository.readProjcacheSync?.(id);
+		return this.records.get(id);
+	}
+	/**
+	* The stored record for one session, accepted only when its bound log
+	* identity matches `expected`. A session id names a slot, not a lifecycle:
+	* a recreated id or a persistence store swapped under a surviving cache
+	* must not let an old record seed state folded from an unrelated log.
+	* @param id - the session whose record is read.
+	* @param expected - the log identity the caller holds (live or stored header).
+	* @returns the identity-matching record, or `undefined` (absent or unrelated).
+	*/
+	recordFor(id, expected) {
+		const record = this.lookup(id);
+		if (record === void 0) return void 0;
+		return identityMatches(record.identity, expected) ? record : void 0;
+	}
+	/**
+	* The cached projection cut for one stored (cold) or live header.
+	* @param meta - authoritative Session header.
+	* @param inheritedEventCount - exact inherited cut completing the lifecycle identity.
+	* @param keys - optional projection keys required by the caller's audience.
+	* @returns the cut (`asOfSeq` = lowest served-row watermark), or `undefined`
+	*   when no usable row exists for this lifecycle.
+	*/
+	cachedSnapshot(meta, inheritedEventCount, keys) {
+		const record = this.recordFor(meta.id, identityOf(meta, inheritedEventCount));
+		const snapshot = record === void 0 ? void 0 : this.viewRecord(record, keys);
+		return this.withDirectTitle(meta.id, keys, snapshot);
+	}
+	/**
+	* 标题是会话数据本身（`t_sessions.f_title`，由 rdb 写路径与 rewind 维护）：
+	* checkpoint 行里没有 title 时直接取该列，列表消费不依赖缓存行是否存在。
+	*/
+	withDirectTitle(id, keys, snapshot) {
+		if (keys !== void 0 && !keys.includes(PREDECESSOR_TITLE_KEY)) return snapshot;
+		if (snapshot?.values[PREDECESSOR_TITLE_KEY] !== void 0) return snapshot;
+		const direct = this.repository.readSessionTitleSync?.(id);
+		if (direct === void 0) return snapshot;
+		const values = {
+			...snapshot?.values,
+			[PREDECESSOR_TITLE_KEY]: direct.title
+		};
+		return {
+			asOfSeq: snapshot === void 0 ? direct.seq : Math.min(snapshot.asOfSeq, direct.seq),
+			values
+		};
+	}
+	/**
+	* Read only a predecessor checkpoint's title as a zero-I/O listing hint.
+	* @param meta - authoritative listed Session header.
+	* @param inheritedEventCount - exact inherited cut completing the lifecycle identity.
+	* @returns a title-only checkpoint view with `asOfSeq: -1`, or `undefined`
+	*   when the record is current, newer, unrelated, missing, or incompatible
+	*   with the title unit.
+	*/
+	cachedPredecessorTitle(meta, inheritedEventCount) {
+		const expected = identityOf(meta, inheritedEventCount);
+		const record = this.lookup(meta.id);
+		if (record === void 0 || !predecessorIdentityMatches(record.identity, expected)) return;
+		const title = this.viewRecord(record, [PREDECESSOR_TITLE_KEY]);
+		return title === void 0 ? void 0 : {
+			...title,
+			asOfSeq: -1
+		};
+	}
+	/** View selected wire rows and bind them to their lowest served watermark. */
+	viewRecord(record, keys) {
+		const values = this.ctx.sessionProjections.viewCheckpoint(record.rows, keys);
+		const servedKeys = Object.keys(values);
+		if (servedKeys.length === 0) return void 0;
+		const firstKey = servedKeys[0];
+		let asOfSeq = record.rows[firstKey].seq;
+		for (const key of servedKeys.slice(1)) {
+			const row = record.rows[key];
+			if (row.seq < asOfSeq) asOfSeq = row.seq;
+		}
+		return {
+			asOfSeq,
+			values
+		};
+	}
+	/**
+	* Hydrate projection cells for an already-prepared Session without another
+	* persistence read. The cache seeds matching rows; the supplied exact log
+	* advances every unit to the observation cut. No checkpoint is written
+	* because the logical observation may contain recovery events not yet durable.
+	* @param session - exact unpublished Session retained by persistence.
+	* @param events - exact logical event prefix represented by the observation.
+	* @returns all projection values at the event cut.
+	*/
+	hydratePrepared(session, events) {
+		const record = this.recordFor(session.id, identityOf(session.header, session.inheritedEventCount));
+		if (record === void 0) return this.ctx.sessionProjections.hydrate(session, {}, events, SessionLogOffset(0));
+		try {
+			return this.ctx.sessionProjections.hydrate(session, record.rows, events, SessionLogOffset(0));
+		} catch {
+			return this.ctx.sessionProjections.hydrate(session, {}, events, SessionLogOffset(0));
+		}
+	}
+	/**
+	* Durably checkpoint one live session NOW (all mandatory points call this).
+	* NOT fail-soft — callers on the fail-soft paths contain it.
+	* @param session - the live session to checkpoint.
+	* @returns resolution after durability.
+	*/
+	async write(session) {
+		const rows = this.ctx.sessionProjections.checkpoint(session);
+		this.markClean(session);
+		if (this.ctx.sessions.get(session.id) === session) await this.ctx.sessions.flush(session);
+		await this.put(session.id, identityOf(session.header, session.inheritedEventCount), rows);
+	}
+	/**
+	* Cold-read one session's projections from its complete log. Each unit is
+	* seeded from the identity-checked cached rows and the refreshed checkpoint
+	* is written back (fail-soft, fire-and-forget).
+	* @param meta - the stored session header (identity witness).
+	* @param inheritedEventCount - exact inherited prefix length for projection initialization and identity.
+	* @param events - the session's complete log, in seq order.
+	* @returns the projection cut at the log end.
+	*/
+	coldSnapshot(meta, inheritedEventCount, events) {
+		const identity = identityOf(meta, inheritedEventCount);
+		const restored = this.ctx.sessionProjections.restore(this.recordFor(meta.id, identity)?.rows ?? {}, events, SessionLogOffset(0), meta, inheritedEventCount);
+		this.put(meta.id, identity, restored.checkpoint).catch((error) => {
+			this.ctx.logger.warn(`session projection cache: cold-read write-back for "${meta.id}" failed (cache stays stale): ${String(error)}`);
+		});
+		return restored.snapshot;
+	}
+	installWritePath() {
+		this.ctx.on("session/event", (session, event) => {
+			if (event.type === "turn/end") {
+				this.flushSoft(session, "turn/end");
+				return;
+			}
+			const state = this.dirty.get(session) ?? {
+				pending: 0,
+				timer: void 0
+			};
+			this.dirty.set(session, state);
+			state.pending += 1;
+			if (state.pending >= this.config.writeEveryEvents) {
+				this.flushSoft(session, "count threshold");
+				return;
+			}
+			state.timer ??= setTimeout(() => {
+				this.flushSoft(session, "interval");
+			}, this.config.writeIntervalMs);
+		});
+		this.ctx.on("session/created", (session) => {
+			this.flushSoft(session, "create");
+		});
+		this.ctx.on("session/disposed", (session) => {
+			this.flushSoft(session, "detach");
+			this.markClean(session);
+			this.dirty.delete(session);
+		});
+		this.ctx.effect(() => () => {
+			for (const state of this.dirty.values()) if (state.timer !== void 0) clearTimeout(state.timer);
+			this.dirty.clear();
+		}, "sessionProjectionCacheRdb.timers");
+	}
+	/** One fail-soft durable checkpoint. */
+	async flushSoft(session, trigger) {
+		try {
+			await this.write(session);
+		} catch (error) {
+			this.ctx.logger.warn(`session projection cache: ${trigger} write for "${session.id}" failed (cache stays stale): ${String(error)}`);
+		}
+	}
+	/** Reset one session's dirty bookkeeping (its checkpoint is being written). */
+	markClean(session) {
+		const state = this.dirty.get(session);
+		if (state === void 0) return;
+		state.pending = 0;
+		if (state.timer !== void 0) {
+			clearTimeout(state.timer);
+			state.timer = void 0;
+		}
+	}
+	/** Replace one session's stored record with its log identity and a detached snapshot of `rows`. */
+	async put(id, identity, rows) {
+		const detached = detachJson(rows);
+		await this.repository.putProjcache(id, detached);
+		if (!this.directReads) this.records.set(id, {
+			sessionId: id,
+			identity,
+			rows: detached
+		});
+	}
+};
+/** Detach one checkpoint from live unit state, refusing non-lossless JSON. */
+function detachJson(rows) {
+	let text;
+	try {
+		text = JSON.stringify(rows);
+	} catch (error) {
+		throw new TypeError(`projection checkpoint is not losslessly JSON-serializable: ${String(error)}`, { cause: error });
+	}
+	if (text === void 0) throw new TypeError("projection checkpoint is not losslessly JSON-serializable");
+	return JSON.parse(text);
+}
+/** Project a header onto the identity fields a record is bound to. */
+function identityOf(header, inheritedEventCount) {
+	const cut = SessionLogOffset(inheritedEventCount);
+	if (!header.isSeeded && cut !== 0) throw new Error("unseeded projection-cache identity inherited event count must be 0");
+	return {
+		formatVersion: header.version,
+		createdAt: header.createdAt,
+		...header.cwd === void 0 ? {} : { cwd: header.cwd },
+		isSeeded: header.isSeeded,
+		inheritedEventCount: cut
+	};
+}
+/**
+* Whether a stored record's bound identity names the caller's lifecycle.
+* An absent format generation cannot prove the fold semantics and never
+* matches. Once the format matches, absent lineage fields (records admitted
+* via compatible versions predate them) read as the unseeded lineage.
+*/
+function identityMatches(stored, expected) {
+	return stored.formatVersion === expected.formatVersion && lifecycleIdentityMatches(stored, expected);
+}
+/** Match one predecessor cache record to the authoritative listed lifecycle. */
+function predecessorIdentityMatches(stored, expected) {
+	return (stored.formatVersion === void 0 || stored.formatVersion < expected.formatVersion) && lifecycleIdentityMatches(stored, expected);
+}
+/** Match the format-independent fields that distinguish one Session lifecycle. */
+function lifecycleIdentityMatches(stored, expected) {
+	return stored.createdAt === expected.createdAt && stored.cwd === expected.cwd && (stored.isSeeded ?? false) === expected.isSeeded && (stored.inheritedEventCount ?? 0) === expected.inheritedEventCount;
+}
+//#endregion
+//#region ../session-rdb/src/storage-takeover/storage-backend.ts
+/**
+* storages 接管：注册在 storage hub 上的 `rdb` KV 后端。它把 workspace 域
+* （上游 single 布局：一张 `workspaces` 表 + global 单例）映射到 session-rdb
+* 的语义专用表，与事件日志同库同连接；域层（`ctx.storageDomain`）通过
+* `routes` 把 `workspace` 域路由到本后端。
+*
+* 本后端只服务已知域的专用表：未知 unit 名 fail loud，而不是静默落到通用
+* 存储——表结构是显式维护的（见 docs/schema.md）。
+*/
+/** 本后端唯一服务的域：上游 `workspaceDomainSpec`（v2，single 布局）。 */
+const WORKSPACE_UNIT = "workspace";
+const WORKSPACE_TABLE = "workspaces";
+/** 只服务 workspace 域的 KV 后端。 */
+var RdbStorageBackend = class {
+	repository;
+	kv = { open: (descriptor) => this.openUnit(descriptor) };
+	/** 已打开（或打开中）的 unit 名；重复 open 是调用方 bug。 */
+	open = /* @__PURE__ */ new Set();
+	closed = false;
+	/**
+	* @param repository - storages 接管表访问层（与事件日志同介质）。
+	*/
+	constructor(repository) {
+		this.repository = repository;
+	}
+	async openUnit(descriptor) {
+		if (this.closed) throw new StorageError("closed", "rdb storage backend is closed");
+		if (descriptor.name !== WORKSPACE_UNIT) throw new Error(`rdb storage backend serves only the '${WORKSPACE_UNIT}' domain (requested '${descriptor.name}')`);
+		if (!descriptor.tables.includes(WORKSPACE_TABLE) || descriptor.hasGlobal !== true) throw new Error(`rdb storage backend expects the '${WORKSPACE_UNIT}' domain shape (table '${WORKSPACE_TABLE}' plus a global slot)`);
+		if (this.open.has(descriptor.name)) throw new Error(`kv unit '${descriptor.name}' is already open (double-open is a caller bug)`);
+		const stored = await this.repository.readUnitVersion(descriptor.name);
+		if (stored === void 0) await this.repository.insertUnitVersion(descriptor.name, descriptor.version);
+		else if (stored !== descriptor.version) throw new StorageError("version-mismatch", `kv unit '${descriptor.name}' is stamped version ${stored} on the medium, incompatible with descriptor version ${descriptor.version}`);
+		this.open.add(descriptor.name);
+		return new WorkspaceKvUnit(this.repository, descriptor, () => {
+			this.open.delete(descriptor.name);
+		});
+	}
+	/**
+	* Release the backend. The medium (the session database) belongs to the
+	* owning session-rdb plugin, so closing open units here does not close it.
+	* @returns resolution after the name table is cleared.
+	*/
+	async close() {
+		this.closed = true;
+		this.open.clear();
+	}
+};
+/** workspace 域的 KV unit：每个原语一条 SQL 语句，值形状与上游记录一致。 */
+var WorkspaceKvUnit = class {
+	repository;
+	descriptor;
+	onClose;
+	closed = false;
+	constructor(repository, descriptor, onClose) {
+		this.repository = repository;
+		this.descriptor = descriptor;
+		this.onClose = onClose;
+	}
+	async loadAll() {
+		this.assertOpen();
+		const records = Object.create(null);
+		for (const { id, record } of await this.repository.listWorkspaces()) records[id] = record;
+		const state = await this.repository.readWorkspaceState();
+		return {
+			tables: { [WORKSPACE_TABLE]: records },
+			global: state
+		};
+	}
+	async putRecord(table, key, value) {
+		this.assertOpen();
+		this.assertTable(table);
+		await this.repository.putWorkspace(key, workspaceRecordOf(value));
+	}
+	async deleteRecord(table, key) {
+		this.assertOpen();
+		this.assertTable(table);
+		await this.repository.deleteWorkspace(key);
+	}
+	async setGlobal(value) {
+		this.assertOpen();
+		await this.repository.writeWorkspaceState(workspaceStateOf(value));
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.onClose();
+	}
+	assertOpen() {
+		if (this.closed) throw new StorageError("closed", `kv unit '${this.descriptor.name}' is closed`);
+	}
+	assertTable(table) {
+		if (table !== WORKSPACE_TABLE) throw new Error(`unit '${this.descriptor.name}' does not declare table '${table}'`);
+	}
+};
+/** Narrow one opaque KV record to the workspace record the domain shipped. */
+function workspaceRecordOf(value) {
+	const record = value;
+	if (typeof record !== "object" || record === null || typeof record.path !== "string" || typeof record.title !== "string" || !Array.isArray(record.sessionIds) || typeof record.createdAt !== "string" || typeof record.updatedAt !== "string") throw new TypeError("workspace record does not match the stored shape");
+	return {
+		path: record.path,
+		title: record.title,
+		sessionIds: record.sessionIds.map((id) => id),
+		createdAt: record.createdAt,
+		updatedAt: record.updatedAt
+	};
+}
+/** Narrow one opaque KV global to the workspace registry state the domain shipped. */
+function workspaceStateOf(value) {
+	const state = value;
+	if (typeof state !== "object" || state === null || typeof state.initialized !== "boolean" || !Array.isArray(state.workspaceIds) || !Array.isArray(state.archivedSessionIds)) throw new TypeError("workspace registry state does not match the stored shape");
+	return {
+		initialized: state.initialized,
+		workspaceIds: state.workspaceIds.map((id) => id),
+		archivedSessionIds: state.archivedSessionIds.map((id) => id),
+		...state.pendingMutation === void 0 ? {} : { pendingMutation: state.pendingMutation }
+	};
+}
+//#endregion
+//#region ../session-rdb/src/storage-takeover/index.ts
+/**
+* Install the storages takeover on the session-rdb plugin context.
+* @param ctx - session-rdb plugin context.
+* @param options - repository and projection-cache throttle parameters.
+*/
+function installStorageTakeover(ctx, options) {
+	ctx.inject(["storage"], (storageCtx) => {
+		const backend = new RdbStorageBackend(options.repository);
+		storageCtx.effect(() => {
+			const unregister = storageCtx.storage.backend.register("rdb", backend);
+			return async () => {
+				unregister();
+				await backend.close();
+			};
+		}, "session-rdb.storageBackend");
+		storageCtx.provide(storageBackendServiceKey("rdb"), backend);
+	});
+	ctx.inject(["sessionProjections"], (projectionCtx) => {
+		new SessionProjectionCacheRdb(projectionCtx, options.projectionCache, options.repository, options.ready);
+	});
+}
+//#endregion
 //#region ../session-rdb/src/index.ts
+/** 投影缓存默认写节流（与上游 base 装配的部署值一致）。 */
+const DEFAULT_PROJECTION_WRITE_EVERY_EVENTS = 200;
+const DEFAULT_PROJECTION_WRITE_INTERVAL_MS = 5e3;
 /** 会话级写所有权与 live 路由簿记。 */
 var RdbBackendTracker = class {
 	name;
@@ -24910,11 +25941,25 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 			"truncate",
 			"persist"
 		]).default("wal"),
-		busyTimeout: Schema.number().step(1).min(0).default(DEFAULT_BUSY_TIMEOUT_MS)
+		busyTimeout: Schema.number().step(1).min(0).default(DEFAULT_BUSY_TIMEOUT_MS),
+		projectionCache: Schema.object({
+			writeEveryEvents: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS),
+			writeIntervalMs: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS)
+		}).default({
+			writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
+			writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
+		})
 	}), Schema.object({
 		type: Schema.const("postgres"),
 		connectionString: Schema.string().required(),
-		schema: Schema.string().default("public")
+		schema: Schema.string().default("public"),
+		projectionCache: Schema.object({
+			writeEveryEvents: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS),
+			writeIntervalMs: Schema.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS)
+		}).default({
+			writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
+			writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
+		})
 	})]);
 	static settingsNs = "session-rdb";
 	name = "session-rdb";
@@ -24945,6 +25990,14 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		this.installLiveRouting(ctx);
 		new SessionBranchRdb(this.ctx);
 		registerSessionImport(this.ctx, this);
+		installStorageTakeover(this.ctx, {
+			repository: this.backend.storage,
+			ready: this.ready,
+			projectionCache: {
+				writeEveryEvents: this.config.projectionCache?.writeEveryEvents ?? DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
+				writeIntervalMs: this.config.projectionCache?.writeIntervalMs ?? DEFAULT_PROJECTION_WRITE_INTERVAL_MS
+			}
+		});
 	}
 	async init() {
 		await this.backend.open();
@@ -25455,6 +26508,7 @@ async function appendEventTail(tx, meta, events, anchor, reuse) {
 	}
 	if (eventRows.length > 0) await tx.insertEvents(eventRows);
 	await tx.insertBridges(bridgeRows);
+	if (events.some((event) => event.type === "session/title")) await tx.refreshTitle(meta.id);
 	return {
 		headEventId: parentId,
 		headSequence: nextSeq - 1