@morlay/session-rdb 0.0.12 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/session-rdb",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "RDB durable session backend for DeepSeek Harness: implements both session-persistence and session-branch (rewind / retry / fork) providers.",
   "keywords": [
     "branch",
@@ -25,12 +25,16 @@
   "type": "module",
   "exports": {
     ".": "./dist/index.mjs",
+    "./artifact": "./dist/artifact.mjs",
+    "./import": "./dist/import.mjs",
     "./invariant": "./dist/invariant.mjs",
+    "./storage": "./dist/storage.mjs",
+    "./testing": "./dist/testing.mjs",
     "./package.json": "./package.json",
     "./cordis.patch.yml": "./cordis.patch.yml"
   },
   "dependencies": {
-    "@morlay/session-branch": "^0.0.2",
+    "@morlay/session-branch": "^0.0.3",
     "drizzle-orm": "^1.0.0-rc.5-ab785fc",
     "fflate": "^0.8.2",
     "pg": "^8.23.0"
@@ -55,6 +59,19 @@
       "patch": "./cordis.patch.yml"
     }
   },
+  "inlinedDependencies": {
+    "@jridgewell/sourcemap-codec": "1.6.0",
+    "@vitest/expect": "4.1.11",
+    "@vitest/pretty-format": "4.1.11",
+    "@vitest/runner": "4.1.11",
+    "@vitest/snapshot": "4.1.11",
+    "@vitest/spy": "4.1.11",
+    "@vitest/utils": "4.1.11",
+    "chai": "6.2.2",
+    "magic-string": "0.30.21",
+    "tinyrainbow": "3.1.1",
+    "vitest": "4.1.11"
+  },
   "scripts": {
     "build": "pnpm exec tsdown"
   }

package/src/artifact.ts

@@ -0,0 +1,4 @@
+// 日志 / artifact 格式层：会话日志行处理（scanRows / rowToEvent / 修复）与
+// 导入导出 artifact 解析（jsonl / zip）。文件物理分开，经本入口聚合导出。
+export * from "./log.ts";
+export * from "./import.ts";

package/src/index.ts

@@ -27,6 +27,7 @@ import { WriteGuard } from "./write-guard.ts";
 import {
   buildSeqMap,
   recomputeReplaceProvenance,
+  repairOrphanInboxSplices,
   repairSurfaceOps,
   rowToMeta,
   scanRows,
@@ -261,6 +262,9 @@ export class SessionPersistenceRdb
     this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
     // replace 的 provenance 读取时重计算（sourceEventSeqs 不落库）。
     recomputeReplaceProvenance(log.events);
+    // 孤儿 inbox splice（引用已被截断排队消息的插入/消费）会使上游 Inbox
+    // 增量重放失败、整个会话不可 resume——读取时改写为 no-op 修复。
+    repairOrphanInboxSplices(log.events);
     return {
       meta: log.meta,
       inheritedEventCount: SessionLogOffset(log.inheritedEventCount),

package/src/log.ts

@@ -90,6 +90,13 @@ export function remapShadowedRange(
   return { start: remap(range.start), end: remap(range.end) };
 }
 
+export function remapShadowedSeqs(
+  seqs: readonly number[],
+  remap: (seq: number) => number,
+): number[] {
+  return seqs.map(remap);
+}
+
 export function rowToEvent(row: EventRow, seqMap: ReadonlyMap<number, number>): SessionEvent {
   const remap = (seq: number): number => seqMap.get(seq) ?? seq;
   const surfaceOp =
@@ -97,12 +104,21 @@ export function rowToEvent(row: EventRow, seqMap: ReadonlyMap<number, number>):
       ? remapSurfaceOp(JSON.parse(row.fSurfaceOp) as SurfaceOp, remap)
       : undefined;
   const data = JSON.parse(row.fData) as SessionEvent["data"];
-  // compaction 事件的 shadowedRange 是插件合并字段，经结构化视图重映射。
+  // 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 } };
+    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, remap);
+    }
   }
   return {
     type: row.fType as SessionEvent["type"],
@@ -125,14 +141,38 @@ export function buildSeqMap(
 
 const SURFACE_EVENT_TYPES = new Set(["user/message", "assistant/message", "tool/result"]);
 
+const METERING_EVENT_TYPES = new Set(["compaction/summary", "compaction/prune"]);
+
+/**
+ * 读取时重计算 replace 的 sourceEventSeqs（sourceEventSeqs 不落库）。
+ *
+ * 优先采用紧邻 metering 事件（compaction/summary | compaction/prune）的
+ * shadowedSeqs：它是压缩事务落库的**权威被遮蔽节点列表**（range 只是首尾
+ * 边界对，压缩竞态下可能漏掉并发落地的节点——range 数值扫描会漏掉这些
+ * 节点，使上游 assertProvenance 报 missing）。shadowedSeqs 已由 rowToEvent
+ * 重映射到稠密坐标，与 replace 的 surfaceOp range 同空间。
+ *
+ * 无紧邻 metering 事件时回退到 range 数值扫描（历史数据 / 非压缩 replace，
+ * 如 tool-result pruner 的旧样式），保证既有行为不变。
+ */
 export function recomputeReplaceProvenance(events: SessionEvent[]): void {
-  for (const event of events) {
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i]!;
     const raw = event as SessionEvent & { surfaceOp?: unknown; sourceEventSeqs?: number[] };
     const op = raw.surfaceOp;
     if (typeof op !== "object" || op === null || (op as { op?: string }).op !== "replace") {
       continue;
     }
     const { start, end } = op as { start: number; end: number };
+    const metering = i > 0 ? events[i - 1] : undefined;
+    const meteringData =
+      metering !== undefined && METERING_EVENT_TYPES.has(metering.type)
+        ? (metering.data as unknown as { shadowedSeqs?: number[] })
+        : undefined;
+    if (meteringData?.shadowedSeqs !== undefined) {
+      raw.sourceEventSeqs = meteringData.shadowedSeqs;
+      continue;
+    }
     const refs: number[] = [];
     for (const candidate of events) {
       if (
@@ -283,6 +323,92 @@ export function repairSurfaceOps(events: SessionEvent[]): void {
   }
 }
 
+interface InboxSpliceLike {
+  target?: unknown;
+  start?: unknown;
+  removedCount?: unknown;
+  inserted?: Array<{ id?: unknown }>;
+}
+
+/**
+ * 定位无法从空状态增量重放的 agent/inbox/spliced 事件（孤儿操作）。
+ *
+ * 上游 Inbox 每次构造都从会话起点重放全部 inbox splice，失败即拒绝整个
+ * 会话（resume / 编辑重放不可用）。rewind 截断历史轮次后若残留 splice 引用
+ * 已被截断的排队消息（插入被删、消费保留，或反之），重放时越界或重复——
+ * 无法独立重放。
+ */
+export function orphanInboxSpliceSeqs(events: readonly SessionEvent[]): Set<number> {
+  const inbox: Record<string, Array<{ id: string }>> = { "next-turn": [], "next-step": [] };
+  const orphan = new Set<number>();
+  for (const raw of events) {
+    // agent/inbox/spliced 属 dsh-agent 类型扩展，不在本包 SessionEventMap——
+    // 用宽类型 duck-type 读取，避免判别联合窄化到 never。
+    const event = raw as unknown as { type: string; seq: number; data: InboxSpliceLike };
+    if (event.type !== "agent/inbox/spliced") continue;
+    const { target, start, removedCount, inserted } = event.data;
+    const list = typeof target === "string" ? inbox[target] : undefined;
+    if (list === undefined) {
+      orphan.add(event.seq);
+      continue;
+    }
+    const removed = removedCount ?? 0;
+    const parsedInserted = (inserted ?? []).map((m) => ({
+      id: typeof m.id === "string" ? m.id : "",
+    }));
+    if (
+      !Number.isSafeInteger(start as number) ||
+      (start as number) < 0 ||
+      (start as number) > list.length ||
+      !Number.isSafeInteger(removed as number) ||
+      (removed as number) < 0 ||
+      (start as number) + (removed as number) > list.length
+    ) {
+      orphan.add(event.seq);
+      continue;
+    }
+    const candidate = [
+      ...list.slice(0, start as number),
+      ...parsedInserted,
+      ...list.slice((start as number) + (removed as number)),
+    ];
+    const other = (target === "next-turn" ? inbox["next-step"] : inbox["next-turn"]) ?? [];
+    const seen = new Set<string>();
+    let dup = false;
+    for (const m of [...candidate, ...other]) {
+      if (m.id === "") continue;
+      if (seen.has(m.id)) {
+        dup = true;
+        break;
+      }
+      seen.add(m.id);
+    }
+    if (dup) {
+      orphan.add(event.seq);
+      continue;
+    }
+    list.splice(start as number, removed as number, ...parsedInserted);
+  }
+  return orphan;
+}
+
+/** 内存修复：把孤儿 inbox splice 改写为 no-op（调用方负责持久化）。 */
+export function repairOrphanInboxSplices(events: SessionEvent[]): void {
+  const orphan = orphanInboxSpliceSeqs(events);
+  if (orphan.size === 0) return;
+  for (const event of events) {
+    if (!orphan.has(event.seq)) continue;
+    const data = event.data as unknown as InboxSpliceLike;
+    const target = data.target;
+    (event as { data: unknown }).data = {
+      ...(typeof target === "string" ? { target } : { target: "next-turn" }),
+      start: 0,
+      removedCount: 0,
+      inserted: [],
+    };
+  }
+}
+
 export function scanRows(
   rows: readonly EventRow[],
   base = 0,

package/src/storage.ts

@@ -0,0 +1,5 @@
+// 存储引擎层：schema 常量/表定义、sqlite 后端（openDatabase / SqliteBackend）与
+// 并发写保护（WriteGuard）。文件物理分开，经本入口聚合导出。
+export * from "./schema.ts";
+export * from "./sqlite.ts";
+export * from "./write-guard.ts";