@morlay/session-rdb 0.1.8 → 0.1.10-alpha.0

package/src/branch.ts

@@ -153,7 +153,19 @@ function resetSurfaceManager(surfaceManager: SurfaceManagerLike): void {
   surfaceManager._pendingPlan = undefined;
 }
 
-export function truncateLiveSession(session: Session, newLength: number): void {
+/**
+ * 会话**当前内存 log** 的快照（复制一份）。用于"需要完整序列"的操作（首次落库的 seed、rewind / fork 的历史），
+ * 不走已弃用的同步历史读 `snapshotEvents()`——那三个读口上游已声明「新调用禁止」，而这里要的是当前内存里
+ * 那份完整日志，不是按需分页的历史。
+ * @param session - 会话。
+ * @returns 事件副本（调用方可以自由遍历）。
+ */
+export function liveEventsOf(session: Session): readonly SessionEvent[] {
+  return [...(session as unknown as { log: readonly SessionEvent[] }).log];
+}
+
+/** @returns 截断后日志里最后一个 `turn/start` 的 turn 号（没有则 0）。 */
+export function truncateLiveSession(session: Session, newLength: number): number {
   const s = session as unknown as {
     log: SessionEvent[];
     eventsSnapshot?: unknown;
@@ -166,6 +178,9 @@ export function truncateLiveSession(session: Session, newLength: number): void {
     derivedGeneration: number;
     surfaceManager: SurfaceManagerLike;
   };
+  // 截断后 agent 的 turn 游标要跟着落在保留前缀的最后一个 turn 上：这里直接读**要保留的那段**（同一个数组，
+  // 不经过已弃用的同步历史读 `snapshotEvents`，也不依赖 agent 侧的投影）。
+  const lastTurn = s.log.slice(0, newLength).findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
   s.log.length = newLength;
   s.eventsSnapshot = undefined;
   s.headerFold = undefined;
@@ -176,6 +191,7 @@ export function truncateLiveSession(session: Session, newLength: number): void {
   s.derivedNodes = 0;
   s.derivedGeneration = 0;
   resetSurfaceManager(s.surfaceManager);
+  return lastTurn;
 }
 
 export function replaceLiveSessionLog(session: Session, events: readonly SessionEvent[]): void {
@@ -407,7 +423,7 @@ export class SessionBranchRdbProvider implements SessionBranchProvider {
     internals.writeGuard.confirmHead(id, denseBoundary);
 
     if (live !== undefined) {
-      truncateLiveSession(live, keepLength);
+      const lastTurn = truncateLiveSession(live, keepLength);
 
       this.live.resetProjections?.(live);
 
@@ -416,8 +432,6 @@ export class SessionBranchRdbProvider implements SessionBranchProvider {
       if (agent !== undefined) {
         agent.requestHeaderLogged = false;
 
-        const lastTurn =
-          live.snapshotEvents().findLast((e) => e.type === "turn/start")?.data.turn ?? 0;
         const phase = (agent as unknown as { phase?: { lastTurn?: number } }).phase;
         if (phase !== undefined) phase.lastTurn = lastTurn;
       }

package/src/index.ts

@@ -57,7 +57,7 @@ import {
 } from "./schema.ts";
 import { SqliteBackend } from "./sqlite.ts";
 import { PostgresBackend } from "./postgres.ts";
-import { SessionBranchRdb } from "./branch.ts";
+import { SessionBranchRdb, liveEventsOf } from "./branch.ts";
 import { balanceRewindPrefix } from "@morlay/session-branch";
 import { registerSessionImport } from "./import.ts";
 import { registerSessionDeletion } from "./deletion.ts";
@@ -93,7 +93,7 @@ const DEFAULT_PROJECTION_WRITE_INTERVAL_MS = 5000;
 export { SCHEMA_VERSION } from "./schema.ts";
 export { SESSION_ROWS_PATH } from "./rows.ts";
 export type { SessionRowsItem, SessionRowsValue } from "./rows.ts";
-export { SessionBranchRdb, SessionBranchRdbProvider, locateTurnEnd } from "./branch.ts";
+export { SessionBranchRdb, SessionBranchRdbProvider, liveEventsOf, locateTurnEnd } from "./branch.ts";
 
 export interface SessionPersistenceRdbInternals {
   readonly backend: Backend;
@@ -134,12 +134,14 @@ export type Config =
       journalMode?: JournalMode | undefined;
       busyTimeout?: number | undefined;
       projectionCache?: ProjectionCacheOptions | undefined;
+      preparedSessionCacheSize?: number | undefined;
     }
   | {
       type: "postgres";
       connectionString: string;
       schema?: string | undefined;
       projectionCache?: ProjectionCacheOptions | undefined;
+      preparedSessionCacheSize?: number | undefined;
     };
 
 // schema 解析之后的形状：整段 Config 是 **volatile 稳定引用**（页面可编辑），读它要过 `.get()`。
@@ -493,6 +495,22 @@ class RdbSessionHandle implements SessionHandle {
 const localized = (text: { zh: string; en: string }): string => text as unknown as string;
 
 // 投影 checkpoint 的写回节流：两个分支共用。
+// 上游 session-query 的**冷会话观察缓存**容量（`preparedSessionCacheSize`）：缓存按**条目数**持有完整
+// `Session`（含整份 append-only log），被活跃观察租约钉住的条目不淘汰；一次读取中途转成 live 时会重试 live
+// 路径，但**不会顺手清掉已缓存的 cold 条目**——所以同一个 id 可能同时有两份 log 驻留。上游默认 5；本部署把它
+// 收到最小的 1：本地单用户、rdb 后端，冷读复用的收益不值这份内存放大。上游校验是 >= 1（不能设 0）。
+const preparedSessionCacheSchema = z
+  .number()
+  .step(1)
+  .min(1)
+  .default(1)
+  .description(
+    localized({
+      zh: "冷会话观察缓存容量（条数，最小 1）：每个条目持一份完整会话日志；本部署默认 1，把同 id 两份日志的驻留压到最小。",
+      en: "Cold prepared-Session observation cache size (entries, minimum 1): each entry holds one complete session log. This deployment defaults to 1, minimizing duplicate per-id residency.",
+    }),
+  );
+
 const projectionCacheSchema = z
   .object({
     writeEveryEvents: z
@@ -560,6 +578,7 @@ export class SessionPersistenceRdb extends SessionPersistence {
             }),
           ),
         projectionCache: projectionCacheSchema,
+        preparedSessionCacheSize: preparedSessionCacheSchema,
       }),
       z.object({
         type: z.const("postgres"),
@@ -582,6 +601,7 @@ export class SessionPersistenceRdb extends SessionPersistence {
             }),
           ),
         projectionCache: projectionCacheSchema,
+        preparedSessionCacheSize: preparedSessionCacheSchema,
       }),
     ])
     .description(
@@ -628,7 +648,12 @@ export class SessionPersistenceRdb extends SessionPersistence {
 
     new SessionBranchRdb(this.ctx);
 
-    this.ctx.plugin(SessionQueryRdb, {});
+    // 冷会话观察缓存的容量在这一行配置里（默认见 `preparedSessionCacheSchema`）；session-query 自己不会再读它。
+    const queryConfig =
+      this.config.preparedSessionCacheSize === undefined
+        ? {}
+        : { preparedSessionCacheSize: this.config.preparedSessionCacheSize };
+    this.ctx.plugin(SessionQueryRdb, queryConfig);
 
     registerSessionImport(this.ctx, this);
 
@@ -875,6 +900,17 @@ export class SessionPersistenceRdb extends SessionPersistence {
     await this.backend.vacuum();
   }
 
+  /**
+   * 已归档的会话 id（`t_sessions.f_archived_at` 非空）。`session/list` 默认过滤掉它们。
+   * 读的是持久化里的归档标记，不依赖 `workspaceRegistry` 服务的就绪时机。
+   * @returns 归档过的 Session id 集。
+   */
+  async archivedSessionIds(): Promise<ReadonlySet<string>> {
+    await this.ready;
+    const state = await this.backend.storage.readWorkspaceState();
+    return new Set((state?.archivedSessionIds ?? []).map(String));
+  }
+
   private async unarchiveBeforeDeletion(id: SessionId): Promise<void> {
     const registry = this.ctx.get("workspaceRegistry") as unknown as
       | {
@@ -1440,7 +1476,7 @@ export class SessionPersistenceRdb extends SessionPersistence {
       handle = (await this.create(session.header, {
         inheritedEventCount: session.inheritedEventCount,
       })) as RdbSessionHandle;
-      const seed = session.snapshotEvents();
+      const seed = liveEventsOf(session);
       if (seed.length > 0) await handle.append(seed);
     } else {
       if (stored.meta.cwd !== session.header.cwd) {
@@ -1456,7 +1492,7 @@ export class SessionPersistenceRdb extends SessionPersistence {
       assertVersion(stored.meta);
 
       repairReadView(stored.events);
-      const seed = session.snapshotEvents();
+      const seed = liveEventsOf(session);
       if (!seedCoversPrefix(seed, stored.events)) {
         throw new Error(
           `session "${id}" already has a persisted log on disk that does not match this live session (id collision)`,

package/src/log.ts

@@ -108,12 +108,12 @@ export function rowToEvent(row: EventRow): SessionEvent {
     typeof (record as Record<string, unknown>)["time"] === "number" &&
     "data" in (record as Record<string, unknown>);
   if (full) {
-    return {
-      ...(record as SessionEvent),
-      seq: row.fSequence,
-      time: row.fCreatedAt,
-      ...(surfaceOp === undefined ? {} : { surfaceOp }),
-    } as SessionEvent;
+    // 直接改写出参而不是 `{...record}`：冷读一页就是几万次，spread 在这里是纯开销。
+    const event = record as SessionEvent & { seq: number; time: number; surfaceOp?: unknown };
+    event.seq = row.fSequence as SessionEvent["seq"];
+    event.time = row.fCreatedAt as SessionEvent["time"];
+    if (surfaceOp !== undefined) event.surfaceOp = surfaceOp;
+    return event as SessionEvent;
   }
   return {
     type: row.fType as SessionEvent["type"],
@@ -648,44 +648,40 @@ export function scanRows(
   rows: readonly EventRow[],
   base = 0,
 ): { preserved: SessionEvent[]; tornFrom?: number } {
-  interface Parsed {
-    ok: boolean;
-    event?: SessionEvent;
-  }
-  const parsed: Parsed[] = rows.map((row) => {
-    try {
-      return { ok: true, event: rowToEvent(row) };
-    } catch {
-      return { ok: false };
-    }
-  });
-
+  // 已提交区（最后一个 `turn/end` 及之前）必须完整：坏行/断号只有在它之后才允许当作撕裂尾部丢掉。
+  // 倒序只为找到这个边界，先按行类型筛（绝大多数行直接跳过），再解析候选行确认它本身可读。
   let lastTurnEnd = -1;
-  for (let i = parsed.length - 1; i >= 0; i--) {
-    if (parsed[i]?.ok && rows[i]?.fType === "turn/end") {
+  for (let i = rows.length - 1; i >= 0; i--) {
+    if (rows[i]?.fType !== "turn/end") continue;
+    try {
+      rowToEvent(rows[i] as EventRow);
       lastTurnEnd = i;
       break;
+    } catch {
+      /* 这个 turn/end 自身坏掉：继续往前找上一个可读的边界。 */
     }
   }
 
   const preserved: SessionEvent[] = [];
   for (let i = 0; i < rows.length; i++) {
-    const p = parsed[i];
-    if (!p?.ok || p.event === undefined) {
+    let event: SessionEvent;
+    try {
+      event = rowToEvent(rows[i] as EventRow);
+    } catch {
       if (i <= lastTurnEnd)
         throw new Error(
           `corrupt session log: unparsable committed event at seq ${rows[i]?.fSequence}`,
         );
       break;
     }
-    if (p.event.seq !== base + i) {
+    if (event.seq !== base + i) {
       if (i <= lastTurnEnd)
         throw new Error(
-          `corrupt session log: seq gap in committed region (expected ${base + i}, got ${p.event.seq})`,
+          `corrupt session log: seq gap in committed region (expected ${base + i}, got ${event.seq})`,
         );
       break;
     }
-    preserved.push(p.event);
+    preserved.push(event);
   }
 
   return preserved.length < rows.length

package/src/session-query.ts

@@ -7,25 +7,38 @@ import {
 } from "@deepseek-ai/dsh-session-query";
 
 export class SessionQueryRdb extends SessionQueryEngine {
+  /**
+   * 本次装配用的冷会话观察缓存容量（由 `session-rdb` 行的 `preparedSessionCacheSize` 透传；undefined 表示沿用
+   * 上游默认）。它是**按条目数**持有完整 Session 的缓存：条目多一条就多一份完整 append-only log 驻留。
+   */
+  readonly preparedSessionCacheSize: number | undefined;
+
   constructor(ctx: Context, config: Config = {}) {
     super(ctx, config);
+    this.preparedSessionCacheSize = config.preparedSessionCacheSize;
   }
 
   // 官方列表（`session/list`）**默认不含已归档**：归档是「收起来」的会话，上游 client 用 workspace registry
   // 的归档集做「只看归档」的派生；完整语料走管理面路由 `SESSION_ROWS_PATH`。
   override async listSessions(signal?: AbortSignal): Promise<SessionRecord[]> {
     const records = await super.listSessions(signal);
-    const archived = this.archivedSessionIds();
+    const archived = await this.archivedSessionIds();
     if (archived.size === 0) return records;
     return records.filter((record) => !archived.has(String(record.header.id)));
   }
 
-  // 归档集合来自 workspace registry；服务未就绪时保守返回空集（宁可多给，不可漏掉可见会话）。
-  private archivedSessionIds(): ReadonlySet<string> {
+  // 归档集合：优先读 workspace registry（它和页面上的归档动作同源）；registry 不在（headless / 启动早期 /
+  // 测试装配）就退回持久化里的 `f_archived_at`——`session/list` 默认**不含**已归档是这一层的语义，不能因为
+  // 一个可选服务没到就把归档会话又列出来。
+  private async archivedSessionIds(): Promise<ReadonlySet<string>> {
     const registry = this.ctx.get("workspaceRegistry" as never) as unknown as
       | { archivedSessionIds?: readonly string[] }
       | undefined;
-    return new Set<string>(registry?.archivedSessionIds ?? []);
+    if (registry !== undefined) return new Set<string>(registry.archivedSessionIds ?? []);
+    const persistence = this.ctx.get("sessionPersistence") as unknown as
+      | { archivedSessionIds?: () => Promise<ReadonlySet<string>> }
+      | undefined;
+    return (await persistence?.archivedSessionIds?.()) ?? new Set<string>();
   }
 
   override async searchSessions(): Promise<never> {

package/src/sqlite.ts

@@ -3,7 +3,7 @@ import { mkdir, open, readdir, stat } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DatabaseSync } from "node:sqlite";
-import { and, desc, eq, gte, inArray, lt, notInArray, sql } from "drizzle-orm";
+import { and, desc, eq, inArray, lt, notInArray, sql } from "drizzle-orm";
 import { drizzle, type NodeSQLiteDatabase } from "drizzle-orm/node-sqlite";
 import { migrate } from "drizzle-orm/node-sqlite/migrator";
 import type { SessionId } from "@deepseek-ai/dsh-session";
@@ -341,6 +341,10 @@ function configureDatabase(
   db.exec("PRAGMA foreign_keys = ON");
 
   db.exec(`PRAGMA busy_timeout = ${busyTimeout}`);
+  // 冷读一次要顺序扫整份日志（大会话 30k+ 事件、几十 MiB 的 `f_data`）：把页缓存与 mmap 窗口调大，
+  // 省掉的是 SQLite 与内核页缓存之间的往返。`:memory:` 上这两个 PRAGMA 无害。
+  db.exec("PRAGMA cache_size = -65536");
+  db.exec("PRAGMA mmap_size = 268435456");
   const dbx = drizzle({ client: db });
 
   dbx.transaction(
@@ -500,13 +504,19 @@ export class SqliteBackend implements Backend {
   }
 
   async getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]> {
-    const scoped =
-      fromSequence === undefined
-        ? this.eventRows().where(eq(tSessionEvents.fSessionId, id))
-        : this.eventRows().where(
-            and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence)),
-          );
-    return scoped.orderBy(tSessionEvents.fSequence).all() as unknown as EventRow[];
+    // 裸 prepared 语句而不是 drizzle 的 `.select().all()`：冷读要一次拉整份日志（大会话 30k+ 行、几十 MiB 的
+    // `f_data`），drizzle 的逐行对象映射在这条路径上是纯开销。列集合与 `eventRows()` 完全一致。
+    const sql =
+      `select se.f_event_id as fEventId, se.f_sequence as fSequence, e.f_type as fType,
+              e.f_kind as fKind, e.f_role as fRole, e.f_name as fName, e.f_action_id as fActionId,
+              e.f_created_at as fCreatedAt, e.f_data as fData, se.f_surface_op as fSurfaceOp
+         from t_session_events se join t_events e on se.f_event_id = e.f_event_id
+        where se.f_session_id = ?${fromSequence === undefined ? "" : " and se.f_sequence >= ?"}
+        order by se.f_sequence`;
+    const statement = this.db.$client.prepare(sql);
+    const rows =
+      fromSequence === undefined ? statement.all(id) : statement.all(id, fromSequence);
+    return rows as unknown as EventRow[];
   }
 
   // 只取类型：rewind 的边界 / 窗口探测不该把整个事件 JSON（f_data）拖回来。

package/src/storage-takeover/projection-cache.ts

@@ -9,9 +9,22 @@ import type {
 } from "@deepseek-ai/dsh-session";
 import type {
   ProjectionCheckpoint,
+  ProjectionKeySelection,
   ProjectionSnapshot,
   SessionProjectionMap,
 } from "@deepseek-ai/dsh-session-projection";
+
+// 上游的 keys 选择面既接受数组也接受 `ReadonlySet`（`sessionProjections.summaryKeys()` 给的是 Set）。
+// 只看一个键时两种都要认——之前只按数组写了 `.includes`，Set 上直接抛 `keys.includes is not a function`，
+// 列表行于是整列投影都没有（会话标题显示"未命名"）。
+function selects(
+  keys: ProjectionKeySelection | undefined,
+  key: Extract<keyof SessionProjectionMap, string>,
+): boolean {
+  if (keys === undefined) return true;
+  if ("has" in keys) return keys.has(key);
+  return (keys as readonly string[]).includes(key);
+}
 import type {
   StorageRepository,
   StoredProjcacheEntry,
@@ -105,7 +118,7 @@ export class SessionProjectionCacheRdb extends Service {
   // inherited cut（那个只有写路径与 hydration 用得上）。
   cachedSnapshot(
     meta: SessionHeader,
-    keys?: readonly Extract<keyof SessionProjectionMap, string>[],
+    keys?: ProjectionKeySelection,
   ): ProjectionSnapshot | undefined {
     const record = this.recordForLifecycle(meta);
     const snapshot = record === undefined ? undefined : this.viewRecord(record, keys);
@@ -121,12 +134,10 @@ export class SessionProjectionCacheRdb extends Service {
 
   private withDirectTitle(
     id: SessionId,
-    keys: readonly Extract<keyof SessionProjectionMap, string>[] | undefined,
+    keys: ProjectionKeySelection | undefined,
     snapshot: ProjectionSnapshot | undefined,
   ): ProjectionSnapshot | undefined {
-    if (keys !== undefined && !(keys as readonly string[]).includes(PREDECESSOR_TITLE_KEY)) {
-      return snapshot;
-    }
+    if (!selects(keys, PREDECESSOR_TITLE_KEY)) return snapshot;
     if (snapshot?.values[PREDECESSOR_TITLE_KEY] !== undefined) return snapshot;
     const direct = this.repository.readSessionTitleDirect?.(id);
     if (direct === undefined) return snapshot;
@@ -150,7 +161,7 @@ export class SessionProjectionCacheRdb extends Service {
 
   private viewRecord(
     record: StoredProjcacheEntry,
-    keys?: readonly Extract<keyof SessionProjectionMap, string>[],
+    keys?: ProjectionKeySelection,
   ): ProjectionSnapshot | undefined {
     const values = this.ctx.sessionProjections.viewCheckpoint(
       record.rows as unknown as ProjectionCheckpoint,

package/src/storage-takeover/repository.ts

@@ -232,6 +232,17 @@ export function createStorageRepository(host: StorageRepositoryHost): StorageRep
       });
     },
 
+    async deleteWorkspaces(ids: readonly string[]): Promise<void> {
+      if (ids.length === 0) return;
+      await host.writeAtomically(async () => {
+        const db = await dbx();
+        await runQuery(
+          db.delete(tWorkspaceSessions).where(inArray(tWorkspaceSessions.fWorkspaceId, [...ids])),
+        );
+        await runQuery(db.delete(tWorkspaces).where(inArray(tWorkspaces.fWorkspaceId, [...ids])));
+      });
+    },
+
     async readWorkspaceState(): Promise<WorkspaceDomainState | null> {
       const db = await dbx();
       const row = await oneRow<{
@@ -399,6 +410,14 @@ export function createStorageRepository(host: StorageRepositoryHost): StorageRep
       });
     },
 
+    async deleteScheduleTasks(ids: readonly string[]): Promise<void> {
+      if (ids.length === 0) return;
+      await host.writeAtomically(async () => {
+        const db = await dbx();
+        await runQuery(db.delete(tScheduleTasks).where(inArray(tScheduleTasks.fId, [...ids])));
+      });
+    },
+
     async loadProjcache(): Promise<StoredProjcacheEntry[]> {
       const db = await dbx();
       const rows = await allRows<ProjcacheRowRecord>(db.select().from(tProjcacheRows));

package/src/storage-takeover/storage-backend.ts

@@ -177,6 +177,13 @@ class WorkspaceKvUnit extends TrackedKvUnit {
     await this.track(this.repository.deleteWorkspace(key));
   }
 
+  // 上游 `KvUnit.deleteRecords`：行存储一次批量做完（不让调用方逐条重试）。
+  async deleteRecords(table: string, keys: readonly string[]): Promise<void> {
+    this.assertOpen();
+    this.assertTable(table);
+    await this.track(this.repository.deleteWorkspaces([...new Set(keys)]));
+  }
+
   async setGlobal(value: unknown): Promise<void> {
     this.assertOpen();
     await this.track(this.repository.writeWorkspaceState(workspaceStateOf(value)));
@@ -208,6 +215,12 @@ class ScheduleKvUnit extends TrackedKvUnit {
     await this.track(this.repository.deleteScheduleTask(key));
   }
 
+  async deleteRecords(table: string, keys: readonly string[]): Promise<void> {
+    this.assertOpen();
+    this.assertTable(table);
+    await this.track(this.repository.deleteScheduleTasks([...new Set(keys)]));
+  }
+
   setGlobal(_value: unknown): Promise<void> {
     throw new Error(`unit '${this.descriptor.name}' declares no global slot`);
   }

package/src/storage-takeover/types.ts

@@ -33,6 +33,9 @@ export interface StorageRepository {
 
   deleteWorkspace(id: string): Promise<void>;
 
+  // 一次批量（上游 `KvUnit.deleteRecords` 的契约：行存储要么一次做完、要么不做）。
+  deleteWorkspaces(ids: readonly string[]): Promise<void>;
+
   readWorkspaceState(): Promise<WorkspaceDomainState | null>;
 
   writeWorkspaceState(state: WorkspaceDomainState): Promise<void>;
@@ -44,6 +47,8 @@ export interface StorageRepository {
 
   deleteScheduleTask(id: string): Promise<void>;
 
+  deleteScheduleTasks(ids: readonly string[]): Promise<void>;
+
   loadProjcache(): Promise<StoredProjcacheEntry[]>;
 
   // 不经 await、直接读的路径（供同步的 `cachedSnapshot` 消费）；宿主提供不了则缺省。