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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/session-rdb",
-  "version": "0.1.10-alpha.0",
+  "version": "0.1.10-alpha.3",
   "description": "RDB durable session backend for DeepSeek Harness: implements both session-persistence and session-branch (rewind / retry / fork) providers.",
   "keywords": [
     "branch",
@@ -20,7 +20,6 @@
     "locale/*.json",
     "dist",
     "src",
-    "drizzle",
     "!**/__tests__"
   ],
   "type": "module",
@@ -41,9 +40,9 @@
       "types": "./dist/export.d.mts",
       "default": "./dist/export.mjs"
     },
-    "./gc": {
-      "types": "./dist/gc.d.mts",
-      "default": "./dist/gc.mjs"
+    "./organize": {
+      "types": "./dist/organize.d.mts",
+      "default": "./dist/organize.mjs"
     },
     "./import": {
       "types": "./dist/import.d.mts",
@@ -65,44 +64,41 @@
     "./locale/*.json": "./locale/*.json"
   },
   "dependencies": {
-    "@morlay/session-branch": "0.1.10-alpha.0",
-    "drizzle-orm": "^1.0.0-rc.5-ab785fc",
-    "fflate": "^0.8.2",
-    "pg": "^8.23.0"
+    "@morlay/rdbkit": "0.0.1-alpha.3",
+    "@morlay/session-branch": "0.1.10-alpha.3",
+    "fflate": "^0.8.2"
   },
   "devDependencies": {
-    "@deepseek-ai/cosmokit": "^1.8.7-alpha.1",
-    "@deepseek-ai/dsh-agent-loop-testkit": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-compaction": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-session-turn-outline": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-storage": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-storage-domain": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-token-meter": "^0.2.2-alpha.2",
-    "@types/pg": "^8.23.1",
-    "drizzle-kit": "1.0.0-rc.5-ab785fc"
+    "@deepseek-ai/cosmokit": "^1.8.7-alpha.2",
+    "@deepseek-ai/dsh-agent-loop-testkit": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-compaction": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-cua": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session-turn-outline": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-storage": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-storage-domain": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-token-meter": "^0.2.2-alpha.3"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.6-alpha.1",
-    "@deepseek-ai/cosmokit": "^1.8.7-alpha.1",
-    "@deepseek-ai/dsh-llm": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-schedule": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-scope": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-session": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-session-format": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-session-format-catalog": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-session-persistence": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-session-projection": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-session-projection-cache": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-session-query": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-storage": "^0.2.2-alpha.2",
-    "@deepseek-ai/dsh-workspace": "^0.2.2-alpha.2",
-    "@deepseek-ai/schemastery": "^3.18.6-alpha.1"
+    "@deepseek-ai/cordis": "^4.0.6-alpha.2",
+    "@deepseek-ai/cosmokit": "^1.8.7-alpha.2",
+    "@deepseek-ai/dsh-llm": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-schedule": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-scope": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session-format": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session-format-catalog": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session-persistence": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session-projection": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session-projection-cache": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session-query": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-storage": "^0.2.2-alpha.3",
+    "@deepseek-ai/dsh-workspace": "^0.2.2-alpha.3",
+    "@deepseek-ai/schemastery": "^3.18.6-alpha.2"
   },
   "engines": {
-    "dsh": ">= 0.2.2-alpha.2 < 0.2.3"
+    "dsh": ">= 0.2.2-alpha.3 < 0.2.3"
   },
   "scripts": {
-    "build": "pnpm exec tsdown",
-    "db:generate": "drizzle-kit generate --config drizzle.config.ts && drizzle-kit generate --config drizzle.pg.config.ts"
+    "build": "pnpm exec tsdown"
   }
 }

package/src/artifact.ts

@@ -1,2 +1,5 @@
-export * from "./log.ts";
+export * from "./log/rows.ts";
+export * from "./log/repair.ts";
+export * from "./log/export.ts";
+export * from "./log/usage-row.ts";
 export * from "./import.ts";

package/src/backend-rdb.ts

@@ -0,0 +1,331 @@
+import { E, count, type Database } from "@morlay/rdbkit";
+import type {
+  Backend,
+  BackendTx,
+  EventInsert,
+  SessionCountBucket,
+  SessionListRowsPage,
+  SessionListRowsQuery,
+  SessionRow,
+  SessionUsageBucket,
+} from "./backend.ts";
+import type { SessionId } from "@deepseek-ai/dsh-session";
+import type { UsageAggregate } from "./usage.ts";
+import {
+  eventUsage,
+  events,
+  sessionEvents,
+  sessions,
+} from "./entities/index.ts";
+import type { EventUsageRow } from "./log/usage-row.ts";
+import { sessionHeaderColumns, sessionInsertColumns } from "./log/rows.ts";
+import { titleOfEventData } from "./log/export.ts";
+import { collectOrphans, readHead, readPrevBridge, readSeedLength } from "./session-ops.ts";
+import {
+  headerChangedCondition,
+  lastEventAtExpr,
+  type ReadModel,
+} from "./storage-takeover/read-model.ts";
+import type { StorageRepository } from "./storage-takeover/types.ts";
+import * as stats from "./db/stats.ts";
+import { pruneWorkspaceDocuments } from "./storage-takeover/workspace-documents.ts";
+
+const INSERT_BATCH_ROWS = 1000;
+
+/**
+ * 唯一的 backend 实现：读写方法收敛在这里（读模型 + `session-ops` + 表句柄）；打开流程在 `db/open.ts`，
+ * 统计面在 `db/stats.ts`。方言差异全部由 rdbkit 的表达式承担，这里不出现任何 SQL 文本。
+ */
+export class RdbBackend implements Backend {
+  readonly storage: StorageRepository;
+  readonly storeIdentity: string;
+
+  readonly #database: Database;
+  readonly reads: ReadModel;
+
+  constructor(options: {
+    kind: "sqlite" | "postgres";
+    database: Database;
+    storage: StorageRepository;
+    readModel: ReadModel;
+    storeIdentity: string;
+  }) {
+    this.kind = options.kind;
+    this.#database = options.database;
+    this.storage = options.storage;
+    this.reads = options.readModel;
+    this.storeIdentity = options.storeIdentity;
+  }
+
+  readonly kind: "sqlite" | "postgres";
+
+  async open(): Promise<void> {
+    // 打开在 `openRdbBackend` 里完成（构造后即可用）。
+  }
+
+  async close(): Promise<void> {
+    await this.#database.close();
+  }
+
+  async transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T> {
+    return await this.#database.transaction(async (scoped) => fn(this.#txFor(scoped)));
+  }
+
+  async listOrphanSubagentSessions(): Promise<SessionId[]> {
+    return (await this.reads.listOrphanSubagentSessions()) as SessionId[];
+  }
+
+  /** 当前 head 指针（分支 / 测试读路径用；写路径在 `BackendTx` 里）。 */
+  async getHead(id: SessionId): Promise<Pick<SessionRow, "fHeadEventId" | "fHeadSequence">> {
+    return await readHead(this.#database, id);
+  }
+
+  async collectOrphans(): Promise<number> {
+    return await collectOrphans(this.#database);
+  }
+
+  async usageReport(sinceMs?: number): Promise<UsageAggregate> {
+    return await stats.usageReport(this.#database, sinceMs);
+  }
+
+  async listSessionRows(query?: SessionListRowsQuery): Promise<SessionListRowsPage> {
+    return await stats.listSessionRows(this.#database, this.storage, query);
+  }
+
+  async incrementSessionUsage(id: string, buckets: readonly SessionUsageBucket[]): Promise<void> {
+    await stats.incrementSessionUsage(this.#database, id, buckets);
+  }
+
+  async incrementSessionCounts(id: string, buckets: readonly SessionCountBucket[]): Promise<void> {
+    await stats.incrementSessionCounts(this.#database, id, buckets);
+  }
+
+  async deleteSessionStats(id: string): Promise<void> {
+    await stats.deleteSessionStats(this.#database, id);
+  }
+
+  async rebuildSessionStats(id: string): Promise<void> {
+    await stats.rebuildSessionStats(this.#database, id);
+  }
+
+  async rebuildAllStats(): Promise<number> {
+    return await stats.rebuildAllStats(this.#database);
+  }
+
+  async refreshEventUsageFlags(eventIds: readonly string[]): Promise<void> {
+    await stats.refreshEventUsageFlags(this.#database, eventIds);
+  }
+
+  async vacuum(): Promise<void> {
+    await this.#database.vacuum();
+  }
+
+  #txFor(rdb: Database): BackendTx {
+    return {
+      upsertSession: (storage, incarnation) => this.#upsertSession(rdb, storage, incarnation),
+      getHead: (id) => readHead(rdb, id),
+      getSeedLength: (id) => readSeedLength(rdb, id),
+      updateSeedLength: (id, seedLength) => this.#updateSeedLength(rdb, id, seedLength),
+      refreshTitle: (id) => this.#refreshTitle(rdb, id),
+      insertEvents: (events, usageRows) => this.#insertEvents(rdb, events, usageRows),
+      insertBridges: (rows) => this.#insertBridges(rdb, rows),
+      updateHead: (id, headEventId, headSequence) =>
+        this.#updateHead(rdb, id, headEventId, headSequence),
+      updateHeadAndRevision: (id, headEventId, headSequence, lastEventAt) =>
+        this.#updateHeadAndRevision(rdb, id, headEventId, headSequence, lastEventAt),
+      bumpRevision: (id, lastEventAt) => this.#bumpRevision(rdb, id, lastEventAt),
+      deleteBridgeTail: (id, fromSequence) => this.#deleteBridgeTail(rdb, id, fromSequence),
+      getPrevBridge: (id, sequence) => readPrevBridge(rdb, id, sequence),
+      deleteSession: (id) => this.#deleteSession(rdb, id),
+      deleteSessions: (ids) => this.#deleteSessions(rdb, ids),
+    };
+  }
+
+  async #upsertSession(
+    rdb: Database,
+    storage: Parameters<BackendTx["upsertSession"]>[0],
+    incarnation: string,
+  ): Promise<void> {
+    const row = sessionInsertColumns(storage, incarnation);
+    const header = sessionHeaderColumns(storage);
+    const table = sessions.table(rdb);
+    await table.insertIgnore(row, ["f_session_id"]);
+    await table.update(
+      header,
+      E.and(E.eq(table.f_session_id, storage.meta.id), headerChangedCondition(header)),
+    );
+  }
+
+  async #updateSeedLength(rdb: Database, id: string, seedLength: number): Promise<void> {
+    const table = sessions.table(rdb);
+    await table.update({ f_seed_length: seedLength }, E.eq(table.f_session_id, id));
+  }
+
+  async #refreshTitle(rdb: Database, id: string): Promise<void> {
+    const latest = await this.reads.latestTitleEvent(id);
+    const title = latest === undefined ? undefined : titleOfEventData(latest.fData);
+    const nextTitle = title ?? null;
+    const nextSeq = title === undefined ? null : latest!.fSequence;
+    const table = sessions.table(rdb);
+    await table.update(
+      { f_title: nextTitle, f_title_seq: nextSeq },
+      E.and(
+        E.eq(table.f_session_id, id),
+        E.or(E.isDistinctFrom(table.f_title, nextTitle), E.isDistinctFrom(table.f_title_seq, nextSeq)),
+      ),
+    );
+  }
+
+  async #insertEvents(
+    rdb: Database,
+    eventRows: EventInsert[],
+    usageRows: readonly EventUsageRow[],
+  ): Promise<void> {
+    if (eventRows.length === 0) return;
+    const eventsTable = events.table(rdb);
+    for (let i = 0; i < eventRows.length; i += INSERT_BATCH_ROWS) {
+      await eventsTable.insertMany(
+        eventRows.slice(i, i + INSERT_BATCH_ROWS).map((event) => ({
+          f_event_id: event.fEventId,
+          f_parent_id: event.fParentId,
+          f_type: event.fType,
+          f_kind: event.fKind,
+          f_role: event.fRole,
+          f_name: event.fName,
+          f_action_id: event.fActionId,
+          f_encoding: event.fEncoding,
+          f_data: event.fData,
+          f_created_at: event.fCreatedAt,
+        })),
+      );
+    }
+    if (usageRows.length > 0) {
+      const usage = eventUsage.table(rdb);
+      for (let i = 0; i < usageRows.length; i += INSERT_BATCH_ROWS) {
+        await usage.insertMany(
+          usageRows.slice(i, i + INSERT_BATCH_ROWS).map((row) => ({
+            f_event_id: row.fEventId,
+            f_created_at: row.fCreatedAt,
+            f_day: row.fDay,
+            f_provider: row.fProvider,
+            f_model: row.fModel,
+            f_referenced: row.fReferenced,
+            f_subagent: row.fSubagent,
+            f_input_tokens: row.fInputTokens,
+            f_output_tokens: row.fOutputTokens,
+            f_cache_read_tokens: row.fCacheReadTokens,
+            f_reasoning_tokens: row.fReasoningTokens,
+            f_total_tokens: row.fTotalTokens,
+          })),
+          { conflict: ["f_event_id"] },
+        );
+      }
+    }
+  }
+
+  async #insertBridges(
+    rdb: Database,
+    rows: Array<{ fSessionId: string; fEventId: string; fSequence: number; fSurfaceOp: string | null }>,
+  ): Promise<void> {
+    if (rows.length === 0) return;
+    const links = sessionEvents.table(rdb);
+    for (let i = 0; i < rows.length; i += INSERT_BATCH_ROWS) {
+      await links.insertMany(
+        rows.slice(i, i + INSERT_BATCH_ROWS).map((row) => ({
+          f_session_id: row.fSessionId,
+          f_event_id: row.fEventId,
+          f_sequence: row.fSequence,
+          f_surface_op: row.fSurfaceOp,
+        })),
+      );
+    }
+  }
+
+  async #updateHead(
+    rdb: Database,
+    id: string,
+    headEventId: string,
+    headSequence: number,
+  ): Promise<void> {
+    const table = sessions.table(rdb);
+    await table.update(
+      { f_head_event_id: headEventId, f_head_sequence: headSequence },
+      E.eq(table.f_session_id, id),
+    );
+  }
+
+  async #updateHeadAndRevision(
+    rdb: Database,
+    id: string,
+    headEventId: string,
+    headSequence: number,
+    lastEventAt?: number,
+  ): Promise<void> {
+    const table = sessions.table(rdb);
+    await table.update(
+      {
+        f_head_event_id: headEventId,
+        f_head_sequence: headSequence,
+        f_revision: E.add(table.f_revision, 1),
+        ...(lastEventAt === undefined ? {} : { f_last_event_at: lastEventAtExpr(lastEventAt) }),
+      },
+      E.eq(table.f_session_id, id),
+    );
+  }
+
+  async #bumpRevision(rdb: Database, id: string, lastEventAt?: number): Promise<void> {
+    const table = sessions.table(rdb);
+    await table.update(
+      {
+        f_revision: E.add(table.f_revision, 1),
+        ...(lastEventAt === undefined ? {} : { f_last_event_at: lastEventAtExpr(lastEventAt) }),
+      },
+      E.eq(table.f_session_id, id),
+    );
+  }
+
+  async #deleteBridgeTail(rdb: Database, id: string, fromSequence: number): Promise<readonly string[]> {
+    const links = sessionEvents.table(rdb);
+    const rows = await links.delete(
+      E.and(E.eq(links.f_session_id, id), E.gte(links.f_sequence, fromSequence)),
+      ["f_event_id"],
+    );
+    return rows.map((row) => row.f_event_id);
+  }
+
+  async #deleteSession(rdb: Database, id: string): Promise<readonly string[]> {
+    const links = sessionEvents.table(rdb);
+    const rows = await links.delete(E.eq(links.f_session_id, id), ["f_event_id"]);
+    await this.#deleteSessionStatsRows(rdb, [id]);
+    const table = sessions.table(rdb);
+    await table.delete(E.eq(table.f_session_id, id));
+    await this.#pruneWorkspace(rdb, [id]);
+    return rows.map((row) => row.f_event_id);
+  }
+
+  async #deleteSessions(
+    rdb: Database,
+    ids: string[],
+  ): Promise<{ deleted: number; eventIds: readonly string[] }> {
+    if (ids.length === 0) return { deleted: 0, eventIds: [] };
+    const links = sessionEvents.table(rdb);
+    const removed = await links.delete(E.inList(links.f_session_id, ids), ["f_event_id"]);
+    await this.#deleteSessionStatsRows(rdb, ids);
+    const table = sessions.table(rdb);
+    let deleted = 0;
+    for await (const row of table.select({ n: count() }).where(E.inList(table.f_session_id, ids))) {
+      deleted = Number(row.n);
+    }
+    await table.delete(E.inList(table.f_session_id, ids));
+    await this.#pruneWorkspace(rdb, ids);
+    return { deleted, eventIds: removed.map((row) => row.f_event_id) };
+  }
+
+  async #deleteSessionStatsRows(rdb: Database, ids: readonly string[]): Promise<void> {
+    for (const id of ids) await stats.deleteSessionStats(rdb, id);
+  }
+
+  async #pruneWorkspace(rdb: Database, ids: readonly string[]): Promise<void> {
+    await pruneWorkspaceDocuments(rdb, ids);
+  }
+}

package/src/backend.ts

@@ -1,6 +1,6 @@
 import type { SessionId } from "@deepseek-ai/dsh-session";
 import type { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
-import type { EventUsageRow } from "./log.ts";
+import type { EventUsageRow } from "./log/usage-row.ts";
 import type { StorageRepository } from "./storage-takeover/types.ts";
 import type { UsageActivityTotals, UsageAggregate, UsageTokenTotals } from "./usage.ts";
 
@@ -90,6 +90,14 @@ export interface BackendTx {
 
   updateHead(id: SessionId, headEventId: string, headSequence: number): Promise<void>;
 
+  /** 推进 head 并 bump revision：同一行一次 UPDATE（分两次写是纯写放大）。 */
+  updateHeadAndRevision(
+    id: SessionId,
+    headEventId: string,
+    headSequence: number,
+    lastEventAt?: number,
+  ): Promise<void>;
+
   // 写批次提交时递增 revision；给了 `lastEventAt` 就一并把「最后活动时间」往前推（只增不减）。
   bumpRevision(id: SessionId, lastEventAt?: number): Promise<void>;
 
@@ -152,6 +160,23 @@ export interface SessionUsageBucket extends UsageTokenTotals {
   model: string | null;
 }
 
+/** 会话读的共享实现：写路径之外的所有查询都在这里（两方言共用一套投影查询）。 */
+export interface ReadModel {
+  getSession(id: string): Promise<SessionRow | undefined>;
+  getEventRows(id: string, fromSequence?: number): Promise<EventRow[]>;
+  getEventTypeAt(id: string, sequence: number): Promise<string | undefined>;
+  getEventTypesBefore(
+    id: string,
+    beforeSequence: number,
+    limit: number,
+  ): Promise<Array<Pick<EventRow, "fSequence" | "fType">>>;
+  listSessions(): Promise<SessionRow[]>;
+  /** 最新一条 `session/title` 事件（`refreshTitle` 用）。 */
+  latestTitleEvent(id: string): Promise<{ fSequence: number; fData: string } | undefined>;
+  /** 父会话已不在表里的 subagent 会话。 */
+  listOrphanSubagentSessions(): Promise<string[]>;
+}
+
 export interface Backend {
   readonly kind: "sqlite" | "postgres";
 
@@ -159,21 +184,10 @@ export interface Backend {
 
   readonly storage: StorageRepository;
 
-  open(): Promise<void>;
-
-  getSession(id: SessionId): Promise<SessionRow | undefined>;
+  /** 读面：会话行与事件行的查询（不再是 Backend 自己的 6 个转发方法）。 */
+  readonly reads: ReadModel;
 
-  getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]>;
-
-  getEventTypeAt(id: SessionId, sequence: number): Promise<string | undefined>;
-
-  getEventTypesBefore(
-    id: SessionId,
-    beforeSequence: number,
-    limit: number,
-  ): Promise<Array<Pick<EventRow, "fSequence" | "fType">>>;
-
-  listSessions(): Promise<SessionRow[]>;
+  open(): Promise<void>;
 
   transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T>;
 
@@ -201,6 +215,9 @@ export interface Backend {
   // 按会话从事件表重算两张汇总表（旧日志重写之后调用：迁移进来的会话没有旁路累加的历史，得补算）。
   rebuildSessionStats(id: SessionId): Promise<void>;
 
+  // 三张派生统计表清空后全量重算（整理数据的一步）；返回涉及的会话数。
+  rebuildAllStats(): Promise<number>;
+
   // 重算这些用量行的引用标记（`f_referenced` / `f_subagent`）：会话删除 / 日志重写之后调用，
   // `eventIds` 是被删掉的那批桥接行引用的事件（只有它们的引用可能消失）。
   // fork 与撤回（rewind）都**不**走这里——它们不改变已发生过的消耗（见 ADR-fork不继承统计、ADR-撤回不回退统计）。