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

package/src/legacy.ts

@@ -1,43 +1,62 @@
-// 旧格式（v0/v1）历史数据读取转换：RDB 行 → v0/v1 物理记录 → 上游迁移链 →
-// v2 逻辑事件。RDB 写路径从不持久化 sourceEventSeqs（读取时重计算），且
+// 非当前格式（v0/v1/v2）历史数据读取转换：RDB 行 → 物理记录 → 上游迁移链 →
+// 当前逻辑事件。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 {
+  SESSION_FORMAT_VERSION,
+  type SessionEvent,
+  type SessionHeader,
+  type SessionId,
+} from "@deepseek-ai/dsh-session";
 import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
 import type { EventRow, SessionRow } from "./backend.ts";
+import { repairRequestHeaders, rowToMeta, scanRows } from "./log.ts";
 
-/** 重建 v0/v1 物理 header 记录（RDB 行 → 物理 JSON 对象）。 */
+/** 重建 v0/v1/v2 物理 header 记录（RDB 行 → 物理 JSON 对象）。 */
 function physicalHeader(row: SessionRow): Record<string, unknown> {
-  return {
+  const common = {
     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 物理 header 用 seedLength 表达继承前缀；v2 起改用 isSeeded，
+  // 前缀长度由 log 里的 session/end-seed 标记推导。
+  return row.fVersion < 2
+    ? { ...common, ...(row.fSeedLength !== null ? { seedLength: row.fSeedLength } : {}) }
+    : { ...common, isSeeded: row.fSeedLength !== null };
 }
 
-/** 重建一条 v0/v1 物理事件记录（桥接行 + 事件行 → 物理 JSON 对象）。 */
+/** 重建一条 v0/v1/v2 物理事件记录（桥接行 + 事件行 → 物理 JSON 对象）。 */
 function physicalEvent(row: EventRow): Record<string, unknown> {
+  const stored = JSON.parse(row.fData) as unknown;
+  // 两种存储形状：当前写入器落完整事件信封（与 JSONL 每行同构），schema v2
+  // 时代只落 data 部分。迁移链要的是 payload，故信封形状取 `data`。
+  const full =
+    typeof stored === "object" &&
+    stored !== null &&
+    !Array.isArray(stored) &&
+    typeof (stored as Record<string, unknown>)["type"] === "string" &&
+    "data" in (stored as Record<string, unknown>);
   return {
     type: row.fType,
     seq: row.fSequence,
     time: row.fCreatedAt,
-    data: JSON.parse(row.fData) as unknown,
+    data: full ? (stored as Record<string, unknown>)["data"] : stored,
     ...(row.fSurfaceOp !== null ? { surfaceOp: JSON.parse(row.fSurfaceOp) as unknown } : {}),
   };
 }
 
 /**
- * 把旧格式（v0/v1）行转换为 v2 逻辑事件与 header。
- * @param row - 会话行（f_version < 2）。
+ * 把非当前格式（v0/v1/v2）行转换为当前逻辑事件与 header。
+ * @param row - 会话行（f_version < SESSION_FORMAT_VERSION）。
  * @param eventRows - 已扫描保留的桥接行（稠密 seq，torn tail 已剔除）。
- * @returns v2 逻辑 header、继承前缀长度与事件。
+ * @returns 当前逻辑 header、继承前缀长度与事件。
  * @throws 迁移链拒绝（格式损坏 / 无法迁移）时原样抛出。
  */
 export function convertLegacyRows(
@@ -59,9 +78,51 @@ export function convertLegacyRows(
   };
 }
 
-/** 会话行是否携带旧格式（v0/v1）数据。 */
+/** 会话行是否携带非当前格式（f_version < SESSION_FORMAT_VERSION）数据。 */
 export function isLegacyVersion(version: number): boolean {
-  return version < 2;
+  return version < SESSION_FORMAT_VERSION;
+}
+
+/**
+ * 迁移链拒绝后，把旧格式行直接当**当前格式**事件视图采用。
+ *
+ * 旧写入器只在建会话时落一次 header version，之后跟随上游演进继续追加
+ * 事件——同一个 log 因此可能是混合世代（v0 时代的行 + 新版本字段），不是
+ * 任何单一已发布格式，严格迁移链必然拒绝。这些行的数据形状（消息包装、
+ * 类型名）已经是当前格式，只需 header 版本归一到当前、按稠密 seq 读取；
+ * 事件数据的补全与 surface 修复由读取视图修复（repairReadView）负责。
+ *
+ * 调用方须在此之后执行 `validateStoredEvents`：真正属于旧格式的类型
+ * （`assistant/chunk` / `compact/*` 等）仍会被 fail-loud 拒绝。
+ *
+ * @param row - 会话行（f_version < SESSION_FORMAT_VERSION）。
+ * @param eventRows - 该会话全部桥接行（按 f_sequence 升序）。
+ * @returns 当前格式 header（version 归一到 SESSION_FORMAT_VERSION）、收缩后的
+ *   继承前缀长度、稠密事件与可选 torn tail 起点。
+ * @throws scanRows 的已提交区损坏错误（seq gap / 不可解析行）。
+ */
+export function adoptLegacyRows(
+  row: SessionRow,
+  eventRows: readonly EventRow[],
+): {
+  meta: SessionHeader;
+  inheritedEventCount: number;
+  events: SessionEvent[];
+  tornFrom?: number;
+} {
+  const { preserved, tornFrom } = scanRows(eventRows, 0);
+  // 旧格式 request/header 归一为当前格式：v3 起 system prompt 由 surface 上的
+  // system/message 承载，header 必须省略 system / 空 tools / 空 adapterDefaults
+  // （上游事件校验 fail loud）。归一必须发生在调用方 `validateStoredEvents`
+  // 之前，否则整个会话加载失败。
+  repairRequestHeaders(preserved);
+  return {
+    meta: { ...rowToMeta(row), version: SESSION_FORMAT_VERSION },
+    // 继承前缀不得超过事件数（历史 rewind 未收缩的损坏样式），上游 load 判损坏。
+    inheritedEventCount: Math.min(row.fSeedLength ?? 0, preserved.length),
+    events: preserved,
+    ...(tornFrom !== undefined ? { tornFrom } : {}),
+  };
 }
 
 export type { SessionId };

package/src/log.ts

@@ -1,9 +1,30 @@
+import { SessionSeq } from "@deepseek-ai/dsh-session";
 import type { SessionEvent, SessionHeader, SessionId, SurfaceOp } 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";
 
+/**
+ * 把桥接行列里的 replace surfaceOp 归一到当前字段名。
+ *
+ * v2 时代落库的 JSON 用 `start`/`end`，当前格式用 `startSeq`/`endSeq`；
+ * 混合世代回退路径直接采用存储行，必须在此归一，否则上游 v3 surface 校验
+ * 以「invalid replace surfaceOp」拒绝整个会话。非 replace 形状原样返回，
+ * 由读取视图修复决定降级。
+ */
+function normalizeSurfaceOp(value: unknown): SurfaceOp {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value as SurfaceOp;
+  }
+  const record = value as Record<string, unknown>;
+  if (record["op"] !== "replace") return value as SurfaceOp;
+  const startSeq = record["startSeq"] ?? record["start"];
+  const endSeq = record["endSeq"] ?? record["end"];
+  if (typeof startSeq !== "number" || typeof endSeq !== "number") return value as SurfaceOp;
+  return { op: "replace", startSeq: SessionSeq(startSeq), endSeq: SessionSeq(endSeq) };
+}
+
 export function rowToMeta(row: SessionRow): SessionHeader {
   if (!Number.isSafeInteger(row.fCreatedAt) || row.fCreatedAt < 0) {
     throw new Error("stored session createdAt must be a non-negative safe integer");
@@ -76,7 +97,8 @@ export function sessionConflictRow(storage: SessionStorageMetadata): {
 }
 
 export function rowToEvent(row: EventRow): SessionEvent {
-  const surfaceOp = row.fSurfaceOp !== null ? (JSON.parse(row.fSurfaceOp) as SurfaceOp) : undefined;
+  const surfaceOp =
+    row.fSurfaceOp !== null ? normalizeSurfaceOp(JSON.parse(row.fSurfaceOp) as unknown) : undefined;
   const record = JSON.parse(row.fData) as unknown;
   // fData 形状判别：新写入的完整事件（含 ignorable 信封，与 JSONL 每行
   // 同构）vs 旧 v2 库的纯 data 部分。完整事件必有 type/seq/time/data 四键。
@@ -107,7 +129,12 @@ export function rowToEvent(row: EventRow): SessionEvent {
   } as SessionEvent;
 }
 
-const SURFACE_EVENT_TYPES = new Set(["user/message", "assistant/message", "tool/result"]);
+const SURFACE_EVENT_TYPES = new Set([
+  "system/message",
+  "user/message",
+  "assistant/message",
+  "tool/result",
+]);
 
 const METERING_EVENT_TYPES = new Set(["compaction/summary", "compaction/prune"]);
 
@@ -126,12 +153,12 @@ const METERING_EVENT_TYPES = new Set(["compaction/summary", "compaction/prune"])
 export function recomputeReplaceProvenance(events: SessionEvent[]): void {
   for (let i = 0; i < events.length; i++) {
     const event = events[i]!;
-    const raw = event as SessionEvent & { surfaceOp?: unknown; sourceEventSeqs?: number[] };
+    const raw = event as unknown as { 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 { startSeq, endSeq } = op as { startSeq: number; endSeq: number };
     const metering = i > 0 ? events[i - 1] : undefined;
     const meteringData =
       metering !== undefined && METERING_EVENT_TYPES.has(metering.type)
@@ -144,8 +171,8 @@ export function recomputeReplaceProvenance(events: SessionEvent[]): void {
     const refs: number[] = [];
     for (const candidate of events) {
       if (
-        candidate.seq >= start &&
-        candidate.seq <= end &&
+        candidate.seq >= startSeq &&
+        candidate.seq <= endSeq &&
         SURFACE_EVENT_TYPES.has(candidate.type)
       ) {
         refs.push(candidate.seq);
@@ -211,12 +238,15 @@ export function findSurfaceRepairs(events: readonly SessionEvent[]): {
   degradeToAppend: Set<number>;
   addAppendMarker: Set<number>;
   clearSurfaceOp: Set<number>;
+  clampEnd: Map<number, number>;
 } {
   const nodes: number[] = [];
   const degradeToAppend = new Set<number>();
   const addAppendMarker = new Set<number>();
   const clearSurfaceOp = new Set<number>();
-  for (const event of events) {
+  const clampEnd = new Map<number, number>();
+  for (let index = 0; index < events.length; index++) {
+    const event = events[index]!;
     const raw = event as SessionEvent & { surfaceOp?: unknown };
     const op = raw.surfaceOp;
     if (op === undefined) {
@@ -239,16 +269,29 @@ export function findSurfaceRepairs(events: readonly SessionEvent[]): {
       typeof op === "object" && op !== null && !Array.isArray(op)
         ? (op as Record<string, unknown>)
         : undefined;
-    const start = replace?.["start"];
-    const end = replace?.["end"];
+    const start = replace?.["startSeq"];
+    const end = replace?.["endSeq"];
     const shapeOk =
       replace !== undefined &&
       replace["op"] === "replace" &&
       isEventSeqLike(start) &&
       isEventSeqLike(end);
     const startIdx = shapeOk ? nodes.indexOf(start as number) : -1;
-    const endIdx = shapeOk ? nodes.indexOf(end as number) : -1;
+    let endIdx = shapeOk ? nodes.indexOf(end as number) : -1;
+    // 旧写入器重编号事件后，存储的 range 端点可能落在旧坐标空间：end 不在
+    // 当前 surface 中，但紧邻 metering 事件的 shadowedSeqs 仍给出被遮蔽
+    // 节点数量。按数量从 start 起夹取到当前 surface 的同长区间，保住压缩
+    // 语义（否则只能降级 append，被压缩历史全部回到派生历史）。
+    let clamped: number | undefined;
+    if (shapeOk && startIdx !== -1 && endIdx === -1) {
+      clamped = clampReplaceEnd(events, index, nodes, startIdx);
+      if (clamped !== undefined) endIdx = nodes.indexOf(clamped);
+    }
     const rangeOk = shapeOk && startIdx !== -1 && endIdx !== -1 && startIdx <= endIdx;
+    // assistant/message 的来源内嵌在 stream，上游禁止其携带 sourceEventSeqs，
+    // replace 的 provenance 因此永远无法满足 fold 校验——降级 append 是唯一
+    // 可加载形态。
+    const provenanceOk = event.type !== "assistant/message";
     let rewriteOk = true;
     if (rangeOk && event.type === "tool/result") {
       const shadowed = nodes.slice(startIdx, endIdx + 1);
@@ -260,14 +303,36 @@ export function findSurfaceRepairs(events: readonly SessionEvent[]): {
           original?.type === "tool/result" && toolResultRewriteContentOnly(original, event);
       }
     }
-    if (!rangeOk || !rewriteOk) {
+    if (!rangeOk || !rewriteOk || !provenanceOk) {
       degradeToAppend.add(event.seq);
       nodes.push(event.seq);
       continue;
     }
+    if (clamped !== undefined) clampEnd.set(event.seq, clamped);
     nodes.splice(startIdx, endIdx - startIdx + 1, event.seq);
   }
-  return { degradeToAppend, addAppendMarker, clearSurfaceOp };
+  return { degradeToAppend, addAppendMarker, clearSurfaceOp, clampEnd };
+}
+
+/**
+ * 夹取一个 end 落在旧坐标空间的 replace 的结尾。
+ *
+ * 仅当 replace 紧邻一个 metering 事件且其 `shadowedSeqs` 是权威数量时成立；
+ * 夹取点是从 `start` 起的第 `shadowedSeqs.length` 个当前 surface 节点（不足
+ * 则取当前 surface 末尾）。无法夹取（start 也不在当前 surface）时返回
+ * `undefined`，由调用方降级为 append。
+ */
+function clampReplaceEnd(
+  events: readonly SessionEvent[],
+  index: number,
+  nodes: readonly number[],
+  startIdx: number,
+): number | undefined {
+  const metering = index > 0 ? events[index - 1] : undefined;
+  if (metering === undefined || !METERING_EVENT_TYPES.has(metering.type)) return undefined;
+  const shadowedSeqs = (metering.data as unknown as { shadowedSeqs?: unknown }).shadowedSeqs;
+  if (!Array.isArray(shadowedSeqs) || shadowedSeqs.length === 0) return undefined;
+  return nodes[Math.min(startIdx + shadowedSeqs.length - 1, nodes.length - 1)];
 }
 
 export function repairSurfaceOps(events: SessionEvent[]): void {
@@ -275,14 +340,23 @@ export function repairSurfaceOps(events: SessionEvent[]): void {
   if (
     repairs.degradeToAppend.size === 0 &&
     repairs.addAppendMarker.size === 0 &&
-    repairs.clearSurfaceOp.size === 0
+    repairs.clearSurfaceOp.size === 0 &&
+    repairs.clampEnd.size === 0
   ) {
     return;
   }
   for (const event of events) {
     const raw = event as SessionEvent & { surfaceOp?: unknown };
+    const clamped = repairs.clampEnd.get(event.seq);
     if (repairs.degradeToAppend.has(event.seq)) {
       raw.surfaceOp = "append";
+    } else if (clamped !== undefined) {
+      const op = raw.surfaceOp as { startSeq: number };
+      raw.surfaceOp = {
+        op: "replace",
+        startSeq: SessionSeq(op.startSeq),
+        endSeq: SessionSeq(clamped),
+      };
     } else if (repairs.addAppendMarker.has(event.seq)) {
       raw.surfaceOp = "append";
     } else if (repairs.clearSurfaceOp.has(event.seq)) {
@@ -291,6 +365,173 @@ export function repairSurfaceOps(events: SessionEvent[]): void {
   }
 }
 
+/**
+ * 读取时补全 assistant 结算字段：旧写入器不落库 `stream`（v2 才把流式记录
+ * 嵌入消息），读回时缺失即补空数组——上游 seed 校验要求 turn/step/stream
+ * 三者齐备，缺失会让整个会话加载失败。
+ */
+export function repairAssistantSettlement(events: SessionEvent[]): void {
+  for (const event of events) {
+    if (event.type !== "assistant/message" && event.type !== "assistant/attempt") continue;
+    const data = event.data as unknown as Record<string, unknown>;
+    if (!Array.isArray(data["stream"])) data["stream"] = [];
+  }
+}
+
+/**
+ * 读取时把旧格式 `request/header` 归一为当前格式：v3 起 system prompt 由
+ * surface 上的 `system/message` 承载，header 必须省略 `system`，空 `tools` /
+ * `adapterDefaults` 也必须省略（上游 v3 事件校验 fail loud）。混合世代回退
+ * 视图直接采用存储行，不归一会让整个会话加载失败。system prompt 因此不再
+ * 进入模型请求；会话下次运行由 v3 的 system/message 机制重建。
+ */
+export function repairRequestHeaders(events: SessionEvent[]): void {
+  for (const event of events) {
+    if (event.type !== "request/header") continue;
+    const data = event.data as unknown as Record<string, unknown>;
+    const header = data["header"];
+    if (typeof header !== "object" || header === null || Array.isArray(header)) continue;
+    const record = header as Record<string, unknown>;
+    delete record["system"];
+    if (Array.isArray(record["tools"]) && record["tools"].length === 0) delete record["tools"];
+    const defaults = record["adapterDefaults"];
+    if (
+      typeof defaults === "object" &&
+      defaults !== null &&
+      !Array.isArray(defaults) &&
+      Object.keys(defaults).length === 0
+    ) {
+      delete record["adapterDefaults"];
+    }
+  }
+}
+
+/**
+ * 把紧邻 replace 的 metering 事件的 `shadowedRange` / `shadowedSeqs` 对齐到
+ * replace 最终的稠密 range。
+ *
+ * 旧写入器重编号事件后，metering 与 replace 一起落在旧坐标空间：二者数值
+ * 相等但与当前 surface 无关。夹取（或 range 本身已落在稠密空间而 metering
+ * 仍是旧值）后二者不再相等，而上游 token-meter 契约要求紧邻的 metering
+ * range 与 replace range 完全一致（否则报 no adjacent shadow price）。range
+ * 已一致时不改写——当前写入器保证一致，shadowedSeqs 的额外并发节点因此
+ * 原样保留。
+ */
+export function syncMeteringRanges(events: SessionEvent[]): void {
+  for (let i = 1; i < events.length; i++) {
+    const metering = events[i - 1]!;
+    if (!METERING_EVENT_TYPES.has(metering.type)) continue;
+    const event = events[i]!;
+    const op = (event as SessionEvent & { surfaceOp?: unknown }).surfaceOp;
+    if (typeof op !== "object" || op === null || (op as { op?: string }).op !== "replace") continue;
+    const { startSeq, endSeq } = op as { startSeq: number; endSeq: number };
+    const data = metering.data as unknown as {
+      shadowedRange?: { start: number; end: number };
+      shadowedSeqs?: number[];
+    };
+    if (data.shadowedRange?.start === startSeq && data.shadowedRange.end === endSeq) continue;
+    data.shadowedRange = { start: startSeq, end: endSeq };
+    data.shadowedSeqs = events
+      .filter(
+        (candidate) =>
+          candidate.seq >= startSeq &&
+          candidate.seq <= endSeq &&
+          SURFACE_EVENT_TYPES.has(candidate.type),
+      )
+      .map((candidate) => candidate.seq);
+  }
+}
+
+const PTC_EVENT_RENAMES: Record<string, string> = {
+  "tool/code-dispatch-start": "tool/ptc-dispatch-start",
+  "tool/code-dispatch": "tool/ptc-dispatch",
+};
+
+/** 把消息的 `tools-code-mode` 插件来源改写为 `tools-ptc`（非该来源原样返回）。 */
+function renamePtcMessageSource(message: unknown): unknown {
+  if (typeof message !== "object" || message === null || Array.isArray(message)) return message;
+  const record = message as Record<string, unknown>;
+  const source = record["source"];
+  if (typeof source !== "object" || source === null || Array.isArray(source)) return message;
+  const sourceRecord = source as Record<string, unknown>;
+  if (sourceRecord["kind"] !== "plugin" || sourceRecord["plugin"] !== "tools-code-mode") {
+    return message;
+  }
+  return { ...record, source: { ...sourceRecord, plugin: "tools-ptc" } };
+}
+
+/** 宽类型事件视图：PTC 词汇归一涉及本包 SessionEventMap 之外的插件类型。 */
+interface LegacyPtcEvent {
+  type: string;
+  data: unknown;
+  [key: string]: unknown;
+}
+
+/**
+ * 读取时把 v2 时代的 PTC 词汇归一为当前词汇。
+ *
+ * 上游 v2→v3 迁移把 `tool/code-dispatch(-start)` 改名为
+ * `tool/ptc-dispatch(-start)`、把 `tools-code-mode` 插件来源改名为 `tools-ptc`、
+ * 把 agent preset 值 `code` 改名为 `ptc`。混合世代回退视图直接采用存储行，
+ * 不重命名会被上游 v3 校验以「unknown event type」拒绝整个会话。词汇改写
+ * 与上游迁移链的 renamePtcEvent 对齐。
+ */
+export function renameLegacyPtcEvents(events: SessionEvent[]): void {
+  for (let index = 0; index < events.length; index++) {
+    const event = events[index] as unknown as LegacyPtcEvent;
+    const renamedType = PTC_EVENT_RENAMES[event.type];
+    if (renamedType !== undefined) {
+      events[index] = { ...event, type: renamedType } as unknown as SessionEvent;
+      continue;
+    }
+    if (event.type === "agent-preset/selected") {
+      const data = event.data as Record<string, unknown>;
+      if (data["agentPreset"] === "code") {
+        events[index] = {
+          ...event,
+          data: { ...data, agentPreset: "ptc" },
+        } as unknown as SessionEvent;
+      }
+      continue;
+    }
+    if (event.type === "user/message") {
+      const renamed = renamePtcMessageSource(event.data);
+      if (renamed !== event.data) {
+        events[index] = { ...event, data: renamed } as unknown as SessionEvent;
+      }
+      continue;
+    }
+    if (event.type === "agent/inbox/spliced" || event.type === "session/title-llm-request") {
+      const data = event.data as Record<string, unknown>;
+      const key = event.type === "agent/inbox/spliced" ? "inserted" : "messages";
+      const list = data[key];
+      if (!Array.isArray(list)) continue;
+      const renamed = list.map(renamePtcMessageSource);
+      if (renamed.some((message, position) => message !== list[position])) {
+        events[index] = {
+          ...event,
+          data: { ...data, [key]: renamed },
+        } as unknown as SessionEvent;
+      }
+    }
+  }
+}
+
+/**
+ * 读取视图修复总入口：形状补全（结算字段 / request header）→ PTC 词汇归一
+ * → surface 语义修复 → metering 对齐 → provenance 重算 → 孤儿 inbox splice
+ * 改写。全部只作用于内存视图，不落库。
+ */
+export function repairReadView(events: SessionEvent[]): void {
+  repairAssistantSettlement(events);
+  repairRequestHeaders(events);
+  renameLegacyPtcEvents(events);
+  repairSurfaceOps(events);
+  syncMeteringRanges(events);
+  recomputeReplaceProvenance(events);
+  repairOrphanInboxSplices(events);
+}
+
 interface InboxSpliceLike {
   target?: unknown;
   start?: unknown;

package/src/testing/contract.ts

@@ -535,7 +535,7 @@ export function runPersistenceContract(name: string, make: () => Promise<Contrac
         const m = meta("foreign-vocabulary");
         const handle = await persistence.create(m);
         await handle.append(oneTurnLog());
-        // 写路径 v2 校验：未知类型（非 ignorable）拒绝入库，批次不落库。
+        // 写路径当前格式校验：未知类型（非 ignorable）拒绝入库，批次不落库。
         await expect(
           handle.append([
             { type: "mystery/event", seq: SessionSeq(6), time: 7, data: { payload: true } },