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

package/dist/log-DBFUBPhv.mjs

@@ -0,0 +1,394 @@
+import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
+//#region src/log.ts
+function rowToMeta(row) {
+	if (!Number.isSafeInteger(row.fCreatedAt) || row.fCreatedAt < 0) throw new Error("stored session createdAt must be a non-negative safe integer");
+	return {
+		version: row.fVersion,
+		id: row.fSessionId,
+		createdAt: row.fCreatedAt,
+		...row.fCwd !== null ? { cwd: row.fCwd } : {},
+		...row.fParentSession !== null ? { parentSession: row.fParentSession } : {},
+		isSeeded: row.fSeedLength !== null,
+		...row.fOrigin !== null ? { origin: row.fOrigin } : {},
+		...row.fDelegationDepth === null ? {} : { delegationDepth: row.fDelegationDepth }
+	};
+}
+function sessionInsertRow(storage, incarnation) {
+	const meta = storage.meta;
+	return {
+		fSessionId: meta.id,
+		fHeadEventId: "",
+		fHeadSequence: -1,
+		fVersion: meta.version,
+		fCreatedAt: meta.createdAt,
+		fCwd: meta.cwd ?? null,
+		fParentSession: meta.parentSession ?? null,
+		fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
+		fOrigin: meta.origin ?? null,
+		fDelegationDepth: meta.delegationDepth ?? null,
+		fIncarnation: incarnation,
+		fRevision: 0
+	};
+}
+function sessionConflictRow(storage) {
+	const meta = storage.meta;
+	return {
+		fVersion: meta.version,
+		fCreatedAt: meta.createdAt,
+		fCwd: meta.cwd ?? null,
+		fParentSession: meta.parentSession ?? null,
+		fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
+		fOrigin: meta.origin ?? null,
+		fDelegationDepth: meta.delegationDepth ?? null
+	};
+}
+function rowToEvent(row) {
+	const surfaceOp = row.fSurfaceOp !== null ? JSON.parse(row.fSurfaceOp) : void 0;
+	const record = JSON.parse(row.fData);
+	if (typeof record === "object" && record !== null && !Array.isArray(record) && typeof record["type"] === "string" && typeof record["seq"] === "number" && typeof record["time"] === "number" && "data" in record) return {
+		...record,
+		seq: row.fSequence,
+		time: row.fCreatedAt,
+		...surfaceOp === void 0 ? {} : { surfaceOp }
+	};
+	return {
+		type: row.fType,
+		seq: row.fSequence,
+		time: row.fCreatedAt,
+		data: record,
+		...surfaceOp === void 0 ? {} : { surfaceOp }
+	};
+}
+const SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"user/message",
+	"assistant/message",
+	"tool/result"
+]);
+const METERING_EVENT_TYPES = /* @__PURE__ */ 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 的旧样式），保证既有行为不变。
+*/
+function recomputeReplaceProvenance(events) {
+	for (let i = 0; i < events.length; i++) {
+		const raw = events[i];
+		const op = raw.surfaceOp;
+		if (typeof op !== "object" || op === null || op.op !== "replace") continue;
+		const { start, end } = op;
+		const metering = i > 0 ? events[i - 1] : void 0;
+		const meteringData = metering !== void 0 && METERING_EVENT_TYPES.has(metering.type) ? metering.data : void 0;
+		if (meteringData?.shadowedSeqs !== void 0) {
+			raw.sourceEventSeqs = meteringData.shadowedSeqs;
+			continue;
+		}
+		const refs = [];
+		for (const candidate of events) if (candidate.seq >= start && candidate.seq <= end && SURFACE_EVENT_TYPES.has(candidate.type)) refs.push(candidate.seq);
+		raw.sourceEventSeqs = refs;
+	}
+}
+function isEventSeqLike(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0);
+}
+function isDeepEqualJson(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((item, i) => isDeepEqualJson(item, b[i]));
+	}
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	const aKeys = Object.keys(a);
+	const bRecord = b;
+	if (aKeys.length !== Object.keys(bRecord).length) return false;
+	return aKeys.every((key) => Object.hasOwn(bRecord, key) && isDeepEqualJson(a[key], bRecord[key]));
+}
+function toolResultRewriteContentOnly(original, replacement) {
+	const originalData = original.data;
+	const replacementData = replacement.data;
+	const originalMessage = originalData["message"];
+	const replacementMessage = replacementData["message"];
+	const originalContent = Array.isArray(originalMessage?.content) ? originalMessage.content : void 0;
+	const replacementContent = Array.isArray(replacementMessage?.content) ? replacementMessage.content : void 0;
+	if (originalContent === void 0 || replacementContent === void 0) return false;
+	return isDeepEqualJson({
+		...originalData,
+		message: {
+			...originalMessage,
+			content: [{
+				...originalContent[0],
+				content: null
+			}]
+		}
+	}, {
+		...replacementData,
+		message: {
+			...replacementMessage,
+			content: [{
+				...replacementContent[0],
+				content: null
+			}]
+		}
+	});
+}
+function findSurfaceRepairs(events) {
+	const nodes = [];
+	const degradeToAppend = /* @__PURE__ */ new Set();
+	const addAppendMarker = /* @__PURE__ */ new Set();
+	const clearSurfaceOp = /* @__PURE__ */ new Set();
+	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)) {
+				addAppendMarker.add(event.seq);
+				nodes.push(event.seq);
+			}
+			continue;
+		}
+		if (op === "append") {
+			if (SURFACE_EVENT_TYPES.has(event.type)) nodes.push(event.seq);
+			else clearSurfaceOp.add(event.seq);
+			continue;
+		}
+		if (!SURFACE_EVENT_TYPES.has(event.type)) {
+			clearSurfaceOp.add(event.seq);
+			continue;
+		}
+		const replace = typeof op === "object" && op !== null && !Array.isArray(op) ? op : void 0;
+		const start = replace?.["start"];
+		const end = replace?.["end"];
+		const shapeOk = replace !== void 0 && replace["op"] === "replace" && isEventSeqLike(start) && isEventSeqLike(end);
+		const startIdx = shapeOk ? nodes.indexOf(start) : -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") {
+			const shadowed = nodes.slice(startIdx, endIdx + 1);
+			if (shadowed.length !== 1) rewriteOk = false;
+			else {
+				const original = events[shadowed[0]];
+				rewriteOk = original?.type === "tool/result" && toolResultRewriteContentOnly(original, event);
+			}
+		}
+		if (!rangeOk || !rewriteOk) {
+			degradeToAppend.add(event.seq);
+			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,
+		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 && 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，失败即拒绝整个
+* 会话（resume / 编辑重放不可用）。rewind 截断历史轮次后若残留 splice 引用
+* 已被截断的排队消息（插入被删、消费保留，或反之），重放时越界或重复——
+* 无法独立重放。
+*/
+function orphanInboxSpliceSeqs(events) {
+	const inbox = {
+		"next-turn": [],
+		"next-step": []
+	};
+	const orphan = /* @__PURE__ */ new Set();
+	for (const raw of events) {
+		const event = raw;
+		if (event.type !== "agent/inbox/spliced") continue;
+		const { target, start, removedCount, inserted } = event.data;
+		const list = typeof target === "string" ? inbox[target] : void 0;
+		if (list === void 0) {
+			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) || start < 0 || start > list.length || !Number.isSafeInteger(removed) || removed < 0 || start + removed > list.length) {
+			orphan.add(event.seq);
+			continue;
+		}
+		const candidate = [
+			...list.slice(0, start),
+			...parsedInserted,
+			...list.slice(start + removed)
+		];
+		const other = (target === "next-turn" ? inbox["next-step"] : inbox["next-turn"]) ?? [];
+		const seen = /* @__PURE__ */ new Set();
+		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, removed, ...parsedInserted);
+	}
+	return orphan;
+}
+/** 内存修复：把孤儿 inbox splice 改写为 no-op（调用方负责持久化）。 */
+function repairOrphanInboxSplices(events) {
+	const orphan = orphanInboxSpliceSeqs(events);
+	if (orphan.size === 0) return;
+	for (const event of events) {
+		if (!orphan.has(event.seq)) continue;
+		const target = event.data.target;
+		event.data = {
+			...typeof target === "string" ? { target } : { target: "next-turn" },
+			start: 0,
+			removedCount: 0,
+			inserted: []
+		};
+	}
+}
+function scanRows(rows, base = 0) {
+	const parsed = rows.map((row) => {
+		try {
+			return {
+				ok: true,
+				event: rowToEvent(row)
+			};
+		} catch {
+			return { ok: false };
+		}
+	});
+	let lastTurnEnd = -1;
+	for (let i = parsed.length - 1; i >= 0; i--) if (parsed[i]?.ok && rows[i]?.fType === "turn/end") {
+		lastTurnEnd = i;
+		break;
+	}
+	const preserved = [];
+	for (let i = 0; i < rows.length; i++) {
+		const p = parsed[i];
+		if (!p?.ok || p.event === void 0) {
+			if (i <= lastTurnEnd) throw new Error(`corrupt session log: unparsable committed event at seq ${rows[i]?.fSequence}`);
+			break;
+		}
+		if (p.event.seq !== base + i) {
+			if (i <= lastTurnEnd) throw new Error(`corrupt session log: seq gap in committed region (expected ${base + i}, got ${p.event.seq})`);
+			break;
+		}
+		preserved.push(p.event);
+	}
+	return preserved.length < rows.length ? {
+		preserved,
+		tornFrom: base + preserved.length
+	} : { preserved };
+}
+function toJsonlArtifact(meta, inheritedEventCount, events) {
+	const header = sessionFormatCatalog.encodeCurrentHeader({
+		...meta,
+		delegationDepth: meta.delegationDepth ?? 0
+	}, inheritedEventCount);
+	const lines = [JSON.stringify(header)];
+	for (const event of events) lines.push(JSON.stringify(sessionFormatCatalog.encodeCurrentEvent(event)));
+	return lines.join("\n");
+}
+//#endregion
+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/{schema-CFXZURX7.d.mts → schema-COK7-wRV.d.mts}

@@ -30,7 +30,6 @@ interface EventInsert {
 interface EventRow {
   fEventId: string;
   fSequence: number;
-  fOriginalSeq: number;
   fType: string;
   fKind: string;
   fRole: string;
@@ -50,7 +49,6 @@ interface BackendTx {
     fSessionId: SessionId;
     fEventId: string;
     fSequence: number;
-    fOriginalSeq: number;
     fSurfaceOp: string | null;
   }>): Promise<void>;
   updateHead(id: SessionId, headEventId: string, headSequence: number): Promise<void>;
@@ -60,20 +58,12 @@ interface BackendTx {
     fEventId: string;
     fSequence: number;
   } | undefined>;
-  getLastBridge(id: SessionId): Promise<{
-    fEventId: string;
-    fSequence: number;
-  } | undefined>;
 }
 interface Backend {
   readonly kind: "sqlite" | "postgres";
   readonly storeIdentity: string;
   open(): Promise<void>;
   getSession(id: SessionId): Promise<SessionRow | undefined>;
-  getSeqMapRows(id: SessionId): Promise<Array<{
-    fSequence: number;
-    fOriginalSeq: number;
-  }>>;
   getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]>;
   listSessions(): Promise<SessionRow[]>;
   transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T>;
@@ -88,18 +78,16 @@ declare class WriteGuard {
 }
 //#endregion
 //#region src/schema.d.ts
-declare const SCHEMA_VERSION = 2;
+declare const SCHEMA_VERSION = 3;
 declare const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
-declare const EPHEMERAL_EVENT_TYPES: readonly ["assistant/chunk"];
 declare const EVENT_ENCODING = "json";
 declare const tPersistenceState: any;
+declare const tSchemaMeta: any;
 declare const tSessions: any;
 declare const tEvents: any;
 declare const tSessionEvents: any;
 type JournalMode = "wal" | "delete" | "truncate" | "persist";
 declare const DEFAULT_BUSY_TIMEOUT_MS = 5000;
-declare function isEphemeralType(type: string): boolean;
-declare function isPersistedEvent(event: SessionEvent): boolean;
 type EventKind = "message" | "thinking" | "turn" | "tool" | "request" | "config" | "audit" | "lifecycle" | "inbox" | "compaction" | "llm" | "subagent" | "team" | "workflow" | "goal" | "schedule" | "todo" | "web";
 type EventRole = "user" | "assistant" | "tool";
 declare function eventKind(event: {
@@ -113,4 +101,4 @@ declare function eventDimensions(event: SessionEvent): {
   actionId: string;
 };
 //#endregion
-export { WriteGuard as _, EventRole as a, EventRow as b, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as c, isEphemeralType as d, isPersistedEvent as f, tSessions as g, tSessionEvents as h, EventKind as i, eventDimensions as l, tPersistenceState as m, EPHEMERAL_EVENT_TYPES as n, JournalMode as o, tEvents as p, EVENT_ENCODING as r, SCHEMA_VERSION as s, DEFAULT_BUSY_TIMEOUT_MS as t, eventKind as u, Backend as v, SessionRow as x, BackendTx as y };
+export { BackendTx as _, JournalMode as a, eventDimensions as c, tPersistenceState as d, tSchemaMeta as f, Backend as g, WriteGuard as h, EventRole as i, eventKind as l, tSessions as m, EVENT_ENCODING as n, SCHEMA_VERSION as o, tSessionEvents as p, EventKind as r, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as s, DEFAULT_BUSY_TIMEOUT_MS as t, tEvents as u, EventRow as v, SessionRow as y };