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

package/dist/route-DpfY0zq-.mjs

@@ -0,0 +1,114 @@
+// src/routes.ts
+const MORLAY_SESSION_API_PREFIX = "/api/morlay/v1/session";
+const SESSION_ROWS_PATH = `${MORLAY_SESSION_API_PREFIX}/rows`;
+const SESSION_EXPORT_PATH = `${MORLAY_SESSION_API_PREFIX}/export`;
+const SESSION_IMPORT_PATH = `${MORLAY_SESSION_API_PREFIX}/import`;
+const SESSION_DELETE_PATH = `${MORLAY_SESSION_API_PREFIX}/delete`;
+const SESSION_ORGANIZE_PATH = `${MORLAY_SESSION_API_PREFIX}/organize`;
+const SESSION_USAGE_PATH = `${MORLAY_SESSION_API_PREFIX}/usage`;
+// src/http/route.ts
+/** 一条路由自己决定的状态码（鉴权 / 方法 / 解析之外的那些校验）。 */
+var HttpError = class extends Error {
+	status;
+	payload;
+	constructor(status, message, payload = {}) {
+		super(message);
+		this.status = status;
+		this.payload = payload;
+		this.name = "HttpError";
+	}
+};
+function writeJson(res, status, body) {
+	res.writeHead(status, { "content-type": "application/json" });
+	res.end(JSON.stringify(body));
+}
+/**
+* 挂一条路由：鉴权与方法检查这些每处都一样的部分收在这里。
+*
+* 二进制响应（导出 zip）自己写响应体，所以只共用鉴权 / 405 / 错误兜底。
+*/
+function mountRoute(ctx, path, handler) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					writeJson(res, 405, { error: "method not allowed" });
+					return;
+				}
+				try {
+					await handler(req, res);
+				} catch (error) {
+					if (res.headersSent) return;
+					writeJson(res, 500, { error: error instanceof Error ? error.message : "request failed" });
+				}
+			}
+		}), `session-rdb: ${path}`);
+	});
+}
+/**
+* 挂一条 JSON 路由：鉴权、方法、body 解析、错误码这些每处都一样的部分收在这里。
+*
+* 5 个 JSON 路由（rows / usage / gc / deletion / import）共用 `mountJsonRoute`；`export` 的响应体是 zip，走
+* `mountRoute`，只复用鉴权 / 405 / 500。之前每个文件各抄一遍（约 270 行样板，而且 `import` 那条漏了 405）。
+*/
+function mountJsonRoute(ctx, spec) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: spec.path,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					writeJson(res, 405, { error: "method not allowed" });
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				const raw = Buffer.concat(chunks).toString("utf8");
+				let body = {};
+				if (raw !== "") try {
+					body = JSON.parse(raw);
+				} catch {
+					writeJson(res, 400, { error: "request body is not JSON" });
+					return;
+				}
+				try {
+					const reply = await spec.handle(body, webCtx);
+					writeJson(res, reply.status ?? 200, reply.body);
+				} catch (error) {
+					if (error instanceof HttpError) {
+						writeJson(res, error.status, {
+							error: error.message,
+							...error.payload
+						});
+						return;
+					}
+					const mapped = spec.statusOfError?.(error);
+					if (mapped !== void 0) {
+						writeJson(res, mapped.status, mapped.body);
+						return;
+					}
+					writeJson(res, 500, { error: error instanceof Error ? error.message : "request failed" });
+				}
+			}
+		}), `session-rdb: ${spec.path}`);
+	});
+}
+export { SESSION_EXPORT_PATH as a, SESSION_ROWS_PATH as c, SESSION_DELETE_PATH as i, SESSION_USAGE_PATH as l, mountJsonRoute as n, SESSION_IMPORT_PATH as o, mountRoute as r, SESSION_ORGANIZE_PATH as s, HttpError as t };

package/dist/storage.d.mts

@@ -1,57 +1,50 @@
-import { A as SessionRow, At as tWorkspaceState, Ct as tSessionCounts, D as SessionCountBucket, Dt as tSessions, E as EventRow, Et as tSessionUsage, F as UsageAggregate, Mt as WriteGuard, O as SessionListRowsPage, Ot as tStorageUnits, St as tSchemaMeta, T as BackendTx, Tt as tSessionProjcacheRows, _t as eventKind, bt as tPersistenceState, dt as EventKind, ft as EventRole, gt as eventDimensions, ht as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, j as SessionUsageBucket, jt as tWorkspaces, k as SessionListRowsQuery, kt as tWorkspaceSessions, lt as DEFAULT_BUSY_TIMEOUT_MS, mt as SCHEMA_VERSION, pt as JournalMode, ut as EVENT_ENCODING, vt as tEventUsage, w as Backend, wt as tSessionEvents, xt as tScheduleTasks, yt as tEvents, zt as StorageRepository } from "./log-TYgd8Xkr.mjs";
-import { SessionId } from "@deepseek-ai/dsh-session";
-import { DatabaseSync } from "node:sqlite";
-export declare function openDatabase(path: string, journalMode: JournalMode, busyTimeout?: number): Promise<DatabaseSync>;
-export interface SqliteBackendOptions {
-  path: string;
-  journalMode: JournalMode;
-  busyTimeout: number;
-}
-export declare class SqliteBackend implements Backend {
-  private readonly options;
-  readonly kind: "sqlite";
-  storeIdentity: string;
+import { F as JournalMode, G as StorageRepository, I as SCHEMA_VERSION, L as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, N as DEFAULT_BUSY_TIMEOUT_MS, P as EVENT_ENCODING, R as WriteGuard, a as SessionCountBucket, c as SessionRow, i as ReadModel, l as SessionUsageBucket, n as BackendTx, o as SessionListRowsPage, p as UsageAggregate, r as EventRow, s as SessionListRowsQuery, t as Backend } from "./backend-BKtJ5sO5.mjs";
+import { Database } from "@morlay/rdbkit";
+import { SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
+export type EventKind = "message" | "thinking" | "turn" | "tool" | "request" | "config" | "audit" | "lifecycle" | "inbox" | "compaction" | "llm" | "subagent" | "team" | "workflow" | "goal" | "schedule" | "todo" | "web";
+export type EventRole = "user" | "assistant" | "tool";
+export declare function eventKind(event: {
+  type: string;
+  data?: unknown;
+}): EventKind | "";
+export declare function eventDimensions(event: SessionEvent): {
+  kind: string;
+  role: string;
+  name: string;
+  actionId: string;
+};
+/**
+ * 唯一的 backend 实现：读写方法收敛在这里（读模型 + `session-ops` + 表句柄）；打开流程在 `db/open.ts`，
+ * 统计面在 `db/stats.ts`。方言差异全部由 rdbkit 的表达式承担，这里不出现任何 SQL 文本。
+ */
+export declare class RdbBackend implements Backend {
+  #private;
   readonly storage: StorageRepository;
-  private dbPath;
-  private db;
-  private readonly dbReady;
-  private resolveDb;
-  private rejectDb;
-  constructor(options: SqliteBackendOptions);
+  readonly storeIdentity: string;
+  readonly reads: ReadModel;
+  constructor(options: {
+    kind: "sqlite" | "postgres";
+    database: Database;
+    storage: StorageRepository;
+    readModel: ReadModel;
+    storeIdentity: string;
+  });
+  readonly kind: "sqlite" | "postgres";
   open(): Promise<void>;
-  private doOpen;
   close(): Promise<void>;
-  getSession(id: SessionId): Promise<SessionRow | undefined>;
-  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[]>;
   transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T>;
-  private readonly tx;
-  private upsertSession;
-  private getHead;
-  private getSeedLength;
-  private updateSeedLength;
-  private static readonly INSERT_BATCH_ROWS;
-  private insertEvents;
-  private insertBridges;
-  private updateHead;
-  private bumpRevision;
-  private refreshTitle;
-  private deleteBridgeTail;
-  private getPrevBridge;
-  private deleteSession;
-  collectOrphans(): Promise<number>;
   listOrphanSubagentSessions(): Promise<SessionId[]>;
-  private deleteSessions;
-  listSessionRows(query?: SessionListRowsQuery): Promise<SessionListRowsPage>;
+  /** 当前 head 指针（分支 / 测试读路径用；写路径在 `BackendTx` 里）。 */
+  getHead(id: SessionId): Promise<Pick<SessionRow, "fHeadEventId" | "fHeadSequence">>;
+  collectOrphans(): Promise<number>;
   usageReport(sinceMs?: number): Promise<UsageAggregate>;
-  incrementSessionUsage(id: SessionId, buckets: readonly SessionUsageBucket[]): Promise<void>;
-  incrementSessionCounts(id: SessionId, buckets: readonly SessionCountBucket[]): Promise<void>;
-  rebuildSessionStats(id: SessionId): Promise<void>;
+  listSessionRows(query?: SessionListRowsQuery): Promise<SessionListRowsPage>;
+  incrementSessionUsage(id: string, buckets: readonly SessionUsageBucket[]): Promise<void>;
+  incrementSessionCounts(id: string, buckets: readonly SessionCountBucket[]): Promise<void>;
+  deleteSessionStats(id: string): Promise<void>;
+  rebuildSessionStats(id: string): Promise<void>;
+  rebuildAllStats(): Promise<number>;
   refreshEventUsageFlags(eventIds: readonly string[]): Promise<void>;
-  deleteSessionStats(id: SessionId): Promise<void>;
   vacuum(): Promise<void>;
-  private eventRows;
 }
-export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, EventKind, EventRole, type EventRow, JournalMode, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, type SessionRow, WriteGuard, eventDimensions, eventKind, tEventUsage, tEvents, tPersistenceState, tScheduleTasks, tSchemaMeta, tSessionCounts, tSessionEvents, tSessionProjcacheRows, tSessionUsage, tSessions, tStorageUnits, tWorkspaceSessions, tWorkspaceState, tWorkspaces };
+export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, type EventRow, JournalMode, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, type SessionRow, WriteGuard };

package/dist/storage.mjs

@@ -1 +1,3 @@
-export { i as DEFAULT_BUSY_TIMEOUT_MS, a as EVENT_ENCODING, o as SCHEMA_VERSION, s as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, t as SqliteBackend, E as WriteGuard, c as eventDimensions, l as eventKind, n as openDatabase, u as tEventUsage, d as tEvents, f as tPersistenceState, p as tScheduleTasks, m as tSchemaMeta, h as tSessionCounts, g as tSessionEvents, _ as tSessionProjcacheRows, v as tSessionUsage, y as tSessions, b as tStorageUnits, x as tWorkspaceSessions, S as tWorkspaceState, C as tWorkspaces } from "./sqlite-BNRd1aqR.mjs";
+import { d as EVENT_ENCODING, f as SCHEMA_VERSION, p as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, t as RdbBackend, u as DEFAULT_BUSY_TIMEOUT_MS } from "./backend-rdb-BDCntVDy.mjs";
+import { n as eventDimensions, r as eventKind, t as WriteGuard } from "./write-guard-CYrY58GM.mjs";
+export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, RdbBackend, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, WriteGuard, eventDimensions, eventKind };

package/dist/testing.d.mts

@@ -1,7 +1,9 @@
-import { ot as truncateLiveSession } from "./log-TYgd8Xkr.mjs";
+import { F as JournalMode } from "./backend-BKtJ5sO5.mjs";
+import { i as truncateLiveSession } from "./index-CUD2ZpTA.mjs";
 import { Session, SessionEvent, SessionHeader, SessionId } from "@deepseek-ai/dsh-session";
 import { SessionPersistence } from "@deepseek-ai/dsh-session-persistence";
 import { Context, Fiber } from "@deepseek-ai/cordis";
+import { DatabaseSync } from "node:sqlite";
 interface ContractBackendInstance {
   persistence: SessionPersistence;
   dispose: () => Promise<void>;
@@ -20,4 +22,10 @@ interface CoordinatorFixture {
   cleanup: () => Promise<void>;
 }
 export declare function runCoordinatorContract(name: string, makeFixture: () => Promise<CoordinatorFixture>): void;
+/**
+ * 测试辅助：先把库初始化（建表 / 迁移 / 身份），再给一个同步句柄——造损坏数据、读 `PRAGMA` 用。
+ *
+ * 同步口只在测试里存在：生产路径拿到的永远是 `Database`。
+ */
+export declare function openInitializedSqlite(path: string, journalMode?: JournalMode, busyTimeout?: number): Promise<DatabaseSync>;
 export { type ContractBackend, type CoordinatorFixture, truncateLiveSession };

package/dist/testing.mjs

@@ -1,9 +1,12 @@
-import { o as truncateLiveSession } from "./branch-CoPCRKer.mjs";
+import { a as truncateLiveSession } from "./branch-CG1PUlO6.mjs";
+import { u as DEFAULT_BUSY_TIMEOUT_MS } from "./backend-rdb-BDCntVDy.mjs";
+import { t as openRdbBackend } from "./open-YoyD_kah.mjs";
 import SessionStore, { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
-import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionFormatUnsupportedError, SessionHandleClosedError, SessionPersistenceNotFoundError, SessionReadOnlyError } from "@deepseek-ai/dsh-session-persistence";
-import { Context } from "@deepseek-ai/cordis";
+import { openSqliteHandle } from "@morlay/rdbkit/testing";
 import { describe, expect, it } from "vitest";
 import { MessageId, createUserMessage, freezeMessage } from "@deepseek-ai/dsh-llm";
+import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionFormatUnsupportedError, SessionHandleClosedError, SessionPersistenceNotFoundError, SessionReadOnlyError } from "@deepseek-ai/dsh-session-persistence";
+import { Context } from "@deepseek-ai/cordis";
 // src/testing/contract.ts
 function meta(id, cwd) {
 	return {
@@ -1047,4 +1050,22 @@ function runCoordinatorContract(name, makeFixture) {
 		});
 	});
 }
-export { appendLog, meta, oneTurnLog, runCoordinatorContract, runPersistenceContract, truncateLiveSession };
+// src/testing.ts
+/**
+* 测试辅助：先把库初始化（建表 / 迁移 / 身份），再给一个同步句柄——造损坏数据、读 `PRAGMA` 用。
+*
+* 同步口只在测试里存在：生产路径拿到的永远是 `Database`。
+*/
+async function openInitializedSqlite(path, journalMode = "wal", busyTimeout = DEFAULT_BUSY_TIMEOUT_MS) {
+	await (await openRdbBackend({
+		type: "sqlite",
+		path,
+		journalMode,
+		busyTimeout
+	})).close();
+	return openSqliteHandle(path, {
+		journalMode,
+		busyTimeout
+	});
+}
+export { appendLog, meta, oneTurnLog, openInitializedSqlite, runCoordinatorContract, runPersistenceContract, truncateLiveSession };

package/dist/usage-row-BQQM-_t6.mjs

@@ -0,0 +1,36 @@
+import { localDayKey } from "./usage.mjs";
+// src/log/usage-row.ts
+function numericField(value) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}
+function textField(value) {
+	return typeof value === "string" && value !== "" ? value : null;
+}
+function usageRowOf(event, subagent) {
+	if (event.fType !== "assistant/message") return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(event.fData);
+	} catch {
+		return;
+	}
+	const envelope = parsed["data"] ?? parsed;
+	const usage = envelope["usage"];
+	if (typeof usage !== "object" || usage === null) return void 0;
+	const source = envelope["message"]?.source;
+	return {
+		fEventId: event.fEventId,
+		fCreatedAt: event.fCreatedAt,
+		fDay: localDayKey(event.fCreatedAt),
+		fProvider: textField(source?.["provider"]),
+		fModel: textField(source?.["model"]),
+		fReferenced: 1,
+		fSubagent: subagent ? 1 : 0,
+		fInputTokens: numericField(usage["inputTokens"]),
+		fOutputTokens: numericField(usage["outputTokens"]),
+		fCacheReadTokens: numericField(usage["cacheReadTokens"]),
+		fReasoningTokens: numericField(usage["reasoningTokens"]),
+		fTotalTokens: numericField(usage["totalTokens"])
+	};
+}
+export { usageRowOf as t };

package/dist/usage.d.mts

@@ -1,2 +1,2 @@
-import { B as UsageTotals, F as UsageAggregate, G as emptyTotals, H as addActivityTotals, I as UsageBucket, J as resolveUsageSince, K as localDayKey, L as UsageRangeKey, M as COUNTED_EVENT_TYPES, N as SessionUsageReport, P as UsageActivityTotals, R as UsageSessionRow, Rt as SESSION_USAGE_PATH, U as addTokenTotals, V as addActivityCount, W as addTotals, q as registerSessionUsage, z as UsageTokenTotals } from "./log-TYgd8Xkr.mjs";
+import { C as emptyTotals, E as resolveUsageSince, S as addTotals, T as registerSessionUsage, W as SESSION_USAGE_PATH, _ as UsageTokenTotals, b as addActivityTotals, d as SessionUsageReport, f as UsageActivityTotals, g as UsageSessionRow, h as UsageRangeKey, m as UsageBucket, p as UsageAggregate, u as COUNTED_EVENT_TYPES, v as UsageTotals, w as localDayKey, x as addTokenTotals, y as addActivityCount } from "./backend-BKtJ5sO5.mjs";
 export { COUNTED_EVENT_TYPES, SESSION_USAGE_PATH, SessionUsageReport, UsageActivityTotals, UsageAggregate, UsageBucket, UsageRangeKey, UsageSessionRow, UsageTokenTotals, UsageTotals, addActivityCount, addActivityTotals, addTokenTotals, addTotals, emptyTotals, localDayKey, registerSessionUsage, resolveUsageSince };

package/dist/usage.mjs

@@ -1,4 +1,4 @@
-import { o as SESSION_USAGE_PATH } from "./routes-hZjTcX_R.mjs";
+import { l as SESSION_USAGE_PATH, n as mountJsonRoute } from "./route-DpfY0zq-.mjs";
 // src/usage.ts
 const ROLLING_DAYS = {
 	"7d": 7,
@@ -91,45 +91,12 @@ function addTotals(target, row) {
 	return target;
 }
 function registerSessionUsage(ctx, persistence) {
-	ctx.inject(["webServer", "connection"], (webCtx) => {
-		const webServer = webCtx.webServer;
-		const connection = webCtx.get("connection");
-		return webCtx.effect(() => webServer.register({
-			kind: "exact",
-			path: SESSION_USAGE_PATH,
-			handler: async (req, res) => {
-				const rejection = connection.requestRejection(req);
-				if (rejection !== void 0) {
-					res.writeHead(rejection);
-					res.end(rejection === 401 ? "unauthorized" : "forbidden");
-					return;
-				}
-				if (req.method !== "POST") {
-					res.writeHead(405, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "method not allowed" }));
-					return;
-				}
-				const chunks = [];
-				for await (const chunk of req) chunks.push(chunk);
-				const raw = Buffer.concat(chunks).toString("utf8");
-				let envelope = {};
-				if (raw !== "") try {
-					envelope = JSON.parse(raw);
-				} catch {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "request body is not JSON" }));
-					return;
-				}
-				try {
-					const report = await persistence.usageReport(resolveUsageSince(parseUsageRange(envelope.range), Date.now()));
-					res.writeHead(200, { "content-type": "application/json" });
-					res.end(JSON.stringify(report));
-				} catch (error) {
-					res.writeHead(500, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "usage report failed" }));
-				}
-			}
-		}), `session-rdb: ${SESSION_USAGE_PATH} route`);
+	mountJsonRoute(ctx, {
+		path: SESSION_USAGE_PATH,
+		handle: async (body) => {
+			const { range } = body;
+			return { body: await persistence.usageReport(resolveUsageSince(parseUsageRange(range), Date.now())) };
+		}
 	});
 }
 export { COUNTED_EVENT_TYPES, SESSION_USAGE_PATH, addActivityCount, addActivityTotals, addTokenTotals, addTotals, emptyTotals, localDayKey, registerSessionUsage, resolveUsageSince };

package/dist/write-guard-CYrY58GM.mjs

@@ -0,0 +1,174 @@
+// src/event-shape.ts
+function eventKind(event) {
+	switch (event.type) {
+		case "user/message": return "message";
+		case "assistant/message":
+			if ((event.data.message?.content)?.some((block) => block?.type === "reasoning")) return "thinking";
+			return "message";
+		case "turn/start":
+		case "turn/end":
+		case "step/start":
+		case "step/end":
+		case "session/end-seed": return "turn";
+		case "tool/call":
+		case "tool/result":
+		case "tool/ptc-dispatch-start":
+		case "tool/ptc-dispatch":
+		case "tool/code-dispatch-start":
+		case "tool/code-dispatch": return "tool";
+		case "request/header":
+		case "request/context": return "request";
+		case "model/selection":
+		case "permission/preset":
+		case "approval/policy":
+		case "sandbox/mode":
+		case "plan/mode":
+		case "agent-preset/selected": return "config";
+		case "approval/asked":
+		case "approval/decided":
+		case "command/run":
+		case "command/done":
+		case "hook/invoked":
+		case "hook/result":
+		case "feedback/record": return "audit";
+		case "session/title":
+		case "session/title-llm-request":
+		case "session-log-deepseek/delivery-accepted": return "lifecycle";
+		case "agent/inbox/spliced": return "inbox";
+		case "compaction/start":
+		case "compaction/end":
+		case "compaction/summary":
+		case "compaction/prune": return "compaction";
+		case "llm/retry":
+		case "llm/retry-started": return "llm";
+		case "subagent/descriptor":
+		case "subagent/model-selection-policy": return "subagent";
+		case "team/member":
+		case "team/task":
+		case "team/message/queued":
+		case "team/message/delivered": return "team";
+		case "tool-workflow/run-start":
+		case "tool-workflow/run-end":
+		case "tool-workflow/agent-start":
+		case "tool-workflow/agent-end": return "workflow";
+		case "goal/change": return "goal";
+		case "schedule/change": return "schedule";
+		case "todo/write": return "todo";
+		case "web/deepseek-search-llm-request": return "web";
+		default: return "";
+	}
+}
+function eventDimensions(event) {
+	const kind = eventKind(event);
+	const type = event.type;
+	const data = event.data;
+	switch (type) {
+		case "user/message": return {
+			kind,
+			role: "user",
+			name: "",
+			actionId: ""
+		};
+		case "assistant/message": return {
+			kind,
+			role: "assistant",
+			name: "",
+			actionId: ""
+		};
+		case "tool/result": return {
+			kind,
+			role: "tool",
+			name: "",
+			actionId: data["message"]?.toolCallId ?? ""
+		};
+		case "tool/call": return {
+			kind,
+			role: "",
+			name: typeof data["name"] === "string" ? data["name"] : "",
+			actionId: typeof data["callId"] === "string" ? data["callId"] : ""
+		};
+		case "tool/ptc-dispatch-start":
+		case "tool/ptc-dispatch":
+		case "tool/code-dispatch-start":
+		case "tool/code-dispatch": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["subCallId"] === "string" ? data["subCallId"] : ""
+		};
+		case "command/run":
+		case "command/done": return {
+			kind,
+			role: "",
+			name: type === "command/run" && typeof data["name"] === "string" ? data["name"] : "",
+			actionId: typeof data["commandId"] === "string" ? data["commandId"] : ""
+		};
+		case "approval/asked":
+		case "approval/decided": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["id"] === "string" ? data["id"] : ""
+		};
+		case "hook/invoked":
+		case "hook/result": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["handlerId"] === "string" ? data["handlerId"] : ""
+		};
+		case "llm/retry":
+		case "llm/retry-started": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["retryId"] === "string" ? data["retryId"] : ""
+		};
+		case "tool-workflow/run-start":
+		case "tool-workflow/run-end":
+		case "tool-workflow/agent-start":
+		case "tool-workflow/agent-end": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["runId"] === "string" ? data["runId"] : ""
+		};
+		case "todo/write": return {
+			kind,
+			role: "",
+			name: "todos",
+			actionId: ""
+		};
+		case "subagent/descriptor": return {
+			kind,
+			role: "",
+			name: typeof data["label"] === "string" ? data["label"] : "",
+			actionId: ""
+		};
+		default: return {
+			kind,
+			role: "",
+			name: "",
+			actionId: ""
+		};
+	}
+}
+// src/write-guard.ts
+var WriteGuard = class {
+	headSeqs = /* @__PURE__ */ new Map();
+	confirmHead(id, head) {
+		this.headSeqs.set(id, head);
+	}
+	has(id) {
+		return this.headSeqs.has(id);
+	}
+	assertNoConcurrentWriter(id, storedHead) {
+		const known = this.headSeqs.get(id);
+		if (known === void 0) {
+			if (storedHead !== -1) throw new Error(`session "${id}" has a persisted log this instance has not read; another writer may own it — load the session first`);
+			return;
+		}
+		if (known !== storedHead) throw new Error(`session "${id}" was modified by another writer (stored head ${storedHead}, this instance last confirmed head ${known}); concurrent writers on one session are not supported`);
+	}
+};
+export { eventDimensions as n, eventKind as r, WriteGuard as t };