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

package/dist/open-YoyD_kah.mjs

@@ -0,0 +1,561 @@
+import { a as sessionProjcacheRows, c as sessions, i as catalog, l as persistenceState, n as backfillUsageTables, o as storageRecords, p as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, r as createReadModel, s as storageUnits, t as RdbBackend } from "./backend-rdb-BDCntVDy.mjs";
+import { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
+import { randomUUID } from "node:crypto";
+import { E, defineTable, ensureSchema, openDatabase, runMigrations } from "@morlay/rdbkit";
+import { chmod, mkdir, open, stat } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+// src/storage-takeover/legacy-domain-migration.ts
+/**
+* 把旧语义表的内容写进通用域存储（`workspace` / `schedule` / 上一版 `t_storage_globals` 的域）。
+* @param rows - 旧表读出来的行。
+* @param repository - 通用域存储。
+*/
+async function migrateLegacyDomainStorage(rows, repository) {
+	if (rows.workspaces.length > 0 || rows.state !== void 0) {
+		for (const row of rows.workspaces) {
+			const sessionIds = rows.links.filter((link) => link.workspaceId === row.id).sort((left, right) => left.position - right.position).map((link) => link.sessionId);
+			await repository.putDomainRecord("workspace", "workspaces", row.id, {
+				path: row.path,
+				title: row.title,
+				sessionIds,
+				createdAt: row.createdAt,
+				updatedAt: row.updatedAt
+			});
+		}
+		const pending = rows.state?.pendingOperation;
+		const pendingMutation = pending === "create" || pending === "delete" ? {
+			operation: pending,
+			workspaceId: rows.state?.pendingWorkspaceId ?? ""
+		} : void 0;
+		await repository.writeDomainGlobal("workspace", {
+			initialized: rows.state === void 0 ? true : Boolean(rows.state.initialized),
+			workspaceIds: rows.workspaces.filter((row) => row.position >= 0).sort((left, right) => left.position - right.position).map((row) => row.id),
+			archivedSessionIds: rows.archived.map((id) => id),
+			pinnedSessionIds: rows.pinned.sort((left, right) => left.seq - right.seq).map((row) => row.id),
+			...pendingMutation === void 0 ? {} : { pendingMutation }
+		});
+		await repository.insertUnitVersion("workspace", 2);
+	}
+	for (const row of rows.tasks) await repository.putDomainRecord("schedule", "tasks", row.id, {
+		sessionId: row.sessionId,
+		record: JSON.parse(row.record),
+		status: row.status === "inactive" ? "inactive" : "active",
+		...row.lastDelivery === null ? {} : { lastDelivery: JSON.parse(row.lastDelivery) },
+		...row.deliveryHistory === null ? {} : { deliveryHistory: JSON.parse(row.deliveryHistory) }
+	});
+	if (rows.tasks.length > 0) await repository.insertUnitVersion("schedule", 1);
+	for (const row of rows.globals) {
+		await repository.writeDomainGlobal(row.domain, row.value);
+		await repository.insertUnitVersion(row.domain, 1);
+	}
+}
+// src/storage-takeover/repository.ts
+function identityOfSession(row) {
+	return {
+		formatVersion: row.fVersion,
+		createdAt: row.fCreatedAt,
+		...row.fCwd === null ? {} : { cwd: row.fCwd },
+		isSeeded: row.fSeedLength !== null,
+		...row.fSeedLength === null ? {} : { inheritedEventCount: SessionLogOffset(row.fSeedLength) }
+	};
+}
+function seqCursor(seq) {
+	return seq === -1 ? -1 : SessionSeq(seq);
+}
+function createStorageRepository(host) {
+	const records = storageRecords.table(host.database);
+	const projcache = sessionProjcacheRows.table(host.database);
+	const sessionRows = sessions.table(host.database);
+	const units = storageUnits.table(host.database);
+	/** 读一个域的 global（空表名那一行）；没有就返回 `null`（域层据此用 initial）。 */
+	async function readGlobal(domain) {
+		for await (const row of records.select({ value: records.column("f_value") }).where(E.and(E.eq(records.f_domain, domain), E.eq(records.f_table, GLOBAL_TABLE)))) return JSON.parse(row.value);
+		return null;
+	}
+	const GLOBAL_TABLE = "";
+	const WORKSPACE_DOMAIN = "workspace";
+	const WORKSPACE_TABLE = "workspaces";
+	async function syncSessionFlags(database, state) {
+		const table = sessions.table(database);
+		const pinned = state.pinnedSessionIds ?? [];
+		await table.update({ f_pinned_seq: null }, E.isNotNull(table.f_pinned_seq));
+		for (const [position, sessionId] of pinned.entries()) await table.update({ f_pinned_seq: position }, E.eq(table.f_session_id, sessionId));
+		const archived = state.archivedSessionIds;
+		await table.update({ f_archived_at: null }, E.isNotNull(table.f_archived_at));
+		const stamp = Date.now();
+		for (const sessionId of archived) {
+			await table.insertIgnore({
+				f_session_id: sessionId,
+				f_head_event_id: "",
+				f_head_sequence: -1,
+				f_version: SESSION_FORMAT_VERSION,
+				f_created_at: stamp,
+				f_cwd: null,
+				f_parent_session: null,
+				f_seed_length: null,
+				f_origin: null,
+				f_delegation_depth: null,
+				f_incarnation: randomUUID(),
+				f_revision: 0,
+				f_archived_at: stamp
+			}, ["f_session_id"]);
+			await table.update({ f_archived_at: stamp }, E.eq(table.f_session_id, sessionId));
+		}
+	}
+	return {
+		async readUnitVersion(name) {
+			for await (const row of units.select({ version: units.column("f_version") }).where(E.eq(units.f_name, name))) return row.version;
+		},
+		async insertUnitVersion(name, version) {
+			await host.writeAtomically(async () => {
+				await units.insertIgnore({
+					f_name: name,
+					f_version: version
+				}, ["f_name"]);
+			});
+		},
+		async listDomainRecords(domain) {
+			const result = [];
+			for await (const row of records.select({
+				table: records.column("f_table"),
+				key: records.column("f_key"),
+				value: records.column("f_value")
+			}).where(E.eq(records.f_domain, domain))) {
+				if (row.table === "") continue;
+				result.push({
+					table: row.table,
+					key: row.key,
+					value: JSON.parse(row.value)
+				});
+			}
+			return result;
+		},
+		async readDomainGlobal(domain) {
+			return await readGlobal(domain);
+		},
+		async putDomainRecord(domain, table, key, value) {
+			await host.writeAtomically(async () => {
+				await records.upsert({
+					f_domain: domain,
+					f_table: table,
+					f_key: key,
+					f_value: JSON.stringify(value)
+				}, [
+					"f_domain",
+					"f_table",
+					"f_key"
+				], ["f_value"]);
+			});
+		},
+		async deleteDomainRecord(domain, table, key) {
+			await host.writeAtomically(async () => {
+				await records.delete(E.and(E.eq(records.f_domain, domain), E.eq(records.f_table, table), E.eq(records.f_key, key)));
+			});
+		},
+		async deleteDomainRecords(domain, table, keys) {
+			if (keys.length === 0) return;
+			await host.writeAtomically(async () => {
+				await records.delete(E.and(E.eq(records.f_domain, domain), E.eq(records.f_table, table), E.inList(records.f_key, [...new Set(keys)])));
+			});
+		},
+		async writeDomainGlobal(domain, value) {
+			await host.writeAtomically(async () => {
+				await records.upsert({
+					f_domain: domain,
+					f_table: "",
+					f_key: "",
+					f_value: JSON.stringify(value)
+				}, [
+					"f_domain",
+					"f_table",
+					"f_key"
+				], ["f_value"]);
+				if (domain === WORKSPACE_DOMAIN) await syncSessionFlags(host.database, value);
+			});
+		},
+		async listWorkspaceIndex() {
+			const rows = [];
+			for await (const row of records.select({
+				key: records.column("f_key"),
+				value: records.column("f_value")
+			}).where(E.and(E.eq(records.f_domain, WORKSPACE_DOMAIN), E.eq(records.f_table, WORKSPACE_TABLE)))) rows.push({
+				id: row.key,
+				record: JSON.parse(row.value)
+			});
+			const state = await readGlobal(WORKSPACE_DOMAIN);
+			const order = new Map((state?.workspaceIds ?? []).map((id, position) => [String(id), position]));
+			return rows.sort((left, right) => (order.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (order.get(right.id) ?? Number.MAX_SAFE_INTEGER)).map(({ id, record }) => ({
+				id,
+				title: record.title,
+				sessionIds: [...record.sessionIds]
+			}));
+		},
+		async loadProjcache() {
+			const entries = /* @__PURE__ */ new Map();
+			for await (const row of sessionRows.select({
+				sessionId: sessionRows.f_session_id,
+				version: sessionRows.f_version,
+				createdAt: sessionRows.f_created_at,
+				cwd: sessionRows.f_cwd,
+				seedLength: sessionRows.f_seed_length,
+				title: sessionRows.f_title,
+				titleSeq: sessionRows.f_title_seq
+			})) entries.set(row.sessionId, {
+				sessionId: SessionId(row.sessionId),
+				identity: identityOfSession({
+					fVersion: row.version,
+					fCreatedAt: Number(row.createdAt),
+					fCwd: row.cwd,
+					fSeedLength: row.seedLength
+				}),
+				rows: {},
+				...typeof row.title === "string" && typeof row.titleSeq === "number" ? { title: {
+					title: row.title,
+					seq: row.titleSeq
+				} } : {}
+			});
+			if (entries.size === 0) return [];
+			for await (const row of projcache.select({
+				sessionId: projcache.f_session_id,
+				key: projcache.f_key,
+				ver: projcache.f_ver,
+				seq: projcache.f_seq,
+				val: projcache.f_val
+			})) {
+				const entry = entries.get(row.sessionId);
+				if (entry === void 0) continue;
+				entry.rows[row.key] = {
+					ver: row.ver,
+					seq: seqCursor(row.seq),
+					val: JSON.parse(row.val)
+				};
+			}
+			return [...entries.values()].filter((entry) => Object.keys(entry.rows).length > 0);
+		},
+		async readSessionTitle(sessionId) {
+			const table = sessions.table(host.database);
+			for await (const row of table.select({
+				title: table.f_title,
+				seq: table.f_title_seq
+			}).where(E.eq(table.f_session_id, sessionId))) return row.title === null || row.seq === null ? void 0 : {
+				title: row.title,
+				seq: row.seq
+			};
+		},
+		async putProjcache(sessionId, rows) {
+			const values = Object.entries(rows).map(([key, row]) => ({
+				f_session_id: sessionId,
+				f_key: key,
+				f_ver: row.ver,
+				f_seq: row.seq,
+				f_val: JSON.stringify(row.val)
+			}));
+			await host.writeAtomically(async () => {
+				await projcache.delete(E.eq(projcache.f_session_id, sessionId));
+				if (values.length > 0) await projcache.insertMany(values);
+			});
+		},
+		async patchProjcache(sessionId, changed, removedKeys) {
+			const values = Object.entries(changed).map(([key, row]) => ({
+				f_session_id: sessionId,
+				f_key: key,
+				f_ver: row.ver,
+				f_seq: row.seq,
+				f_val: JSON.stringify(row.val)
+			}));
+			const touched = [...Object.keys(changed), ...removedKeys];
+			if (touched.length === 0) return;
+			await host.writeAtomically(async () => {
+				await projcache.delete(E.and(E.eq(projcache.f_session_id, sessionId), E.inList(projcache.f_key, touched)));
+				if (values.length > 0) await projcache.insertMany(values);
+			});
+		},
+		async pruneStaleProjcache() {
+			const stale = [];
+			for await (const row of projcache.select({ sessionId: projcache.f_session_id }).where(E.and(E.lt(projcache.f_seq, 0), E.inSubquery(projcache.f_session_id, sessionRows.select({ id: sessionRows.f_session_id }).where(E.gte(sessionRows.f_head_sequence, 0)).toFragment())))) stale.push(row.sessionId);
+			if (stale.length === 0) return 0;
+			await host.writeAtomically(async () => {
+				await projcache.delete(E.inList(projcache.f_session_id, stale));
+			});
+			return stale.length;
+		}
+	};
+}
+// src/migrations.ts
+const legacyWorkspaces = defineTable({
+	name: "t_workspaces",
+	columns: {
+		f_workspace_id: {
+			type: "text",
+			primaryKey: true
+		},
+		f_path: { type: "text" },
+		f_title: { type: "text" },
+		f_created_at: { type: "text" },
+		f_updated_at: { type: "text" },
+		f_position: { type: "integer" }
+	}
+});
+const legacyLinks = defineTable({
+	name: "t_workspace_sessions",
+	columns: {
+		f_workspace_id: { type: "text" },
+		f_session_id: { type: "text" },
+		f_position: { type: "integer" }
+	}
+});
+const legacyWorkspaceState = defineTable({
+	name: "t_workspace_state",
+	columns: {
+		f_singleton: {
+			type: "integer",
+			primaryKey: true
+		},
+		f_initialized: { type: "integer" },
+		f_pending_operation: { type: "text" },
+		f_pending_workspace_id: { type: "text" }
+	}
+});
+const legacyScheduleTasks = defineTable({
+	name: "t_schedule_tasks",
+	columns: {
+		f_id: {
+			type: "text",
+			primaryKey: true
+		},
+		f_session_id: { type: "text" },
+		f_status: { type: "text" },
+		f_record: { type: "text" },
+		f_last_delivery: { type: "text" },
+		f_delivery_history: { type: "text" }
+	}
+});
+const legacyGlobals = defineTable({
+	name: "t_storage_globals",
+	columns: {
+		f_domain: {
+			type: "text",
+			primaryKey: true
+		},
+		f_value: { type: "text" }
+	}
+});
+/**
+* 旧语义表（workspace / schedule / cua 授权域）→ 通用域存储的一次性搬运。
+*
+* 旧表保留可回退；是否搬过由 `t_schema_migrations` 账本决定（只跑一次），不再需要 `t_schema_meta` 标记。
+*/
+function sessionMigrations() {
+	return [{
+		id: "20261028-legacy-domain-storage",
+		up: async (tx) => {
+			const objects = new Set(await tx.objectNames());
+			if (!objects.has(legacyWorkspaces.name)) return false;
+			const workspaces = [];
+			if (objects.has(legacyWorkspaces.name)) {
+				const table = tx.table(legacyWorkspaces);
+				for await (const row of table.select({
+					id: table.f_workspace_id,
+					path: table.f_path,
+					title: table.f_title,
+					createdAt: table.f_created_at,
+					updatedAt: table.f_updated_at,
+					position: table.f_position
+				})) workspaces.push({
+					id: String(row.id),
+					path: String(row.path ?? ""),
+					title: String(row.title ?? ""),
+					createdAt: String(row.createdAt ?? ""),
+					updatedAt: String(row.updatedAt ?? ""),
+					position: Number(row.position ?? 0)
+				});
+			}
+			const links = [];
+			if (objects.has(legacyLinks.name)) {
+				const table = tx.table(legacyLinks);
+				for await (const row of table.select({
+					workspaceId: table.f_workspace_id,
+					sessionId: table.f_session_id,
+					position: table.f_position
+				})) links.push({
+					workspaceId: String(row.workspaceId),
+					sessionId: String(row.sessionId),
+					position: Number(row.position ?? 0)
+				});
+			}
+			let state;
+			if (objects.has(legacyWorkspaceState.name)) {
+				const table = tx.table(legacyWorkspaceState);
+				for await (const row of table.select({
+					initialized: table.f_initialized,
+					pendingOperation: table.f_pending_operation,
+					pendingWorkspaceId: table.f_pending_workspace_id
+				}).where(E.eq(table.f_singleton, 1)).limit(1)) state = {
+					initialized: Number(row.initialized ?? 0),
+					pendingOperation: row.pendingOperation,
+					pendingWorkspaceId: row.pendingWorkspaceId
+				};
+			}
+			const tasks = [];
+			if (objects.has(legacyScheduleTasks.name)) {
+				const table = tx.table(legacyScheduleTasks);
+				for await (const row of table.select({
+					id: table.f_id,
+					sessionId: table.f_session_id,
+					status: table.f_status,
+					record: table.f_record,
+					lastDelivery: table.f_last_delivery,
+					deliveryHistory: table.f_delivery_history
+				})) tasks.push({
+					id: String(row.id),
+					sessionId: String(row.sessionId ?? ""),
+					status: String(row.status ?? ""),
+					record: String(row.record ?? ""),
+					lastDelivery: row.lastDelivery,
+					deliveryHistory: row.deliveryHistory
+				});
+			}
+			const globals = [];
+			if (objects.has(legacyGlobals.name)) {
+				const table = tx.table(legacyGlobals);
+				for await (const row of table.select({
+					domain: table.f_domain,
+					value: table.f_value
+				})) globals.push({
+					domain: String(row.domain),
+					value: JSON.parse(String(row.value))
+				});
+			}
+			const sessionRows = sessions.table(tx);
+			const archived = [];
+			for await (const row of sessionRows.select({ id: sessionRows.f_session_id }).where(E.isNotNull(sessionRows.f_archived_at)).orderBy(sessionRows.f_archived_at)) archived.push(String(row.id));
+			const pinned = [];
+			for await (const row of sessionRows.select({
+				id: sessionRows.f_session_id,
+				seq: sessionRows.f_pinned_seq
+			}).where(E.isNotNull(sessionRows.f_pinned_seq)).orderBy(sessionRows.f_pinned_seq)) pinned.push({
+				id: String(row.id),
+				seq: Number(row.seq)
+			});
+			const storage = createStorageRepository({
+				database: tx,
+				writeAtomically: async (fn) => await fn(tx)
+			});
+			await migrateLegacyDomainStorage({
+				workspaces,
+				links,
+				state,
+				archived,
+				pinned,
+				tasks,
+				globals
+			}, storage);
+		}
+	}];
+}
+// src/db/open.ts
+/**
+* 写事务按介质串行：SQLite 的 `BEGIN IMMEDIATE` 并发会直接 busy，PG 的 `serializable` 并发会冲突；
+* 同一个库（进程内多个实例）共用一条队列。
+*/
+const writeQueues = /* @__PURE__ */ new Map();
+function enqueueWrite(key, fn) {
+	const run = (writeQueues.get(key) ?? Promise.resolve()).then(fn);
+	writeQueues.set(key, run.then(() => void 0, () => void 0));
+	return run;
+}
+/** 打开数据库、对齐结构、跑迁移、落 identity（连接、库身份、回填都在这一步）。 */
+async function openRdbBackend(config) {
+	const schema = config.type === "postgres" ? config.schema ?? "public" : "";
+	const actualPath = config.type === "sqlite" && config.path !== ":memory:" ? resolve(config.path) : void 0;
+	if (actualPath !== void 0) {
+		await mkdir(dirname(actualPath), {
+			recursive: true,
+			mode: 448
+		});
+		try {
+			await (await open(actualPath, "wx", 384)).close();
+			await chmod(actualPath, 384);
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+	const database = await openDatabase(config.type === "sqlite" ? {
+		dialect: "sqlite",
+		path: actualPath ?? config.path,
+		...config.journalMode === void 0 ? {} : { journalMode: config.journalMode },
+		applyJournalMode: false,
+		busyTimeout: config.busyTimeout ?? 5e3,
+		cacheSizeKb: 65536,
+		mmapSize: 268435456
+	} : {
+		dialect: "postgres",
+		connectionString: config.connectionString,
+		...config.schema === void 0 ? {} : { schema: config.schema },
+		isolationLevel: "serializable"
+	});
+	try {
+		let onDisk = 0;
+		if (config.type === "sqlite") {
+			onDisk = Number(await database.sqlitePragma("user_version") ?? 0);
+			const applicationId = Number(await database.sqlitePragma("application_id") ?? 0);
+			if (onDisk !== 0 && onDisk !== 3) throw new Error(`session database at "${config.path}" has schema version ${onDisk}, incompatible with this build (3)`);
+			if (onDisk >= 1 && applicationId !== 1146308688) throw new Error(`session database at "${config.path}" has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
+			if (onDisk === 0) {
+				const objects = await database.objectNames();
+				if (applicationId !== 0 && applicationId !== 1146308688 || objects.length > 0) throw new Error(`session database at "${config.path}" has an unversioned schema or application identity`);
+			}
+		}
+		const writeKey = config.type === "sqlite" ? `sqlite:${config.path}` : `postgres:${config.connectionString}:${schema}`;
+		const inWrite = (fn) => enqueueWrite(writeKey, () => database.transaction(fn));
+		if (actualPath !== void 0) for (const suffix of [
+			"-wal",
+			"-shm",
+			"-journal"
+		]) try {
+			await chmod(`${actualPath}${suffix}`, 384);
+		} catch {}
+		let storeId;
+		await inWrite(async (scoped) => {
+			if (config.type === "sqlite" && onDisk === 0) {
+				await scoped.setSqlitePragma("application_id", SESSION_PERSISTENCE_SQLITE_APPLICATION_ID);
+				await scoped.setSqlitePragma("user_version", 3);
+			}
+			await ensureSchema(scoped, catalog);
+			await runMigrations(scoped, {
+				catalog,
+				migrations: sessionMigrations()
+			});
+			await backfillUsageTables(scoped);
+			const state = persistenceState.table(scoped);
+			await state.insertIgnore({
+				f_singleton: 1,
+				f_store_id: randomUUID()
+			}, ["f_singleton"]);
+			for await (const row of state.select({ storeId: state.f_store_id })) storeId = row.storeId;
+		});
+		if (storeId === void 0 || storeId.length === 0) throw new Error("session database has no valid store identity");
+		if (config.type === "sqlite") await database.setSqlitePragma("journal_mode", (config.journalMode ?? "wal").toLowerCase());
+		const storage = createStorageRepository({
+			database,
+			writeAtomically: (fn) => inWrite((scoped) => fn(scoped))
+		});
+		const storeIdentity = config.type === "sqlite" ? actualPath === void 0 ? `memory:store:${storeId}` : await fileIdentity(actualPath, storeId) : `${config.type}:${config.connectionString}:${schema}:store:${storeId}`;
+		return new RdbBackend({
+			kind: config.type,
+			database,
+			storage,
+			readModel: createReadModel(database),
+			storeIdentity
+		});
+	} catch (error) {
+		await database.close();
+		throw error;
+	}
+}
+/** 库文件身份：`file:dev:ino:birthtimeNs:store:<storeId>`（符号链接指向同一 inode 时身份相同）。 */
+async function fileIdentity(path, storeId) {
+	const identity = await stat(path, { bigint: true });
+	return `file:${identity.dev}:${identity.ino}:${identity.birthtimeNs}:store:${storeId}`;
+}
+export { openRdbBackend as t };

package/dist/organize.d.mts

@@ -0,0 +1,9 @@
+import { H as SESSION_ORGANIZE_PATH, k as SessionPersistenceRdb } from "./backend-BKtJ5sO5.mjs";
+import { Context } from "@deepseek-ai/cordis";
+/**
+ * 整理数据通道：停 agent → 回收孤儿（会话 / 事件行）→ 重算派生统计 → VACUUM。
+ *
+ * 不只是清理孤儿：三张派生统计表是可销毁重建的，整理时一并整表重算，修掉旁路累加漏记或旧数据漂移。
+ */
+export declare function registerSessionOrganize(ctx: Context, persistence: SessionPersistenceRdb): void;
+export { SESSION_ORGANIZE_PATH };

package/dist/organize.mjs

@@ -0,0 +1,30 @@
+import { n as mountJsonRoute, s as SESSION_ORGANIZE_PATH } from "./route-DpfY0zq-.mjs";
+// src/organize.ts
+async function stopRunningAgents(ctx) {
+	const running = ctx.get("agents")?.list() ?? [];
+	for (const agent of running) agent.cancel?.({ kind: "user" }, { keepInbox: true });
+	await Promise.all(running.map((agent) => agent.whenIdle()));
+	return running.length;
+}
+/**
+* 整理数据通道：停 agent → 回收孤儿（会话 / 事件行）→ 重算派生统计 → VACUUM。
+*
+* 不只是清理孤儿：三张派生统计表是可销毁重建的，整理时一并整表重算，修掉旁路累加漏记或旧数据漂移。
+*/
+function registerSessionOrganize(ctx, persistence) {
+	mountJsonRoute(ctx, {
+		path: SESSION_ORGANIZE_PATH,
+		handle: async () => {
+			const stoppedAgents = await stopRunningAgents(ctx);
+			const { orphanSessions, orphanEvents, rebuiltSessions } = await persistence.organize();
+			return { body: {
+				stoppedAgents,
+				orphanSessions,
+				orphanEvents,
+				rebuiltSessions,
+				vacuumed: true
+			} };
+		}
+	});
+}
+export { SESSION_ORGANIZE_PATH, registerSessionOrganize };