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

package/dist/artifact.d.mts

@@ -45,8 +45,32 @@ declare function findSurfaceRepairs(events: readonly SessionEvent[]): {
   degradeToAppend: Set<number>;
   addAppendMarker: Set<number>;
   clearSurfaceOp: Set<number>;
+  clampEnd: Map<number, number>;
 };
 declare function repairSurfaceOps(events: SessionEvent[]): void;
+/**
+ * 读取时补全 assistant 结算字段：旧写入器不落库 `stream`（v2 才把流式记录
+ * 嵌入消息），读回时缺失即补空数组——上游 seed 校验要求 turn/step/stream
+ * 三者齐备，缺失会让整个会话加载失败。
+ */
+declare function repairAssistantSettlement(events: SessionEvent[]): void;
+/**
+ * 把紧邻 replace 的 metering 事件的 `shadowedRange` / `shadowedSeqs` 对齐到
+ * replace 最终的稠密 range。
+ *
+ * 旧写入器重编号事件后，metering 与 replace 一起落在旧坐标空间：二者数值
+ * 相等但与当前 surface 无关。夹取（或 range 本身已落在稠密空间而 metering
+ * 仍是旧值）后二者不再相等，而上游 token-meter 契约要求紧邻的 metering
+ * range 与 replace range 完全一致（否则报 no adjacent shadow price）。range
+ * 已一致时不改写——当前写入器保证一致，shadowedSeqs 的额外并发节点因此
+ * 原样保留。
+ */
+declare function syncMeteringRanges(events: SessionEvent[]): void;
+/**
+ * 读取视图修复总入口：结算字段补全 → surface 语义修复 → metering 对齐 →
+ * provenance 重算 → 孤儿 inbox splice 改写。全部只作用于内存视图，不落库。
+ */
+declare function repairReadView(events: SessionEvent[]): void;
 /**
  * 定位无法从空状态增量重放的 agent/inbox/spliced 事件（孤儿操作）。
  *
@@ -64,4 +88,4 @@ declare function scanRows(rows: readonly EventRow[], base?: number): {
 };
 declare function toJsonlArtifact(meta: SessionHeader, inheritedEventCount: number, events: readonly SessionEvent[]): string;
 //#endregion
-export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, repairOrphanInboxSplices, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, toJsonlArtifact };
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, repairAssistantSettlement, repairOrphanInboxSplices, repairReadView, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, syncMeteringRanges, toJsonlArtifact };

package/dist/artifact.mjs

@@ -1,3 +1,3 @@
-import { a as repairSurfaceOps, c as scanRows, d as toJsonlArtifact, i as repairOrphanInboxSplices, l as sessionConflictRow, n as orphanInboxSpliceSeqs, o as rowToEvent, r as recomputeReplaceProvenance, s as rowToMeta, t as findSurfaceRepairs, u as sessionInsertRow } from "./log-DTJsxMud.mjs";
-import { a as persistImport, i as parseJsonlArtifact, n as SESSION_LOG_ARTIFACT_FILENAME, o as registerSessionImport, r as parseImportZip, t as SESSION_IMPORT_PATH } from "./import-CKrzjXVB.mjs";
-export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, repairOrphanInboxSplices, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, toJsonlArtifact };
+import { a as repairOrphanInboxSplices, c as rowToEvent, d as sessionConflictRow, f as sessionInsertRow, i as repairAssistantSettlement, l as rowToMeta, m as toJsonlArtifact, n as orphanInboxSpliceSeqs, o as repairReadView, p as syncMeteringRanges, r as recomputeReplaceProvenance, s as repairSurfaceOps, t as findSurfaceRepairs, u as scanRows } from "./log-DBFUBPhv.mjs";
+import { a as persistImport, i as parseJsonlArtifact, n as SESSION_LOG_ARTIFACT_FILENAME, o as registerSessionImport, r as parseImportZip, t as SESSION_IMPORT_PATH } from "./import-mZZgDBLd.mjs";
+export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, findSurfaceRepairs, orphanInboxSpliceSeqs, parseImportZip, parseJsonlArtifact, persistImport, recomputeReplaceProvenance, registerSessionImport, repairAssistantSettlement, repairOrphanInboxSplices, repairReadView, repairSurfaceOps, rowToEvent, rowToMeta, scanRows, sessionConflictRow, sessionInsertRow, syncMeteringRanges, toJsonlArtifact };

package/dist/{import-CKrzjXVB.mjs → import-mZZgDBLd.mjs}

@@ -1,4 +1,4 @@
-import { s as rowToMeta } from "./log-DTJsxMud.mjs";
+import { l as rowToMeta } from "./log-DBFUBPhv.mjs";
 import { randomUUID } from "node:crypto";
 import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
 import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";

package/dist/import.d.mts

@@ -1,4 +1,4 @@
-import { n as SessionPersistenceRdb } from "./index-CgGDHQSK.mjs";
+import { n as SessionPersistenceRdb } from "./index-GdKkSSb-.mjs";
 import { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
 import { Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
 import { Context } from "@deepseek-ai/cordis";

package/dist/import.mjs

@@ -1,2 +1,2 @@
-import { a as persistImport, i as parseJsonlArtifact, n as SESSION_LOG_ARTIFACT_FILENAME, o as registerSessionImport, r as parseImportZip, t as SESSION_IMPORT_PATH } from "./import-CKrzjXVB.mjs";
+import { a as persistImport, i as parseJsonlArtifact, n as SESSION_LOG_ARTIFACT_FILENAME, o as registerSessionImport, r as parseImportZip, t as SESSION_IMPORT_PATH } from "./import-mZZgDBLd.mjs";
 export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport };

package/dist/{index-CgGDHQSK.d.mts → index-GdKkSSb-.d.mts}

@@ -196,7 +196,21 @@ declare class SessionPersistenceRdb extends SessionPersistence {
     tornFrom?: number;
     incarnation: string;
     revision: number;
+    /** 存储桥接行数（迁移链可能生成/合并事件，与 `events.length` 不同）。 */
+    storedCount: number;
+    /** 是否经上游迁移链转换（v0/v1 → 当前格式）。 */
+    migrated: boolean;
   } | undefined>;
+  /**
+   * 把迁移链读出的 v2 视图整体落库（旧格式会话写打开时的一次性迁移）。
+   *
+   * 迁移链会生成/合并事件（end-seed / attempt / chunk 合并），事件 seq 空间
+   * 与存储桥接行数不再相等；写路径以存储 head 为锚点重编号，二者不一致会让
+   * append 撞上已有行。这里在同一事务内删光本会话桥接行、按迁移视图重建
+   * （新事件行，完整信封），并更新 head 与 revision；旧事件行保留（可能被
+   * fork 子会话引用，孤儿由惰性 GC 处理）。
+   */
+  private rewriteMigratedLog;
   listSnapshots(signal?: AbortSignal): Promise<Array<SessionPersistenceSnapshot & {
     inheritedEventCount: number;
   }>>;

package/dist/index.d.mts

@@ -1,3 +1,3 @@
 import { o as SCHEMA_VERSION } from "./schema-COK7-wRV.mjs";
-import { a as SessionBranchRdbProvider, i as SessionBranchRdb, n as SessionPersistenceRdb, o as locateTurnEnd, r as SessionPersistenceRdbInternals, t as Config } from "./index-CgGDHQSK.mjs";
+import { a as SessionBranchRdbProvider, i as SessionBranchRdb, n as SessionPersistenceRdb, o as locateTurnEnd, r as SessionPersistenceRdbInternals, t as Config } from "./index-GdKkSSb-.mjs";
 export { Config, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, SessionPersistenceRdbInternals, locateTurnEnd };

package/dist/index.mjs

@@ -1,12 +1,12 @@
-import { a as SCHEMA_VERSION, g as WriteGuard, h as toPostgresSchema, i as EVENT_ENCODING, m as postgresTableDefs, r as DEFAULT_BUSY_TIMEOUT_MS, s as eventDimensions, t as SqliteBackend } from "./sqlite-DCy4VTD8.mjs";
-import { a as repairSurfaceOps, c as scanRows, d as toJsonlArtifact, i as repairOrphanInboxSplices, l as sessionConflictRow, r as recomputeReplaceProvenance, s as rowToMeta, u as sessionInsertRow } from "./log-DTJsxMud.mjs";
-import { c as SessionBranchRdbProvider, l as locateTurnEnd, o as registerSessionImport, s as SessionBranchRdb } from "./import-CKrzjXVB.mjs";
+import { a as SCHEMA_VERSION, g as WriteGuard, h as toPostgresSchema, i as EVENT_ENCODING, m as postgresTableDefs, r as DEFAULT_BUSY_TIMEOUT_MS, s as eventDimensions, t as SqliteBackend } from "./sqlite-CnWwGToZ.mjs";
+import { d as sessionConflictRow, f as sessionInsertRow, l as rowToMeta, m as toJsonlArtifact, o as repairReadView, u as scanRows } from "./log-DBFUBPhv.mjs";
+import { c as SessionBranchRdbProvider, l as locateTurnEnd, o as registerSessionImport, s as SessionBranchRdb } from "./import-mZZgDBLd.mjs";
 import z from "@deepseek-ai/schemastery";
 import { randomUUID } from "node:crypto";
 import { Pool } from "pg";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionHandleClosedError, SessionPersistence, SessionPersistenceNotFoundError, SessionPersistenceRevision, SessionReadOnlyError, assertContiguous, assertVersion, materializeAppendBatch, materializeCreateHeader, validateStoredEvents } from "@deepseek-ai/dsh-session-persistence";
-import { SessionLogOffset } from "@deepseek-ai/dsh-session";
+import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
 import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
 import { and, eq, gte, sql } from "drizzle-orm";
 import { readdirSync } from "node:fs";
@@ -209,6 +209,36 @@ function convertLegacyRows(row, eventRows) {
 function isLegacyVersion(version) {
 	return version < 2;
 }
+/**
+* 迁移链拒绝后，把旧格式行直接当**当前格式**事件视图采用。
+*
+* 旧写入器只在建会话时落一次 header version，之后跟随上游演进继续追加
+* 事件——同一个 log 因此可能是混合世代（v0 时代的行 + 新版本字段），不是
+* 任何单一已发布格式，严格迁移链必然拒绝。这些行的数据形状（消息包装、
+* 类型名）已经是当前格式，只需 header 版本归一到当前、按稠密 seq 读取；
+* 事件数据的补全与 surface 修复由读取视图修复（repairReadView）负责。
+*
+* 调用方须在此之后执行 `validateStoredEvents`：真正属于旧格式的类型
+* （`assistant/chunk` / `compact/*` 等）仍会被 fail-loud 拒绝。
+*
+* @param row - 会话行（f_version < 2）。
+* @param eventRows - 该会话全部桥接行（按 f_sequence 升序）。
+* @returns 当前格式 header（version 归一到 SESSION_FORMAT_VERSION）、收缩后的
+*   继承前缀长度、稠密事件与可选 torn tail 起点。
+* @throws scanRows 的已提交区损坏错误（seq gap / 不可解析行）。
+*/
+function adoptLegacyRows(row, eventRows) {
+	const { preserved, tornFrom } = scanRows(eventRows, 0);
+	return {
+		meta: {
+			...rowToMeta(row),
+			version: SESSION_FORMAT_VERSION
+		},
+		inheritedEventCount: Math.min(row.fSeedLength ?? 0, preserved.length),
+		events: preserved,
+		...tornFrom !== void 0 ? { tornFrom } : {}
+	};
+}
 //#endregion
 //#region src/index.ts
 /** 会话级写所有权与 live 路由簿记。 */
@@ -352,9 +382,7 @@ var RdbSessionHandle = class RdbSessionHandle {
 			};
 			throw new SessionPersistenceNotFoundError(this.id);
 		}
-		repairSurfaceOps(log.events);
-		recomputeReplaceProvenance(log.events);
-		repairOrphanInboxSplices(log.events);
+		repairReadView(log.events);
 		return {
 			eventState: "detached",
 			events: log.events.slice(offset, offset + length)
@@ -567,6 +595,7 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 			const log = await this.readLog(id, {}, options?.signal);
 			if (log === void 0) throw new SessionPersistenceNotFoundError(id);
 			validateStoredEvents(log.meta, log.events);
+			if (log.migrated && log.events.length !== log.storedCount) await this.rewriteMigratedLog(id, log);
 			this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
 			return this.tracker.adopt(new RdbSessionHandle(this, id, log.meta, "write", {
 				cursor: log.events.length,
@@ -630,8 +659,7 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		signal?.throwIfAborted();
 		const log = await this.readLog(id, {}, signal);
 		if (log === void 0) return void 0;
-		repairSurfaceOps(log.events);
-		recomputeReplaceProvenance(log.events);
+		repairReadView(log.events);
 		const inheritedEventCount = Math.min(log.inheritedEventCount, log.events.length);
 		return {
 			meta: log.meta,
@@ -699,14 +727,29 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		const meta = rowToMeta(row);
 		const eventRows = options.fromSeq === void 0 ? await this.backend.getEventRows(id) : await this.backend.getEventRows(id, options.fromSeq);
 		signal?.throwIfAborted();
-		if (isLegacyVersion(row.fVersion)) {
+		if (isLegacyVersion(row.fVersion)) try {
 			const converted = convertLegacyRows(row, eventRows);
 			return {
 				meta: converted.meta,
 				inheritedEventCount: converted.inheritedEventCount,
 				events: converted.events,
 				incarnation: row.fIncarnation,
-				revision: row.fRevision
+				revision: row.fRevision,
+				storedCount: eventRows.length,
+				migrated: true
+			};
+		} catch (error) {
+			this.ctx.logger.warn(`session-rdb: session "${id}" is not a single released format; adopting its stored rows as current-format data (${error instanceof Error ? error.message : String(error)})`);
+			const adopted = adoptLegacyRows(row, eventRows);
+			return {
+				meta: adopted.meta,
+				inheritedEventCount: adopted.inheritedEventCount,
+				events: adopted.events,
+				incarnation: row.fIncarnation,
+				revision: row.fRevision,
+				storedCount: eventRows.length,
+				migrated: false,
+				...adopted.tornFrom !== void 0 ? { tornFrom: adopted.tornFrom } : {}
 			};
 		}
 		const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0);
@@ -716,9 +759,35 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 			events: preserved,
 			incarnation: row.fIncarnation,
 			revision: row.fRevision,
+			storedCount: eventRows.length,
+			migrated: false,
 			...tornFrom !== void 0 ? { tornFrom } : {}
 		};
 	}
+	/**
+	* 把迁移链读出的 v2 视图整体落库（旧格式会话写打开时的一次性迁移）。
+	*
+	* 迁移链会生成/合并事件（end-seed / attempt / chunk 合并），事件 seq 空间
+	* 与存储桥接行数不再相等；写路径以存储 head 为锚点重编号，二者不一致会让
+	* append 撞上已有行。这里在同一事务内删光本会话桥接行、按迁移视图重建
+	* （新事件行，完整信封），并更新 head 与 revision；旧事件行保留（可能被
+	* fork 子会话引用，孤儿由惰性 GC 处理）。
+	*/
+	async rewriteMigratedLog(id, log) {
+		await this.backend.transaction(async (tx) => {
+			await tx.deleteBridgeTail(id, 0);
+			await tx.upsertSession({
+				meta: log.meta,
+				inheritedEventCount: SessionLogOffset(log.inheritedEventCount)
+			}, randomUUID());
+			const { headEventId, headSequence } = await appendEventTail(tx, log.meta, log.events, {
+				parentId: "",
+				nextSeq: 0
+			});
+			await tx.updateHead(id, headEventId, headSequence);
+			await tx.bumpRevision(id);
+		});
+	}
 	async listSnapshots(signal) {
 		signal?.throwIfAborted();
 		await this.ready;
@@ -904,6 +973,7 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 			if (stored.meta.cwd !== session.header.cwd) throw new Error(`session "${id}" is already persisted at a different cwd (persisted: ${String(stored.meta.cwd)}, live: ${String(session.header.cwd)}) (id collision)`);
 			if (stored.inheritedEventCount !== session.inheritedEventCount) throw new Error(`session "${id}" is already persisted with a different inherited event count (id collision)`);
 			assertVersion(stored.meta);
+			repairReadView(stored.events);
 			const seed = session.snapshotEvents();
 			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)`);
 			handle = await this.open(id, "write");

package/dist/{log-DTJsxMud.mjs → log-DBFUBPhv.mjs}

@@ -142,7 +142,9 @@ function findSurfaceRepairs(events) {
 	const degradeToAppend = /* @__PURE__ */ new Set();
 	const addAppendMarker = /* @__PURE__ */ new Set();
 	const clearSurfaceOp = /* @__PURE__ */ new Set();
-	for (const event of events) {
+	const clampEnd = /* @__PURE__ */ new Map();
+	for (let index = 0; index < events.length; index++) {
+		const event = events[index];
 		const op = event.surfaceOp;
 		if (op === void 0) {
 			if (SURFACE_EVENT_TYPES.has(event.type)) {
@@ -165,7 +167,12 @@ function findSurfaceRepairs(events) {
 		const end = replace?.["end"];
 		const shapeOk = replace !== void 0 && replace["op"] === "replace" && isEventSeqLike(start) && isEventSeqLike(end);
 		const startIdx = shapeOk ? nodes.indexOf(start) : -1;
-		const endIdx = shapeOk ? nodes.indexOf(end) : -1;
+		let endIdx = shapeOk ? nodes.indexOf(end) : -1;
+		let clamped;
+		if (shapeOk && startIdx !== -1 && endIdx === -1) {
+			clamped = clampReplaceEnd(events, index, nodes, startIdx);
+			if (clamped !== void 0) endIdx = nodes.indexOf(clamped);
+		}
 		const rangeOk = shapeOk && startIdx !== -1 && endIdx !== -1 && startIdx <= endIdx;
 		let rewriteOk = true;
 		if (rangeOk && event.type === "tool/result") {
@@ -181,25 +188,98 @@ function findSurfaceRepairs(events) {
 			nodes.push(event.seq);
 			continue;
 		}
+		if (clamped !== void 0) clampEnd.set(event.seq, clamped);
 		nodes.splice(startIdx, endIdx - startIdx + 1, event.seq);
 	}
 	return {
 		degradeToAppend,
 		addAppendMarker,
-		clearSurfaceOp
+		clearSurfaceOp,
+		clampEnd
 	};
 }
+/**
+* 夹取一个 end 落在旧坐标空间的 replace 的结尾。
+*
+* 仅当 replace 紧邻一个 metering 事件且其 `shadowedSeqs` 是权威数量时成立；
+* 夹取点是从 `start` 起的第 `shadowedSeqs.length` 个当前 surface 节点（不足
+* 则取当前 surface 末尾）。无法夹取（start 也不在当前 surface）时返回
+* `undefined`，由调用方降级为 append。
+*/
+function clampReplaceEnd(events, index, nodes, startIdx) {
+	const metering = index > 0 ? events[index - 1] : void 0;
+	if (metering === void 0 || !METERING_EVENT_TYPES.has(metering.type)) return void 0;
+	const shadowedSeqs = metering.data.shadowedSeqs;
+	if (!Array.isArray(shadowedSeqs) || shadowedSeqs.length === 0) return void 0;
+	return nodes[Math.min(startIdx + shadowedSeqs.length - 1, nodes.length - 1)];
+}
 function repairSurfaceOps(events) {
 	const repairs = findSurfaceRepairs(events);
-	if (repairs.degradeToAppend.size === 0 && repairs.addAppendMarker.size === 0 && repairs.clearSurfaceOp.size === 0) return;
+	if (repairs.degradeToAppend.size === 0 && repairs.addAppendMarker.size === 0 && repairs.clearSurfaceOp.size === 0 && repairs.clampEnd.size === 0) return;
 	for (const event of events) {
 		const raw = event;
+		const clamped = repairs.clampEnd.get(event.seq);
 		if (repairs.degradeToAppend.has(event.seq)) raw.surfaceOp = "append";
+		else if (clamped !== void 0) raw.surfaceOp = {
+			op: "replace",
+			start: raw.surfaceOp.start,
+			end: clamped
+		};
 		else if (repairs.addAppendMarker.has(event.seq)) raw.surfaceOp = "append";
 		else if (repairs.clearSurfaceOp.has(event.seq)) delete raw.surfaceOp;
 	}
 }
 /**
+* 读取时补全 assistant 结算字段：旧写入器不落库 `stream`（v2 才把流式记录
+* 嵌入消息），读回时缺失即补空数组——上游 seed 校验要求 turn/step/stream
+* 三者齐备，缺失会让整个会话加载失败。
+*/
+function repairAssistantSettlement(events) {
+	for (const event of events) {
+		if (event.type !== "assistant/message" && event.type !== "assistant/attempt") continue;
+		const data = event.data;
+		if (!Array.isArray(data["stream"])) data["stream"] = [];
+	}
+}
+/**
+* 把紧邻 replace 的 metering 事件的 `shadowedRange` / `shadowedSeqs` 对齐到
+* replace 最终的稠密 range。
+*
+* 旧写入器重编号事件后，metering 与 replace 一起落在旧坐标空间：二者数值
+* 相等但与当前 surface 无关。夹取（或 range 本身已落在稠密空间而 metering
+* 仍是旧值）后二者不再相等，而上游 token-meter 契约要求紧邻的 metering
+* range 与 replace range 完全一致（否则报 no adjacent shadow price）。range
+* 已一致时不改写——当前写入器保证一致，shadowedSeqs 的额外并发节点因此
+* 原样保留。
+*/
+function syncMeteringRanges(events) {
+	for (let i = 1; i < events.length; i++) {
+		const metering = events[i - 1];
+		if (!METERING_EVENT_TYPES.has(metering.type)) continue;
+		const op = events[i].surfaceOp;
+		if (typeof op !== "object" || op === null || op.op !== "replace") continue;
+		const { start, end } = op;
+		const data = metering.data;
+		if (data.shadowedRange?.start === start && data.shadowedRange.end === end) continue;
+		data.shadowedRange = {
+			start,
+			end
+		};
+		data.shadowedSeqs = events.filter((candidate) => candidate.seq >= start && candidate.seq <= end && SURFACE_EVENT_TYPES.has(candidate.type)).map((candidate) => candidate.seq);
+	}
+}
+/**
+* 读取视图修复总入口：结算字段补全 → surface 语义修复 → metering 对齐 →
+* provenance 重算 → 孤儿 inbox splice 改写。全部只作用于内存视图，不落库。
+*/
+function repairReadView(events) {
+	repairAssistantSettlement(events);
+	repairSurfaceOps(events);
+	syncMeteringRanges(events);
+	recomputeReplaceProvenance(events);
+	repairOrphanInboxSplices(events);
+}
+/**
 * 定位无法从空状态增量重放的 agent/inbox/spliced 事件（孤儿操作）。
 *
 * 上游 Inbox 每次构造都从会话起点重放全部 inbox splice，失败即拒绝整个
@@ -311,4 +391,4 @@ function toJsonlArtifact(meta, inheritedEventCount, events) {
 	return lines.join("\n");
 }
 //#endregion
-export { repairSurfaceOps as a, scanRows as c, toJsonlArtifact as d, repairOrphanInboxSplices as i, sessionConflictRow as l, orphanInboxSpliceSeqs as n, rowToEvent as o, recomputeReplaceProvenance as r, rowToMeta as s, findSurfaceRepairs as t, sessionInsertRow as u };
+export { repairOrphanInboxSplices as a, rowToEvent as c, sessionConflictRow as d, sessionInsertRow as f, repairAssistantSettlement as i, rowToMeta as l, toJsonlArtifact as m, orphanInboxSpliceSeqs as n, repairReadView as o, syncMeteringRanges as p, recomputeReplaceProvenance as r, repairSurfaceOps as s, findSurfaceRepairs as t, scanRows as u };

package/dist/{sqlite-DCy4VTD8.mjs → sqlite-CnWwGToZ.mjs}

@@ -1,4 +1,4 @@
-import { l as sessionConflictRow, u as sessionInsertRow } from "./log-DTJsxMud.mjs";
+import { d as sessionConflictRow, f as sessionInsertRow } from "./log-DBFUBPhv.mjs";
 import { randomUUID } from "node:crypto";
 import { and, eq, gte, sql } from "drizzle-orm";
 import { check, index, integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";

package/dist/storage.mjs

@@ -1,2 +1,2 @@
-import { a as SCHEMA_VERSION, c as eventKind, d as tSchemaMeta, f as tSessionEvents, g as WriteGuard, i as EVENT_ENCODING, l as tEvents, n as openDatabase, o as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, p as tSessions, r as DEFAULT_BUSY_TIMEOUT_MS, s as eventDimensions, t as SqliteBackend, u as tPersistenceState } from "./sqlite-DCy4VTD8.mjs";
+import { a as SCHEMA_VERSION, c as eventKind, d as tSchemaMeta, f as tSessionEvents, g as WriteGuard, i as EVENT_ENCODING, l as tEvents, n as openDatabase, o as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, p as tSessions, r as DEFAULT_BUSY_TIMEOUT_MS, s as eventDimensions, t as SqliteBackend, u as tPersistenceState } from "./sqlite-CnWwGToZ.mjs";
 export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, SqliteBackend, WriteGuard, eventDimensions, eventKind, openDatabase, tEvents, tPersistenceState, tSchemaMeta, tSessionEvents, tSessions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/session-rdb",
-  "version": "0.0.16-alpha.0",
+  "version": "0.0.16-alpha.1",
   "description": "RDB durable session backend for DeepSeek Harness: implements both session-persistence and session-branch (rewind / retry / fork) providers.",
   "keywords": [
     "branch",
@@ -35,7 +35,7 @@
     "./cordis.patch.yml": "./cordis.patch.yml"
   },
   "dependencies": {
-    "@morlay/session-branch": "^0.0.4-alpha.0",
+    "@morlay/session-branch": "^0.0.4-alpha.1",
     "drizzle-orm": "^1.0.0-rc.5-ab785fc",
     "fflate": "^0.8.2",
     "pg": "^8.23.0"

package/src/index.ts

@@ -39,14 +39,7 @@ import {
 } from "@deepseek-ai/dsh-session";
 import { type Backend, type BackendTx, type EventInsert } from "./backend.ts";
 import { WriteGuard } from "./write-guard.ts";
-import {
-  recomputeReplaceProvenance,
-  repairOrphanInboxSplices,
-  repairSurfaceOps,
-  rowToMeta,
-  scanRows,
-  toJsonlArtifact,
-} from "./log.ts";
+import { repairReadView, rowToMeta, scanRows, toJsonlArtifact } from "./log.ts";
 import {
   DEFAULT_BUSY_TIMEOUT_MS,
   eventDimensions,
@@ -57,7 +50,7 @@ import { SqliteBackend } from "./sqlite.ts";
 import { PostgresBackend } from "./postgres.ts";
 import { SessionBranchRdb } from "./branch.ts";
 import { registerSessionImport } from "./import.ts";
-import { convertLegacyRows, isLegacyVersion } from "./legacy.ts";
+import { adoptLegacyRows, convertLegacyRows, isLegacyVersion } from "./legacy.ts";
 
 export { SCHEMA_VERSION } from "./schema.ts";
 export { SessionBranchRdb, SessionBranchRdbProvider, locateTurnEnd } from "./branch.ts";
@@ -278,11 +271,10 @@ class RdbSessionHandle implements SessionHandle {
       }
       throw new SessionPersistenceNotFoundError(this.id);
     }
-    // 读取时修复（视图只读，不落库）：surface 替换 provenance 重计算、孤儿
-    // inbox splice 改写、非法 surface 替换降级。
-    repairSurfaceOps(log.events);
-    recomputeReplaceProvenance(log.events);
-    repairOrphanInboxSplices(log.events);
+    // 读取时修复（视图只读，不落库）：结算字段补全、非法 surface 替换降级
+    // 或按 metering 数量夹取、metering range 对齐、provenance 重算、孤儿
+    // inbox splice 改写。
+    repairReadView(log.events);
     return { eventState: "detached", events: log.events.slice(offset, offset + length) };
   }
 
@@ -593,6 +585,12 @@ export class SessionPersistenceRdb extends SessionPersistence {
       const log = await this.readLog(id, {}, options?.signal);
       if (log === undefined) throw new SessionPersistenceNotFoundError(id);
       validateStoredEvents(log.meta, log.events);
+      // 迁移链会生成/合并事件（end-seed / attempt / chunk 合并），事件坐标与
+      // 存储桥接行数不再相等——写打开时把迁移视图整体落库，使读写同坐标；
+      // 否则 append 按存储 head 重编号会撞上已有行或写坏 log。
+      if (log.migrated && log.events.length !== log.storedCount) {
+        await this.rewriteMigratedLog(id, log);
+      }
       // 确认 head：本实例已读该会话，后续 append 的并发校验以此为基准。
       this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
       return this.tracker.adopt(
@@ -669,8 +667,7 @@ export class SessionPersistenceRdb extends SessionPersistence {
     signal?.throwIfAborted();
     const log = await this.readLog(id, {}, signal);
     if (log === undefined) return undefined;
-    repairSurfaceOps(log.events);
-    recomputeReplaceProvenance(log.events);
+    repairReadView(log.events);
     const inheritedEventCount = Math.min(log.inheritedEventCount, log.events.length);
     return {
       meta: log.meta,
@@ -762,6 +759,12 @@ export class SessionPersistenceRdb extends SessionPersistence {
         incarnation: string;
 
         revision: number;
+
+        /** 存储桥接行数（迁移链可能生成/合并事件，与 `events.length` 不同）。 */
+        storedCount: number;
+
+        /** 是否经上游迁移链转换（v0/v1 → 当前格式）。 */
+        migrated: boolean;
       }
     | undefined
   > {
@@ -778,15 +781,36 @@ export class SessionPersistenceRdb extends SessionPersistence {
     signal?.throwIfAborted();
     // 旧格式（v0/v1）历史数据：行重建为物理记录，经上游迁移链转 v2 逻辑事件。
     // 迁移链自带 seq gap / torn tail 校验（strict recovery），无需 scanRows。
+    // 混合世代 log（旧写入器跨上游版本追加）不是任何单一已发布格式，迁移链
+    // 必然拒绝——回退为当前格式视图（header 版本归一 + 读取视图修复）。
     if (isLegacyVersion(row.fVersion)) {
-      const converted = convertLegacyRows(row, eventRows);
-      return {
-        meta: converted.meta,
-        inheritedEventCount: converted.inheritedEventCount,
-        events: converted.events,
-        incarnation: row.fIncarnation,
-        revision: row.fRevision,
-      };
+      try {
+        const converted = convertLegacyRows(row, eventRows);
+        return {
+          meta: converted.meta,
+          inheritedEventCount: converted.inheritedEventCount,
+          events: converted.events,
+          incarnation: row.fIncarnation,
+          revision: row.fRevision,
+          storedCount: eventRows.length,
+          migrated: true,
+        };
+      } catch (error: unknown) {
+        this.ctx.logger.warn(
+          `session-rdb: session "${id}" is not a single released format; adopting its stored rows as current-format data (${error instanceof Error ? error.message : String(error)})`,
+        );
+        const adopted = adoptLegacyRows(row, eventRows);
+        return {
+          meta: adopted.meta,
+          inheritedEventCount: adopted.inheritedEventCount,
+          events: adopted.events,
+          incarnation: row.fIncarnation,
+          revision: row.fRevision,
+          storedCount: eventRows.length,
+          migrated: false,
+          ...(adopted.tornFrom !== undefined ? { tornFrom: adopted.tornFrom } : {}),
+        };
+      }
     }
     const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0);
     return {
@@ -795,10 +819,40 @@ export class SessionPersistenceRdb extends SessionPersistence {
       events: preserved,
       incarnation: row.fIncarnation,
       revision: row.fRevision,
+      storedCount: eventRows.length,
+      migrated: false,
       ...(tornFrom !== undefined ? { tornFrom } : {}),
     };
   }
 
+  /**
+   * 把迁移链读出的 v2 视图整体落库（旧格式会话写打开时的一次性迁移）。
+   *
+   * 迁移链会生成/合并事件（end-seed / attempt / chunk 合并），事件 seq 空间
+   * 与存储桥接行数不再相等；写路径以存储 head 为锚点重编号，二者不一致会让
+   * append 撞上已有行。这里在同一事务内删光本会话桥接行、按迁移视图重建
+   * （新事件行，完整信封），并更新 head 与 revision；旧事件行保留（可能被
+   * fork 子会话引用，孤儿由惰性 GC 处理）。
+   */
+  private async rewriteMigratedLog(
+    id: SessionId,
+    log: { meta: SessionHeader; inheritedEventCount: number; events: SessionEvent[] },
+  ): Promise<void> {
+    await this.backend.transaction(async (tx) => {
+      await tx.deleteBridgeTail(id, 0);
+      await tx.upsertSession(
+        { meta: log.meta, inheritedEventCount: SessionLogOffset(log.inheritedEventCount) },
+        randomUUID(),
+      );
+      const { headEventId, headSequence } = await appendEventTail(tx, log.meta, log.events, {
+        parentId: "",
+        nextSeq: 0,
+      });
+      await tx.updateHead(id, headEventId, headSequence);
+      await tx.bumpRevision(id);
+    });
+  }
+
   async listSnapshots(
     signal?: AbortSignal,
   ): Promise<Array<SessionPersistenceSnapshot & { inheritedEventCount: number }>> {
@@ -1068,6 +1122,9 @@ export class SessionPersistenceRdb extends SessionPersistence {
         );
       }
       assertVersion(stored.meta);
+      // adopt 比较必须与读取视图同源：live seed 来自修复后的读取视图（补
+      // stream、surface 修复），未修复的存储视图会把修复差异误判为 id 冲突。
+      repairReadView(stored.events);
       const seed = session.snapshotEvents();
       if (!seedCoversPrefix(seed, stored.events)) {
         throw new Error(

package/src/legacy.ts

@@ -3,9 +3,15 @@
 // 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 { rowToMeta, scanRows } from "./log.ts";
 
 /** 重建 v0/v1 物理 header 记录（RDB 行 → 物理 JSON 对象）。 */
 function physicalHeader(row: SessionRow): Record<string, unknown> {
@@ -64,4 +70,41 @@ export function isLegacyVersion(version: number): boolean {
   return version < 2;
 }
 
+/**
+ * 迁移链拒绝后，把旧格式行直接当**当前格式**事件视图采用。
+ *
+ * 旧写入器只在建会话时落一次 header version，之后跟随上游演进继续追加
+ * 事件——同一个 log 因此可能是混合世代（v0 时代的行 + 新版本字段），不是
+ * 任何单一已发布格式，严格迁移链必然拒绝。这些行的数据形状（消息包装、
+ * 类型名）已经是当前格式，只需 header 版本归一到当前、按稠密 seq 读取；
+ * 事件数据的补全与 surface 修复由读取视图修复（repairReadView）负责。
+ *
+ * 调用方须在此之后执行 `validateStoredEvents`：真正属于旧格式的类型
+ * （`assistant/chunk` / `compact/*` 等）仍会被 fail-loud 拒绝。
+ *
+ * @param row - 会话行（f_version < 2）。
+ * @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);
+  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

@@ -211,12 +211,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) {
@@ -247,7 +250,16 @@ export function findSurfaceRepairs(events: readonly SessionEvent[]): {
       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;
     let rewriteOk = true;
     if (rangeOk && event.type === "tool/result") {
@@ -265,9 +277,31 @@ export function findSurfaceRepairs(events: readonly SessionEvent[]): {
       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 +309,19 @@ 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 { start: number };
+      raw.surfaceOp = { op: "replace", start: op.start, end: clamped };
     } else if (repairs.addAppendMarker.has(event.seq)) {
       raw.surfaceOp = "append";
     } else if (repairs.clearSurfaceOp.has(event.seq)) {
@@ -291,6 +330,65 @@ 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"] = [];
+  }
+}
+
+/**
+ * 把紧邻 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 { start, end } = op as { start: number; end: number };
+    const data = metering.data as unknown as {
+      shadowedRange?: { start: number; end: number };
+      shadowedSeqs?: number[];
+    };
+    if (data.shadowedRange?.start === start && data.shadowedRange.end === end) continue;
+    data.shadowedRange = { start, end };
+    data.shadowedSeqs = events
+      .filter(
+        (candidate) =>
+          candidate.seq >= start && candidate.seq <= end && SURFACE_EVENT_TYPES.has(candidate.type),
+      )
+      .map((candidate) => candidate.seq);
+  }
+}
+
+/**
+ * 读取视图修复总入口：结算字段补全 → surface 语义修复 → metering 对齐 →
+ * provenance 重算 → 孤儿 inbox splice 改写。全部只作用于内存视图，不落库。
+ */
+export function repairReadView(events: SessionEvent[]): void {
+  repairAssistantSettlement(events);
+  repairSurfaceOps(events);
+  syncMeteringRanges(events);
+  recomputeReplaceProvenance(events);
+  repairOrphanInboxSplices(events);
+}
+
 interface InboxSpliceLike {
   target?: unknown;
   start?: unknown;