@morlay/session-rdb 0.0.15 → 0.0.16-alpha.0

package/src/invariant.ts

@@ -1,4 +1,3 @@
-/* jscpd:ignore-start */
 import type { Context } from "@deepseek-ai/cordis";
 import type { InvariantInstaller } from "@deepseek-ai/dsh-invariants";
 
@@ -12,4 +11,3 @@ const install: InvariantInstaller = () => {};
 
 export const apply = (ctx: Context): Promise<() => void> =>
   Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
-/* jscpd:ignore-end */

package/src/legacy.ts

@@ -0,0 +1,67 @@
+// 旧格式（v0/v1）历史数据读取转换：RDB 行 → v0/v1 物理记录 → 上游迁移链 →
+// v2 逻辑事件。RDB 写路径从不持久化 sourceEventSeqs（读取时重计算），且
+// delta（assistant/chunk）落盘被过滤——v1→v2 迁移对无 chunk 引用的
+// assistant/message 走「无 pending 直接 emit」路径，生成 stream: [] 的 v2 事件。
+
+import type { SessionEvent, SessionHeader, SessionId } from "@deepseek-ai/dsh-session";
+import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
+import type { EventRow, SessionRow } from "./backend.ts";
+
+/** 重建 v0/v1 物理 header 记录（RDB 行 → 物理 JSON 对象）。 */
+function physicalHeader(row: SessionRow): Record<string, unknown> {
+  return {
+    type: "session",
+    version: row.fVersion,
+    id: row.fSessionId,
+    createdAt: row.fCreatedAt,
+    ...(row.fCwd !== null ? { cwd: row.fCwd } : {}),
+    ...(row.fParentSession !== null ? { parentSession: row.fParentSession } : {}),
+    ...(row.fSeedLength !== null ? { seedLength: row.fSeedLength } : {}),
+    ...(row.fOrigin !== null ? { origin: row.fOrigin } : {}),
+    delegationDepth: row.fDelegationDepth ?? 0,
+  };
+}
+
+/** 重建一条 v0/v1 物理事件记录（桥接行 + 事件行 → 物理 JSON 对象）。 */
+function physicalEvent(row: EventRow): Record<string, unknown> {
+  return {
+    type: row.fType,
+    seq: row.fSequence,
+    time: row.fCreatedAt,
+    data: JSON.parse(row.fData) as unknown,
+    ...(row.fSurfaceOp !== null ? { surfaceOp: JSON.parse(row.fSurfaceOp) as unknown } : {}),
+  };
+}
+
+/**
+ * 把旧格式（v0/v1）行转换为 v2 逻辑事件与 header。
+ * @param row - 会话行（f_version < 2）。
+ * @param eventRows - 已扫描保留的桥接行（稠密 seq，torn tail 已剔除）。
+ * @returns v2 逻辑 header、继承前缀长度与事件。
+ * @throws 迁移链拒绝（格式损坏 / 无法迁移）时原样抛出。
+ */
+export function convertLegacyRows(
+  row: SessionRow,
+  eventRows: readonly EventRow[],
+): { meta: SessionHeader; inheritedEventCount: number; events: SessionEvent[] } {
+  const restore = sessionFormatCatalog.createRestore(physicalHeader(row), {
+    recovery: "strict",
+    validation: "transformed",
+  });
+  for (const eventRow of eventRows) {
+    restore.decodeRow(physicalEvent(eventRow));
+  }
+  const artifact = restore.finish();
+  return {
+    meta: artifact.header as unknown as SessionHeader,
+    inheritedEventCount: artifact.inheritedEventCount,
+    events: artifact.events as unknown as SessionEvent[],
+  };
+}
+
+/** 会话行是否携带旧格式（v0/v1）数据。 */
+export function isLegacyVersion(version: number): boolean {
+  return version < 2;
+}
+
+export type { SessionId };

package/src/log.ts

@@ -1,5 +1,6 @@
 import type { SessionEvent, SessionHeader, SessionId, SurfaceOp } from "@deepseek-ai/dsh-session";
-import { SessionSeq, encodeSeqRanges, packChunkRuns } from "@deepseek-ai/dsh-session";
+import type { SessionFormatEvent, SessionFormatHeader } from "@deepseek-ai/dsh-session-format";
+import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
 import type { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
 import type { EventRow, SessionRow } from "./backend.ts";
 
@@ -8,7 +9,7 @@ export function rowToMeta(row: SessionRow): SessionHeader {
     throw new Error("stored session createdAt must be a non-negative safe integer");
   }
   return {
-    version: row.fVersion,
+    version: row.fVersion as SessionHeader["version"],
     id: row.fSessionId as SessionId,
     createdAt: row.fCreatedAt,
     ...(row.fCwd !== null ? { cwd: row.fCwd } : {}),
@@ -74,77 +75,38 @@ export function sessionConflictRow(storage: SessionStorageMetadata): {
   };
 }
 
-export function remapSurfaceOp(op: SurfaceOp, remap: (seq: number) => number): SurfaceOp {
-  if (op === "append") return op;
-  return {
-    op: "replace",
-    start: SessionSeq(remap(op.start)),
-    end: SessionSeq(remap(op.end)),
-  };
-}
-
-export function remapShadowedRange(
-  range: { start: number; end: number },
-  remap: (seq: number) => number,
-): { start: number; end: number } {
-  return { start: remap(range.start), end: remap(range.end) };
-}
-
-export function remapShadowedSeqs(
-  seqs: readonly number[],
-  seqMap: ReadonlyMap<number, number>,
-): number[] {
-  // 未持久化的引用（分支裁剪等）直接丢弃：恒等回退会留下陈旧的上游 seq，
-  // 稠密坐标通常被压缩，它可能大于 replace 事件的稠密 seq，上游
-  // assertProvenance 会以 "must reference earlier events" 拒绝整个会话。
-  return seqs.flatMap((seq) => {
-    const dense = seqMap.get(seq);
-    return dense === undefined ? [] : [dense];
-  });
-}
-
-export function rowToEvent(row: EventRow, seqMap: ReadonlyMap<number, number>): SessionEvent {
-  const remap = (seq: number): number => seqMap.get(seq) ?? seq;
-  const surfaceOp =
-    row.fSurfaceOp !== null
-      ? remapSurfaceOp(JSON.parse(row.fSurfaceOp) as SurfaceOp, remap)
-      : undefined;
-  const data = JSON.parse(row.fData) as SessionEvent["data"];
-  // compaction 事件的 shadowedRange / shadowedSeqs 是插件合并字段，经结构化
-  // 视图重映射到稠密坐标。shadowedSeqs 是权威的被遮蔽节点列表（range 只是
-  // 首尾边界对，压缩竞态下可能漏掉并发落地的节点），replace 的 provenance
-  // 重计算依赖它，必须与 range 同空间。
-  if (row.fType === "compaction/summary" || row.fType === "compaction/prune") {
-    const metering = data as unknown as {
-      shadowedRange?: { start: number; end: number };
-      shadowedSeqs?: number[];
-    };
-    if (metering.shadowedRange !== undefined) {
-      metering.shadowedRange = remapShadowedRange(metering.shadowedRange, remap);
-    }
-    if (metering.shadowedSeqs !== undefined) {
-      metering.shadowedSeqs = remapShadowedSeqs(metering.shadowedSeqs, seqMap);
-    }
+export function rowToEvent(row: EventRow): SessionEvent {
+  const surfaceOp = row.fSurfaceOp !== null ? (JSON.parse(row.fSurfaceOp) as SurfaceOp) : undefined;
+  const record = JSON.parse(row.fData) as unknown;
+  // fData 形状判别：新写入的完整事件（含 ignorable 信封，与 JSONL 每行
+  // 同构）vs 旧 v2 库的纯 data 部分。完整事件必有 type/seq/time/data 四键。
+  const full =
+    typeof record === "object" &&
+    record !== null &&
+    !Array.isArray(record) &&
+    typeof (record as Record<string, unknown>)["type"] === "string" &&
+    typeof (record as Record<string, unknown>)["seq"] === "number" &&
+    typeof (record as Record<string, unknown>)["time"] === "number" &&
+    "data" in (record as Record<string, unknown>);
+  if (full) {
+    // seq/time 以桥接行/事件列为权威（rewind 截断后仍稠密连续）；
+    // surfaceOp 走桥接行列，sourceEventSeqs 不落库（读取时重计算）。
+    return {
+      ...(record as SessionEvent),
+      seq: row.fSequence,
+      time: row.fCreatedAt,
+      ...(surfaceOp === undefined ? {} : { surfaceOp }),
+    } as SessionEvent;
   }
   return {
     type: row.fType as SessionEvent["type"],
     seq: row.fSequence,
     time: row.fCreatedAt,
-    data,
+    data: record as SessionEvent["data"],
     ...(surfaceOp === undefined ? {} : { surfaceOp }),
   } as SessionEvent;
 }
 
-export function buildSeqMap(
-  rows: readonly Pick<EventRow, "fSequence" | "fOriginalSeq">[],
-): Map<number, number> {
-  const map = new Map<number, number>();
-  for (const row of rows) {
-    if (!map.has(row.fOriginalSeq)) map.set(row.fOriginalSeq, row.fSequence);
-  }
-  return map;
-}
-
 const SURFACE_EVENT_TYPES = new Set(["user/message", "assistant/message", "tool/result"]);
 
 const METERING_EVENT_TYPES = new Set(["compaction/summary", "compaction/prune"]);
@@ -418,7 +380,6 @@ export function repairOrphanInboxSplices(events: SessionEvent[]): void {
 export function scanRows(
   rows: readonly EventRow[],
   base = 0,
-  seqMap: ReadonlyMap<number, number> = new Map(),
 ): { preserved: SessionEvent[]; tornFrom?: number } {
   // Pass 1：解析每行 data；JSON 非法的行是洞（seq/type 列即使在 data 损坏
   // 时也存在）。
@@ -428,7 +389,7 @@ export function scanRows(
   }
   const parsed: Parsed[] = rows.map((row) => {
     try {
-      return { ok: true, event: rowToEvent(row, seqMap) };
+      return { ok: true, event: rowToEvent(row) };
     } catch {
       return { ok: false };
     }
@@ -471,32 +432,25 @@ export function scanRows(
     : { preserved };
 }
 
-function toStorageRecord(record: import("@deepseek-ai/dsh-session").StorageRecord): unknown {
-  const withSeqs = record as import("@deepseek-ai/dsh-session").StorageRecord & {
-    sourceEventSeqs?: unknown;
-  };
-  if (withSeqs.sourceEventSeqs === undefined) return record;
-  return { ...record, sourceEventSeqs: encodeSeqRanges(withSeqs.sourceEventSeqs as never) };
-}
-
 export function toJsonlArtifact(
   meta: SessionHeader,
   inheritedEventCount: number,
   events: readonly SessionEvent[],
 ): string {
-  const header = {
-    type: "session",
-    version: meta.version,
-    id: meta.id,
-    createdAt: meta.createdAt,
-    ...(meta.cwd === undefined ? {} : { cwd: meta.cwd }),
-    ...(meta.parentSession === undefined ? {} : { parentSession: meta.parentSession }),
-    ...(meta.isSeeded ? { seedLength: inheritedEventCount } : {}),
-    ...(meta.origin === undefined ? {} : { origin: meta.origin }),
-    delegationDepth: meta.delegationDepth ?? 0,
-    ...(meta.agentPreset === undefined ? {} : { agentPreset: meta.agentPreset }),
-  };
+  const header = sessionFormatCatalog.encodeCurrentHeader(
+    {
+      ...meta,
+      delegationDepth: meta.delegationDepth ?? 0,
+    } as unknown as SessionFormatHeader,
+    inheritedEventCount,
+  );
   const lines = [JSON.stringify(header)];
-  for (const record of packChunkRuns(events)) lines.push(JSON.stringify(toStorageRecord(record)));
+  for (const event of events) {
+    lines.push(
+      JSON.stringify(
+        sessionFormatCatalog.encodeCurrentEvent(event as unknown as SessionFormatEvent),
+      ),
+    );
+  }
   return lines.join("\n");
 }

package/src/postgres.ts

@@ -1,6 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { and, desc, eq, gte, sql } from "drizzle-orm";
-import type { PgAsyncDatabase, PgAsyncTransaction, PgQueryResultHKT } from "drizzle-orm/pg-core";
+import { readdirSync } from "node:fs";
+import { and, eq, gte, sql } from "drizzle-orm";
+import type { PgAsyncDatabase, PgAsyncTransaction } from "drizzle-orm/pg-core";
+import type { NodePgDatabase, NodePgQueryResultHKT } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
 import type { SessionId } from "@deepseek-ai/dsh-session";
 import type { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
 import {
@@ -10,11 +13,13 @@ import {
   type EventRow,
   type SessionRow,
 } from "./backend.ts";
-import { SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID } from "./schema.ts";
-import { createTablesSql, toPostgresSchema } from "./adapters/index.ts";
+import { toPostgresSchema } from "./adapters/index.ts";
 import { postgresTableDefs } from "./entities/index.ts";
 import { sessionConflictRow, sessionInsertRow } from "./log.ts";
 
+/** drizzle-kit 生成的迁移目录（随包根 drizzle/ 发布；src/dist 形态经相对 URL 统一解析）。 */
+const postgresMigrationsDir = new URL("../drizzle/postgres/", import.meta.url).pathname;
+
 export interface PostgresBackendOptions {
   identityBase: string;
 
@@ -23,60 +28,36 @@ export interface PostgresBackendOptions {
   close: () => Promise<void>;
 }
 
-export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> implements Backend {
+export class PostgresBackend implements Backend {
   readonly kind = "postgres" as const;
   storeIdentity!: string;
 
   private readonly tables: Record<string, any>;
 
   constructor(
-    private readonly db: PgAsyncDatabase<THKT>,
+    private readonly db: NodePgDatabase,
     private readonly options: PostgresBackendOptions,
   ) {
     this.tables = toPostgresSchema(postgresTableDefs, this.options.schema ?? "public");
   }
 
   async open(): Promise<void> {
-    const storeId = await this.db.transaction(async (tx) => {
-      const schema = this.options.schema ?? "public";
-      // 探测在建表之前：t_schema_meta 存在与否区分全新库与已有库。
-      // `to_regclass` 是数据库元数据查询，drizzle 无对应 API；schema 限定
-      // 显式引用（不依赖 search_path）。
-      const qualifiedMeta = schema === "public" ? "t_schema_meta" : `"${schema}".t_schema_meta`;
-      const probe = (await tx.execute(
-        sql`SELECT to_regclass(${qualifiedMeta}) IS NOT NULL AS exists`,
-      )) as unknown as { rows: { exists: boolean }[] };
-      const metaExists = probe.rows[0]?.exists === true;
-      // DDL 一次一条（PG 的 extended query protocol 拒绝多语句字符串），
-      // 逐条执行保持初始化原子。
-      for (const statement of createTablesSql("postgres", postgresTableDefs, schema)) {
-        await tx.execute(sql.raw(statement));
-      }
-      if (!metaExists) {
-        await tx
-          .insert(this.tables["t_schema_meta"])
-          .values([
-            { fKey: "schema_version", fValue: String(SCHEMA_VERSION) },
-            { fKey: "application_id", fValue: String(SESSION_PERSISTENCE_SQLITE_APPLICATION_ID) },
-          ])
-          .execute();
-      }
-      // 校验：缺版本行 = 有对象但未版本化 → 拒绝，不迁移。
-      const version = await this.readMeta(tx, "schema_version");
-      const applicationId = await this.readMeta(tx, "application_id");
-      if (version === undefined || applicationId === undefined) {
-        throw new Error("session database has an unversioned schema or application identity");
-      }
-      if (Number(version) !== SCHEMA_VERSION) {
-        throw new Error(
-          `session database has schema version ${version}, incompatible with this build (${SCHEMA_VERSION})`,
-        );
-      }
-      if (Number(applicationId) !== SESSION_PERSISTENCE_SQLITE_APPLICATION_ID) {
-        throw new Error(
-          `session database has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`,
-        );
+    const schema = this.options.schema ?? "public";
+    // drizzle-kit 迁移：v2 baseline 由旧版本建表（首次打开时标记为已应用），
+    // 本版本只执行 v3 diff（删 f_original_seq）。
+    const qualifiedMeta = schema === "public" ? "t_schema_meta" : `"${schema}".t_schema_meta`;
+    const probe = (await this.db.execute(
+      sql`SELECT to_regclass(${qualifiedMeta}) IS NOT NULL AS exists`,
+    )) as unknown as { rows: { exists: boolean }[] };
+    const metaExists = probe.rows[0]?.exists === true;
+    if (metaExists) {
+      const version = await this.readMeta(this.db, "schema_version");
+      if (version === "2") {
+        await this.baselineV2();
       }
+    }
+    await migrate(this.db, { migrationsFolder: postgresMigrationsDir });
+    const storeId = await this.db.transaction(async (tx) => {
       await tx
         .insert(this.tables["t_persistence_state"])
         .values({ fSingleton: 1, fStoreId: randomUUID() })
@@ -87,15 +68,36 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
         .from(this.tables["t_persistence_state"])
         .where(eq(this.tables["t_persistence_state"].fSingleton, 1))
         .execute();
-      const storeId = store[0]?.fStoreId;
-      if (storeId === undefined || storeId.length === 0) {
+      const id = store[0]?.fStoreId;
+      if (id === undefined || id.length === 0) {
         throw new Error("session database has no valid store identity");
       }
-      return storeId;
+      return id;
     });
     this.storeIdentity = `${this.options.identityBase}:store:${storeId}`;
   }
 
+  /** 标记 v2 baseline 已应用（迁移表 v1 结构：id/hash/created_at/name/applied_at）。 */
+  private async baselineV2(): Promise<void> {
+    const dir = readdirSync(postgresMigrationsDir).find((name) => name.endsWith("_v2_initial"));
+    if (dir === undefined) throw new Error("missing v2 baseline migration in drizzle/postgres");
+    await this.db.execute(sql`
+      CREATE SCHEMA IF NOT EXISTS drizzle
+    `);
+    await this.db.execute(sql`
+      CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
+        id SERIAL PRIMARY KEY,
+        hash text NOT NULL,
+        created_at bigint,
+        name text,
+        applied_at timestamp with time zone DEFAULT now()
+      )
+    `);
+    await this.db.execute(
+      sql`INSERT INTO drizzle.__drizzle_migrations (hash, created_at, name) VALUES ('baseline', 0, ${dir})`,
+    );
+  }
+
   async close(): Promise<void> {
     await this.options.close();
   }
@@ -110,17 +112,6 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
     )[0] as SessionRow | undefined;
   }
 
-  async getSeqMapRows(id: SessionId): Promise<Array<{ fSequence: number; fOriginalSeq: number }>> {
-    return this.db
-      .select({
-        fSequence: this.tables["t_session_events"].fSequence,
-        fOriginalSeq: this.tables["t_session_events"].fOriginalSeq,
-      })
-      .from(this.tables["t_session_events"])
-      .where(eq(this.tables["t_session_events"].fSessionId, id))
-      .execute();
-  }
-
   async getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]> {
     const scoped =
       fromSequence === undefined
@@ -146,7 +137,7 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
     return this.db.transaction(async (tx) => fn(this.txFor(tx)));
   }
 
-  private txFor(tx: PgAsyncTransaction<THKT>): BackendTx {
+  private txFor(tx: PgAsyncTransaction<NodePgQueryResultHKT>): BackendTx {
     return {
       upsertSession: (storage, incarnation) => this.upsertSession(tx, storage, incarnation),
       getHead: (id) => this.getHead(tx, id),
@@ -159,13 +150,15 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
       bumpRevision: (id) => this.bumpRevision(tx, id),
       deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
       getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence),
-      getLastBridge: (id) => this.getLastBridge(tx, id),
     };
   }
 
   // --- meta helpers ---
 
-  private async readMeta(exec: PgAsyncDatabase<THKT>, key: string): Promise<string | undefined> {
+  private async readMeta(
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
+    key: string,
+  ): Promise<string | undefined> {
     const rows = await exec
       .select({ fValue: this.tables["t_schema_meta"].fValue })
       .from(this.tables["t_schema_meta"])
@@ -177,7 +170,7 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
   // --- row primitives (transaction-internal) ---
 
   private async upsertSession(
-    exec: PgAsyncDatabase<THKT>,
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     storage: SessionStorageMetadata,
     incarnation: string,
   ): Promise<void> {
@@ -192,7 +185,7 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
   }
 
   private async getHead(
-    exec: PgAsyncDatabase<THKT>,
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     id: SessionId,
   ): Promise<Pick<SessionRow, "fHeadEventId" | "fHeadSequence">> {
     const head = (
@@ -210,7 +203,10 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
     return head;
   }
 
-  private async getSeedLength(exec: PgAsyncDatabase<THKT>, id: SessionId): Promise<number | null> {
+  private async getSeedLength(
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
+    id: SessionId,
+  ): Promise<number | null> {
     const row = (
       await exec
         .select({ fSeedLength: this.tables["t_sessions"].fSeedLength })
@@ -224,7 +220,7 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
   }
 
   private async updateSeedLength(
-    exec: PgAsyncDatabase<THKT>,
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     id: SessionId,
     seedLength: number,
   ): Promise<void> {
@@ -237,7 +233,10 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
 
   private static readonly INSERT_BATCH_ROWS = 1000;
 
-  private async insertEvents(exec: PgAsyncDatabase<THKT>, events: EventInsert[]): Promise<void> {
+  private async insertEvents(
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
+    events: EventInsert[],
+  ): Promise<void> {
     if (events.length === 0) return;
     for (let i = 0; i < events.length; i += PostgresBackend.INSERT_BATCH_ROWS) {
       await exec
@@ -250,12 +249,11 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
   }
 
   private async insertBridges(
-    exec: PgAsyncDatabase<THKT>,
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     rows: Array<{
       fSessionId: SessionId;
       fEventId: string;
       fSequence: number;
-      fOriginalSeq: number;
       fSurfaceOp: string | null;
     }>,
   ): Promise<void> {
@@ -269,7 +267,7 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
   }
 
   private async updateHead(
-    exec: PgAsyncDatabase<THKT>,
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     id: SessionId,
     headEventId: string,
     headSequence: number,
@@ -281,7 +279,10 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
       .execute();
   }
 
-  private async bumpRevision(exec: PgAsyncDatabase<THKT>, id: SessionId): Promise<void> {
+  private async bumpRevision(
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
+    id: SessionId,
+  ): Promise<void> {
     await exec
       .update(this.tables["t_sessions"])
       .set({ fRevision: sql`${this.tables["t_sessions"].fRevision} + 1` })
@@ -290,7 +291,7 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
   }
 
   private async deleteBridgeTail(
-    exec: PgAsyncDatabase<THKT>,
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     id: SessionId,
     fromSequence: number,
   ): Promise<void> {
@@ -306,7 +307,7 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
   }
 
   private async getPrevBridge(
-    exec: PgAsyncDatabase<THKT>,
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     id: SessionId,
     sequence: number,
   ): Promise<{ fEventId: string; fSequence: number } | undefined> {
@@ -327,30 +328,11 @@ export class PostgresBackend<THKT extends PgQueryResultHKT = PgQueryResultHKT> i
     )[0] as { fEventId: string; fSequence: number } | undefined;
   }
 
-  private async getLastBridge(
-    exec: PgAsyncDatabase<THKT>,
-    id: SessionId,
-  ): Promise<{ fEventId: string; fSequence: number } | undefined> {
-    return (
-      await exec
-        .select({
-          fEventId: this.tables["t_session_events"].fEventId,
-          fSequence: this.tables["t_session_events"].fSequence,
-        })
-        .from(this.tables["t_session_events"])
-        .where(eq(this.tables["t_session_events"].fSessionId, id))
-        .orderBy(desc(this.tables["t_session_events"].fSequence))
-        .limit(1)
-        .execute()
-    )[0] as { fEventId: string; fSequence: number } | undefined;
-  }
-
-  private eventRows(exec: PgAsyncDatabase<THKT>) {
+  private eventRows(exec: PgAsyncDatabase<NodePgQueryResultHKT>) {
     return exec
       .select({
         fEventId: this.tables["t_session_events"].fEventId,
         fSequence: this.tables["t_session_events"].fSequence,
-        fOriginalSeq: this.tables["t_session_events"].fOriginalSeq,
         fType: this.tables["t_events"].fType,
         fKind: this.tables["t_events"].fKind,
         fRole: this.tables["t_events"].fRole,

package/src/schema.ts

@@ -2,12 +2,10 @@ import type { SessionEvent } from "@deepseek-ai/dsh-session";
 import { toSqliteSchema } from "./adapters/index.ts";
 import { sqliteTableDefs } from "./entities/index.ts";
 
-export const SCHEMA_VERSION = 2;
+export const SCHEMA_VERSION = 3;
 
 export const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 0x44534850;
 
-export const EPHEMERAL_EVENT_TYPES = ["assistant/chunk"] as const;
-
 export const EVENT_ENCODING = "json";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -15,6 +13,8 @@ const sqliteTables: Record<string, any> = toSqliteSchema(sqliteTableDefs);
 
 export const tPersistenceState = sqliteTables["t_persistence_state"]!;
 
+export const tSchemaMeta = sqliteTables["t_schema_meta"]!;
+
 export const tSessions = sqliteTables["t_sessions"]!;
 
 export const tEvents = sqliteTables["t_events"]!;
@@ -29,17 +29,6 @@ export type JournalMode = "wal" | "delete" | "truncate" | "persist";
 
 export const DEFAULT_BUSY_TIMEOUT_MS = 5000;
 
-export function isEphemeralType(type: string): boolean {
-  return (EPHEMERAL_EVENT_TYPES as readonly string[]).includes(type);
-}
-
-export function isPersistedEvent(event: SessionEvent): boolean {
-  return (
-    !isEphemeralType(event.type) &&
-    (event as SessionEvent & { ignorable?: unknown }).ignorable !== true
-  );
-}
-
 export type EventKind =
   | "message"
   | "thinking"