dsh-diff-approval 0.13.1 → 0.14.1

package/lib/index.js

@@ -1,5 +1,4 @@
-import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, resolve, sep } from "node:path";
 import { dshHomePath, expandHomePath } from "@deepseek-ai/dsh-home-paths";
 import { SessionId } from "@deepseek-ai/dsh-session";
@@ -7,51 +6,40 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 //#region lib/types/pending.js
 /**
-* In-memory pending-diff store: one entry per (session, path), holding the
-* file's full set of unhandled changes as one cumulative span. Every later
-* operation to a tracked path folds into its entry — `oldText` stays the
-* earliest basis, `newText` takes the latest content — even when the chain
-* breaks (an outside writer changed the file between operations): the list
-* still shows one element per file. Pure state and transitions; the plugin
+* In-memory pending-diff store: one entry per file path, globally, holding the
+* file's full set of unhandled changes as one cumulative span (earliest basis →
+* latest content) across every session and workspace that touched it. Every
+* later operation to a tracked path folds into its entry — `oldText` stays the
+* earliest basis, `newText` takes the latest content, and the touching sessions
+* accumulate in `sessionIds` — even when the chain breaks (an outside writer
+* changed the file between operations). Pure state and transitions; the plugin
 * body owns the `tools/result` observation, the RPC surface, and the
 * filesystem I/O.
 * @module dsh-diff-approval/src/pending
 */
-/** Map key joining one session id and one entry id. */
-function entryKey(sessionId, id) {
-	return `${String(sessionId)}\u0000${id}`;
+/** Map key: the file path (the single global identity of a pending change). */
+function pathKeyOf(path) {
+	return path;
 }
-/** Map key joining one session id and one path, indexing the path's current entry. */
-function pathKey(sessionId, path) {
-	return `${String(sessionId)}\u0000${path}`;
+/** The session ids an entry was touched by (tolerant of legacy rows without the field). */
+function touchedBy(entry) {
+	if (Array.isArray(entry.sessionIds) && entry.sessionIds.length > 0) return entry.sessionIds;
+	return [entry.sessionId];
 }
 /** Whether a merge changed nothing (a repeated operation is a no-op). */
 function sameEntry(left, right) {
-	return left.path === right.path && left.kind === right.kind && left.oldText === right.oldText && left.newText === right.newText && left.updatedAt === right.updatedAt;
+	const lIds = touchedBy(left);
+	const rIds = touchedBy(right);
+	return left.path === right.path && left.kind === right.kind && left.oldText === right.oldText && left.newText === right.newText && left.updatedAt === right.updatedAt && left.sessionId === right.sessionId && lIds.length === rIds.length && lIds.every((id, index) => id === rIds[index]);
 }
 /**
-* The pending-diff store. Keep/Revert decides one whole file at a time.
+* The pending-diff store: one entry per file path across all sessions. Keep /
+* Revert decides one whole file at a time.
 */
 var PendingDiffStore = class {
 	entries = /* @__PURE__ */ new Map();
-	pathIndex = /* @__PURE__ */ new Map();
-	/** Merge one operation into the store, keyed by (session, path). */
-	merge(entry) {
-		const key = pathKey(entry.sessionId, entry.path);
-		const currentId = this.pathIndex.get(key);
-		const current = currentId === void 0 ? void 0 : this.entries.get(entryKey(entry.sessionId, currentId));
-		const merged = current === void 0 ? { ...entry } : {
-			...current,
-			newText: entry.newText,
-			updatedAt: entry.updatedAt
-		};
-		if (current !== void 0 && sameEntry(current, merged)) return false;
-		this.entries.set(entryKey(entry.sessionId, merged.id), merged);
-		this.pathIndex.set(key, merged.id);
-		return true;
-	}
 	/**
-	* Fold one captured operation into its file's entry. A no-op (equal before
+	* Merge one captured operation into its file's entry. A no-op (equal before
 	* and after) folds nothing.
 	* @param entry - the captured operation (id assigned by the caller).
 	* @returns whether the stored entry changed.
@@ -60,103 +48,105 @@ var PendingDiffStore = class {
 		if (entry.oldText === entry.newText) return false;
 		return this.merge(entry);
 	}
+	/** Fold a captured entry into the path's single global entry. */
+	merge(entry) {
+		const current = this.entries.get(pathKeyOf(entry.path));
+		const merged = current === void 0 ? { ...entry } : this.mergeEntry(current, entry);
+		if (current !== void 0 && sameEntry(current, merged)) return false;
+		this.entries.set(pathKeyOf(merged.path), merged);
+		return true;
+	}
 	/**
-	* Merge persisted entries into the store, one per path after folding. An
-	* already-keyed live entry wins over a persisted one: the live entry is
-	* newer by construction (it was captured after the persisted state was
-	* written), so the path's whole persisted run is skipped.
-	* @param sessionId - the session the entries belong to.
-	* @param entries - persisted entries, oldest capture first, to fold in.
+	* Combine a stored entry and a new capture. `oldText` comes from the earlier
+	* capture (the file's original basis), `newText` from the later (latest
+	* content), and the session set is the union — so the entry always spans the
+	* whole pending change regardless of which session contributed which part.
 	*/
-	hydrate(sessionId, entries) {
-		const livePaths = new Set(this.pathIndex.keys());
-		for (const entry of entries) {
-			const key = pathKey(sessionId, entry.path);
-			if (livePaths.has(key)) continue;
-			this.merge({
-				...entry,
-				sessionId
-			});
-		}
+	mergeEntry(a, b) {
+		const earlier = a.updatedAt <= b.updatedAt ? a : b;
+		const later = earlier === a ? b : a;
+		const sessionIds = [.../* @__PURE__ */ new Set([...touchedBy(a), b.sessionId])];
+		return {
+			...later,
+			id: later.path,
+			oldText: earlier.oldText,
+			kind: earlier.kind === "create" || later.kind === "create" ? "create" : "edit",
+			sessionIds
+		};
 	}
 	/**
-	* Copy the session's entries, oldest capture first.
-	* @param sessionId - the session whose entries to list.
+	* Copy every entry touching a session (the session's view), oldest capture
+	* first. The file list is session-scoped: an entry appears for each session
+	* that touched it, so a session only sees files it worked on.
+	* @param sessionId - the viewing session.
 	* @returns detached entries in capture order.
 	*/
 	list(sessionId) {
 		const found = [];
-		for (const entry of this.entries.values()) if (entry.sessionId === sessionId) found.push(entry);
+		for (const entry of this.entries.values()) if (touchedBy(entry).includes(sessionId)) found.push(entry);
 		return found.sort((left, right) => left.updatedAt - right.updatedAt);
 	}
+	/** Every entry (all paths, all sessions), oldest capture first. */
+	all() {
+		return [...this.entries.values()].sort((left, right) => left.updatedAt - right.updatedAt);
+	}
 	/**
-	* Read one entry without removing it.
-	* @param sessionId - the owning session.
-	* @param id - the entry id.
-	* @returns the entry, or `undefined` when the pair has none.
+	* Read one path's entry without removing it.
+	* @param path - the file path (the global entry key).
+	* @returns the entry, or `undefined` when none is tracked.
 	*/
-	get(sessionId, id) {
-		return this.entries.get(entryKey(sessionId, id));
+	get(path) {
+		return this.entries.get(pathKeyOf(path));
 	}
 	/**
-	* Remove one entry.
-	* @param sessionId - the owning session.
-	* @param id - the entry id.
+	* Remove one path's entry.
+	* @param path - the file path.
 	* @returns whether an entry was removed.
 	*/
-	remove(sessionId, id) {
-		if (!this.entries.delete(entryKey(sessionId, id))) return false;
-		for (const [key, indexedId] of this.pathIndex) if (indexedId === id) this.pathIndex.delete(key);
-		return true;
+	remove(path) {
+		return this.entries.delete(pathKeyOf(path));
 	}
 	/**
 	* Advance one entry's tracked content after a block-level keep/revert. The
-	* entry keeps its id and path; only the given side's text and capture time
-	* move. When the caller decides the sides now match, it removes the entry
-	* instead of updating it.
-	* @param sessionId - the owning session.
-	* @param id - the entry id.
+	* entry keeps its path; only the given side's text and capture time move.
+	* @param path - the file path.
 	* @param patch - the side to advance (`oldText` for keep, `newText` for revert).
 	* @returns whether the entry changed.
 	*/
-	update(sessionId, id, patch) {
-		const key = entryKey(sessionId, id);
-		const entry = this.entries.get(key);
+	update(path, patch) {
+		const entry = this.entries.get(pathKeyOf(path));
 		if (entry === void 0) return false;
 		const next = {
 			...entry,
 			...patch,
 			updatedAt: Date.now()
 		};
-		this.entries.set(key, next);
+		this.entries.set(pathKeyOf(path), next);
 		return true;
 	}
 	/**
 	* Restore one entry exactly as given (an undo/redo replays a snapshot). The
-	* entry is inserted or replaced by id, and the path index points at it so a
-	* later capture folds into the restored entry. The store keeps one entry per
-	* path: restoring an entry for a path that a DIFFERENT entry currently owns
-	* drops that occupant first, so an undo can never leave two list items for
-	* the same file (e.g. an imported entry and a replayed keep of the same path).
-	* @param sessionId - the owning session.
+	* entry is inserted or replaced by path.
 	* @param entry - the entry state to restore.
 	* @returns whether the store changed.
 	*/
-	restore(sessionId, entry) {
-		const key = entryKey(sessionId, entry.id);
+	restore(entry) {
+		const key = pathKeyOf(entry.path);
 		const existing = this.entries.get(key);
 		if (existing !== void 0 && sameEntry(existing, entry)) return false;
-		const pathKey_ = pathKey(sessionId, entry.path);
-		const occupantId = this.pathIndex.get(pathKey_);
-		if (occupantId !== void 0 && occupantId !== entry.id) this.entries.delete(entryKey(sessionId, occupantId));
-		this.entries.set(key, {
-			...entry,
-			sessionId
-		});
-		this.pathIndex.set(pathKey_, entry.id);
+		this.entries.set(key, { ...entry });
 		return true;
 	}
-	/** Total entry count across all sessions. */
+	/**
+	* Merge persisted entries into the store, one per path after folding. A live
+	* entry wins over a persisted one only when its time is newer (folders are
+	* applied in capture order, so a later persisted capture is strictly newer).
+	* @param entries - persisted entries, oldest capture first, to fold in.
+	*/
+	hydrate(entries) {
+		for (const entry of entries) this.merge({ ...entry });
+	}
+	/** Total entry count (one per tracked file path). */
 	get size() {
 		return this.entries.size;
 	}
@@ -164,182 +154,202 @@ var PendingDiffStore = class {
 //#endregion
 //#region lib/types/persist.js
 /**
-* Durable pending-entry persistence under the harness home. One JSON file per
-* workspace holds every session's entries, at
-* `<storageDir>/<workspaceId>.json`; the default root is
-* `<dshHome>/diff-approval/workspaces` and the plugin's `storageDir` config
-* relocates it. `save` rewrites the whole workspace file so sibling sessions
-* survive; a session with no entries leaves the file, and a workspace with no
-* sessions loses its file. Writes are serialized per file, staged as a
-* sibling temp file, and atomically renamed, so a crash leaves either the old
-* or the new file. Missing files read as empty; corrupt content and unknown
-* versions throw so the caller can fail loud instead of silently dropping
-* persisted data.
+* Durable pending-entry persistence under the harness home: one global JSON
+* file holding one entry per file path (across all sessions and workspaces), at
+* `<storageDir>/pending.json`; the default root is `<dshHome>/diff-approval/workspaces`
+* and the plugin's `storageDir` config relocates it. Saves rewrite the whole
+* file (the entry set is small), staged as a sibling temp file and atomically
+* renamed, so a crash leaves either the old or the new file. A missing file
+* reads as empty; corrupt content and unknown versions throw.
+*
+* Legacy layout: the pre-global schema stored one JSON file per workspace
+* (`<storageDir>/<workspaceId>.json`, `{ version: 2, sessions: { [sessionId]:
+* PendingEntry[] } }`). On first load without a global file, `loadAll` scans for
+* those files, flattens every session's entries, and reports them so the caller
+* can fold them into the global store once; `save` then writes the global file
+* and deletes the legacy files.
 * @module dsh-diff-approval/src/persist
 */
 /** Default persistence root: this plugin's own directory under the harness home. */
 function defaultStorageDir() {
 	return dshHomePath("diff-approval", "workspaces");
 }
-/** On-disk envelope version; bumping it abandons older files (pre-release stance). */
-const FILE_VERSION = 2;
+/** Global-file version (post per-workspace schema). */
+const FILE_VERSION = 3;
+/** Legacy per-workspace-file version, accepted only for migration. */
+const LEGACY_FILE_VERSION = 2;
 /** Narrow one JSON value to a pending entry; malformed rows are skipped. */
 function pendingEntryOf(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-	const { id, sessionId, path, kind, oldText, newText, updatedAt } = value;
+	const { id, path, kind, oldText, newText, updatedAt, sessionId, sessionIds } = value;
 	if (typeof id !== "string" || id.length === 0) return void 0;
-	if (typeof sessionId !== "string" || sessionId.length === 0) return void 0;
 	if (typeof path !== "string" || path.length === 0) return void 0;
 	if (kind !== "edit" && kind !== "create") return void 0;
 	if (typeof oldText !== "string" || typeof newText !== "string") return void 0;
 	if (typeof updatedAt !== "number") return void 0;
+	if (typeof sessionId !== "string" || sessionId.length === 0) return void 0;
+	const ids = Array.isArray(sessionIds) ? sessionIds.filter((value) => typeof value === "string" && value.length > 0) : [];
 	return {
-		id,
-		sessionId,
+		id: path,
 		path,
 		kind,
 		oldText,
 		newText,
-		updatedAt
+		updatedAt,
+		sessionId,
+		sessionIds: ids.length > 0 ? ids : [sessionId]
 	};
 }
-/**
-* Validate a parsed workspace file. Missing files yield `undefined` (empty);
-* anything else that is not a current-version workspace file throws so a
-* later save cannot silently overwrite unreadable persisted data.
-* @param file - the file path, for the error message.
-* @param value - the parsed JSON value.
-* @returns the validated file, or `undefined` when the file does not exist.
-*/
-function workspaceFileOf(file, value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`pending persistence file '${file}' is not a workspace file`);
-	const { version, sessions } = value;
+/** Validate a parsed global file. */
+function globalFileOf(file, value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`pending persistence file '${file}' is not a global file`);
+	const { version, entries } = value;
 	if (version !== FILE_VERSION) throw new Error(`pending persistence file '${file}' has unsupported version ${JSON.stringify(version)}`);
-	if (typeof sessions !== "object" || sessions === null || Array.isArray(sessions)) throw new Error(`pending persistence file '${file}' has no session map`);
+	if (!Array.isArray(entries)) throw new Error(`pending persistence file '${file}' has no entry list`);
 	return {
 		version,
-		sessions
+		entries
 	};
 }
+/** Read one file's content; `undefined` when absent (the normal empty state). */
+async function readJson(file) {
+	let raw;
+	try {
+		raw = await readFile(file, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (error) {
+		throw new Error(`pending persistence file '${file}' is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/** Stage a JSON envelope as a sibling temp file and atomically rename it into place. */
+async function writeJson(file, value) {
+	await mkdir(dirName(file), { recursive: true });
+	const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+	await writeFile(tmp, JSON.stringify(value), "utf8");
+	try {
+		await rename(tmp, file);
+	} catch (error) {
+		await rm(tmp, { force: true }).catch(() => {});
+		throw error;
+	}
+}
+function dirName(file) {
+	const index = file.lastIndexOf("/");
+	return index < 0 ? "." : file.slice(0, index);
+}
 /**
-* File-backed pending entries keyed by (workspace, session).
+* File-backed pending entries, one global file keyed by path.
 */
 var PendingPersistence = class {
 	root;
 	tails = /* @__PURE__ */ new Map();
+	globalFile;
 	/**
-	* @param root - directory holding one JSON file per workspace.
+	* @param root - directory holding the global `pending.json` (and, pre-migration,
+	* one JSON file per workspace).
 	*/
 	constructor(root) {
 		this.root = root;
-	}
-	fileOf(workspaceId) {
-		return join(this.root, `${workspaceId}.json`);
-	}
-	/** Read one workspace file; a missing file reads as empty. */
-	async readWorkspace(file) {
-		let raw;
-		try {
-			raw = await readFile(file, "utf8");
-		} catch (error) {
-			if (error.code === "ENOENT") return void 0;
-			throw error;
-		}
-		let parsed;
-		try {
-			parsed = JSON.parse(raw);
-		} catch (error) {
-			throw new Error(`pending persistence file '${file}' is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		return workspaceFileOf(file, parsed);
-	}
-	/** Stage the envelope as a sibling temp file and atomically rename it into place. */
-	async writeWorkspace(file, envelope) {
-		await mkdir(this.root, { recursive: true });
-		const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-		await writeFile(tmp, JSON.stringify(envelope), "utf8");
-		try {
-			await rename(tmp, file);
-		} catch (error) {
-			await rm(tmp, { force: true }).catch(() => {});
-			throw error;
-		}
+		this.globalFile = join(root, "pending.json");
 	}
 	/**
-	* Load one session's entries from its workspace file, oldest capture first.
-	* @param workspaceId - the owning workspace's stable id.
-	* @param sessionId - the session whose entries to load.
-	* @returns the persisted entries; empty when none were saved.
+	* Load every persisted entry. Returns the global file's entries, or — when the
+	* global file is absent — flattens the legacy per-workspace files so the
+	* caller can fold them once and then save (which clears the legacy files).
+	* @returns the entries plus whether they came from the legacy layout (awaiting
+	* a save to finalize the migration).
 	*/
-	async load(workspaceId, sessionId) {
-		const envelope = await this.readWorkspace(this.fileOf(workspaceId));
-		if (envelope === void 0) return [];
-		const rows = envelope.sessions[String(sessionId)];
-		if (!Array.isArray(rows)) return [];
-		const entries = [];
-		for (const row of rows) {
-			const entry = pendingEntryOf(row);
-			if (entry !== void 0) entries.push(entry);
-		}
-		return entries.sort((left, right) => left.updatedAt - right.updatedAt);
-	}
-	/**
-	* Load every session's entries for one workspace, oldest capture first.
-	* The list shows a workspace's pending changes across sessions — a session
-	* that restarted carries a fresh id while its earlier entries sit under the
-	* original session ids in the same workspace file — so hydration reads the
-	* whole workspace, not one session.
-	* @param workspaceId - the owning workspace's stable id.
-	* @returns the persisted entries across all sessions; empty when none were saved.
-	*/
-	async loadWorkspace(workspaceId) {
-		const envelope = await this.readWorkspace(this.fileOf(workspaceId));
-		if (envelope === void 0) return [];
-		const entries = [];
-		for (const sessionId of Object.keys(envelope.sessions)) {
-			const rows = envelope.sessions[sessionId];
-			if (!Array.isArray(rows)) continue;
-			for (const row of rows) {
+	async loadAll() {
+		const global = await readJson(this.globalFile);
+		if (global !== void 0) {
+			const parsed = globalFileOf(this.globalFile, global);
+			const entries = [];
+			for (const row of parsed.entries) {
 				const entry = pendingEntryOf(row);
 				if (entry !== void 0) entries.push(entry);
 			}
+			return {
+				entries: entries.sort((l, r) => l.updatedAt - r.updatedAt),
+				migratedLegacy: false
+			};
 		}
-		return entries.sort((left, right) => left.updatedAt - right.updatedAt);
+		const legacy = await collectLegacy(this.root);
+		if (legacy.length > 0) return {
+			entries: legacy.sort((l, r) => l.updatedAt - r.updatedAt),
+			migratedLegacy: true
+		};
+		return {
+			entries: [],
+			migratedLegacy: false
+		};
 	}
 	/**
-	* Replace one session's entries durably. Saves to one file are serialized;
-	* a previous save's failure does not block the next one.
-	* @param workspaceId - the owning workspace's stable id.
-	* @param sessionId - the session whose entries to replace.
-	* @param entries - the session's complete entry list, possibly empty.
+	* Replace the persisted entry set durably. Saves to the one file are
+	* serialized; a previous save's failure does not block the next one. On a
+	* legacy migration this also removes the per-workspace files.
+	* @param entries - the complete entry list, possibly empty.
 	* @returns resolution after the file is durable.
 	*/
-	save(workspaceId, sessionId, entries) {
-		const file = this.fileOf(workspaceId);
+	save(entries) {
 		const task = async () => {
-			const envelope = await this.readWorkspace(file);
-			if (entries.length === 0) {
-				if (envelope === void 0) return;
-				delete envelope.sessions[String(sessionId)];
-				if (Object.keys(envelope.sessions).length === 0) {
-					await rm(file, { force: true });
-					return;
-				}
-				await this.writeWorkspace(file, envelope);
-				return;
-			}
-			const next = envelope ?? {
+			await writeJson(this.globalFile, {
 				version: FILE_VERSION,
-				sessions: {}
-			};
-			next.sessions[String(sessionId)] = [...entries];
-			await this.writeWorkspace(file, next);
+				entries
+			});
+			await removeLegacy(this.root);
 		};
-		const run = (this.tails.get(file) ?? Promise.resolve()).then(task, task);
-		this.tails.set(file, run.catch(() => {}));
+		const run = (this.tails.get(this.globalFile) ?? Promise.resolve()).then(task, task);
+		this.tails.set(this.globalFile, run.catch(() => {}));
 		return run;
 	}
 };
+/** Flatten every legacy per-workspace file's entries (adding `sessionIds`). */
+async function collectLegacy(root) {
+	let names;
+	try {
+		names = await readdir(root);
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	const entries = [];
+	for (const name of names) {
+		if (name === "pending.json" || !name.endsWith(".json")) continue;
+		const value = await readJson(join(root, name));
+		if (value === void 0) continue;
+		if (typeof value !== "object" || value === null) continue;
+		const { version, sessions } = value;
+		if (version !== LEGACY_FILE_VERSION) continue;
+		if (typeof sessions !== "object" || sessions === null) continue;
+		for (const sessionId of Object.keys(sessions)) {
+			const rows = sessions[sessionId];
+			if (!Array.isArray(rows)) continue;
+			for (const row of rows) {
+				const entry = pendingEntryOf(row);
+				if (entry !== void 0) entries.push(entry);
+			}
+		}
+	}
+	return entries;
+}
+/** Delete the legacy per-workspace files (post-migration cleanup). */
+async function removeLegacy(root) {
+	let names;
+	try {
+		names = await readdir(root);
+	} catch {
+		return;
+	}
+	for (const name of names) {
+		if (name === "pending.json" || !name.endsWith(".json")) continue;
+		await rm(join(root, name), { force: true }).catch(() => {});
+	}
+}
 //#endregion
 //#region lib/types/open.js
 /**
@@ -819,11 +829,20 @@ function apply(ctx, config) {
 	const store = new PendingDiffStore();
 	const persistence = new PendingPersistence(resolve(expandHomePath(storageDir ?? defaultStorageDir())));
 	const launchPath = config?.openPath ?? defaultOpenPath;
-	/** Sessions seen per workspace, so the list can merge a workspace's sessions. */
-	const sessionsByWorkspace = /* @__PURE__ */ new Map();
-	/** Workspace ids whose persisted state has been hydrated into the store. */
-	const loadedWorkspaces = /* @__PURE__ */ new Set();
-	const loadingWorkspaces = /* @__PURE__ */ new Map();
+	/** Hydrate the globally-unique store once from the single persistence file. */
+	let loadPromise;
+	const ensureLoaded = () => {
+		loadPromise ??= (async () => {
+			try {
+				const { entries, migratedLegacy } = await persistence.loadAll();
+				if (entries.length > 0) store.hydrate(entries);
+				if (migratedLegacy) await persistence.save(store.all());
+			} catch (error) {
+				ctx.logger.warn(`diff-approval: loading persisted state failed: ${errorMessage(error)}`);
+			}
+		})();
+		return loadPromise;
+	};
 	/** Pre-write bases captured at the intent seams, keyed by the tool call id. */
 	const editorIntents = /* @__PURE__ */ new Map();
 	/**
@@ -881,17 +900,19 @@ function apply(ctx, config) {
 		}
 		if (basis.kind === "edit" && after === basis.before) return;
 		const sessionId = basis.sessionId;
+		const path = basis.target.displayPath;
 		const entry = {
-			id: randomUUID(),
+			id: path,
 			sessionId,
-			path: basis.target.displayPath,
+			path,
 			kind: basis.kind,
 			oldText: basis.before,
 			newText: after,
-			updatedAt: Date.now()
+			updatedAt: Date.now(),
+			sessionIds: [sessionId]
 		};
-		await ensureLoaded(sessionId);
-		if (store.fold(entry)) await persistSession(sessionId);
+		await ensureLoaded();
+		if (store.fold(entry)) persistSession();
 	}
 	/** The stable `FsError.code`, when the thrown value carries one. */
 	function fsErrorCodeOf(error) {
@@ -935,20 +956,20 @@ function apply(ctx, config) {
 	* @param entries - the store's entries for one session.
 	* @returns entries with `missing` and `diverged` set from the live file.
 	*/
-	/** Drop every undo/redo pair that belongs to a removed entry, so the LIFO
+	/** Drop every undo/redo pair that belongs to a removed file, so the LIFO
 	* queue stays traversable without ever trying to restore an unreadable file. */
-	function purgeForEntry(sessionId, entryId, path) {
-		const key = String(sessionId);
-		for (const stacks of [undoStacks, redoStacks]) {
-			const stack = stacks.get(key);
-			if (stack === void 0) continue;
-			stacks.set(key, stack.filter((pair) => {
-				const touches = (state) => state.id === entryId || state.path === path;
+	function purgeForEntry(path) {
+		const clean = (stack) => {
+			const kept = stack.filter((pair) => {
 				const batch = pair.before.batch ?? pair.after.batch;
-				if (batch !== void 0) return !batch.some((item) => item.id === entryId || item.path === path);
-				return !touches(pair.before) && !touches(pair.after);
-			}));
-		}
+				if (batch !== void 0) return !batch.some((item) => item.path === path);
+				return pair.before.path !== path && pair.after.path !== path;
+			});
+			stack.length = 0;
+			stack.push(...kept);
+		};
+		clean(undoStack);
+		clean(redoStack);
 	}
 	/**
 	* Settle each listed entry against its live file. Existence is decided by the
@@ -956,82 +977,70 @@ function apply(ctx, config) {
 	* (Ctrl+Z recreates it and restores the entry), an unavailable one leaves the
 	* list and has its undo/redo records dropped, and externally changed content
 	* is adopted as the new baseline with its own checkpoint.
-	* @param sessionId - the session being listed.
-	* @param entries - the store's entries for one session.
+	* @param sessionId - the session being listed (its session-scoped view).
 	* @returns the listed entries plus whether an external change cleared redo.
 	*/
-	async function listWithState(sessionId, entries) {
-		const byPath = /* @__PURE__ */ new Map();
-		for (const entry of entries) {
-			const group = byPath.get(entry.path);
-			if (group === void 0) byPath.set(entry.path, [entry]);
-			else group.push(entry);
-		}
+	async function listWithState(sessionId) {
 		const listed = [];
 		let redoCleared = false;
-		for (const group of byPath.values()) {
-			const newest = group[group.length - 1];
-			if (newest === void 0) continue;
-			const live = await liveStateOf(newest.path);
+		for (const entry of store.list(sessionId)) {
+			const live = await liveStateOf(entry.path);
 			if (live.kind === "deleted") {
-				store.remove(sessionId, newest.id);
+				store.remove(entry.path);
 				pushUndo(sessionId, {
-					id: newest.id,
-					path: newest.path,
-					entry: newest,
-					fileText: newest.newText
+					id: entry.path,
+					path: entry.path,
+					entry,
+					fileText: entry.newText
 				}, {
-					id: newest.id,
-					path: newest.path,
+					id: entry.path,
+					path: entry.path,
 					entry: void 0,
 					fileText: void 0
 				});
-				await persistSession(sessionId);
+				persistSession();
 				continue;
 			}
 			if (live.kind === "unavailable") {
-				store.remove(sessionId, newest.id);
-				purgeForEntry(sessionId, newest.id, newest.path);
-				await persistSession(sessionId);
+				store.remove(entry.path);
+				purgeForEntry(entry.path);
+				persistSession();
 				continue;
 			}
 			const content = live.content;
-			let adopted = newest.newText;
+			let adopted = entry.newText;
 			const hasContent = typeof content === "string";
-			if (hasContent && content !== newest.newText) {
+			if (hasContent && content !== entry.newText) {
 				adopted = content;
-				const beforeText = newest.newText;
-				const redoWasPresent = redoStacks.has(String(sessionId));
-				store.update(sessionId, newest.id, { newText: content });
+				const beforeText = entry.newText;
+				const redoWasPresent = redoStack.length > 0;
+				store.update(entry.path, { newText: content });
 				pushUndo(sessionId, {
-					id: newest.id,
-					path: newest.path,
-					entry: newest,
+					id: entry.path,
+					path: entry.path,
+					entry,
 					fileText: beforeText
 				}, {
-					id: newest.id,
-					path: newest.path,
+					id: entry.path,
+					path: entry.path,
 					entry: {
-						...newest,
+						...entry,
 						newText: content,
 						updatedAt: Date.now()
 					},
 					fileText: content
 				});
-				await persistSession(sessionId);
+				persistSession();
 				if (redoWasPresent) redoCleared = true;
 			}
 			const state = {
 				missing: false,
 				diverged: hasContent ? content !== adopted : true
 			};
-			for (const entry of group) listed.push(entry.id === newest.id ? {
+			listed.push({
 				...entry,
 				newText: adopted,
 				...state
-			} : {
-				...entry,
-				...state
 			});
 		}
 		return {
@@ -1083,18 +1092,15 @@ function apply(ctx, config) {
 		const policy = sandboxPolicyOf(sessionId);
 		return policy === void 0 ? ctx.fs.writeText(target, content, void 0, signal) : ctx.fs.writeText(target, content, void 0, signal, policy);
 	}
-	const undoStacks = /* @__PURE__ */ new Map();
-	const redoStacks = /* @__PURE__ */ new Map();
+	const undoStack = [];
+	const redoStack = [];
 	function pushUndo(sessionId, before, after) {
-		const key = String(sessionId);
-		const stack = undoStacks.get(key) ?? [];
-		stack.push({
+		undoStack.push({
 			sessionId,
 			before,
 			after
 		});
-		undoStacks.set(key, stack);
-		redoStacks.delete(key);
+		redoStack.length = 0;
 	}
 	/**
 	* Restore one snapshot (the before/after side of an undo pair). File writes
@@ -1115,116 +1121,59 @@ function apply(ctx, config) {
 			await writeRevert(resolved, state.fileText, sessionId, signal);
 		}
 		if (state.batch !== void 0) {
-			for (const item of state.batch) if (item.entry !== void 0) store.restore(sessionId, item.entry);
-			else store.remove(sessionId, item.id);
+			for (const item of state.batch) if (item.entry !== void 0) store.restore(item.entry);
+			else store.remove(item.path);
 			return;
 		}
-		if (state.entry !== void 0) store.restore(sessionId, state.entry);
-		else store.remove(sessionId, state.id);
-	}
-	/**
-	* Record one session in its workspace's account. Every path that touches a
-	* session registers it, so the list merges all of a workspace's sessions'
-	* entries — a fresh session after restart still sees the workspace's
-	* persisted pending changes.
-	* @param sessionId - the session to register.
-	* @returns the owning workspace, or `undefined` when none accounts it.
-	*/
-	function registerSession(sessionId) {
-		const workspace = workspaceOf(sessionId);
-		if (workspace === void 0) return void 0;
-		const key = String(workspace.id);
-		const sessions = sessionsByWorkspace.get(key);
-		if (sessions === void 0) sessionsByWorkspace.set(key, /* @__PURE__ */ new Set([String(sessionId)]));
-		else sessions.add(String(sessionId));
-		return workspace;
+		if (state.entry !== void 0) store.restore(state.entry);
+		else store.remove(state.path);
 	}
 	/**
-	* Merge one workspace's persisted entries into the store, once per
-	* workspace. Hydration is workspace-scoped: after a restart the current
-	* session has a fresh id while the persisted entries live under their
-	* original session ids in the same workspace file, so the whole workspace
-	* is loaded and every persisted session is accounted. Concurrent callers
-	* share the in-flight load, and folds arriving while the load runs stay
-	* safe: `hydrate` never overwrites a live entry.
-	* @param workspace - the workspace whose persisted state to merge.
-	* @returns resolution after the workspace's persisted state is merged (or skipped).
-	*/
-	function ensureWorkspaceLoaded(workspace) {
-		const key = String(workspace.id);
-		if (loadedWorkspaces.has(key)) return Promise.resolve();
-		const pending = loadingWorkspaces.get(key);
-		if (pending !== void 0) return pending;
-		const task = (async () => {
-			try {
-				const persisted = await persistence.loadWorkspace(key);
-				const bySession = /* @__PURE__ */ new Map();
-				for (const entry of persisted) {
-					const sessionKey = String(entry.sessionId);
-					const group = bySession.get(sessionKey);
-					if (group === void 0) bySession.set(sessionKey, [entry]);
-					else group.push(entry);
-				}
-				for (const [sessionKey, entries] of bySession) {
-					const sessions = sessionsByWorkspace.get(key) ?? /* @__PURE__ */ new Set();
-					sessions.add(sessionKey);
-					sessionsByWorkspace.set(key, sessions);
-					store.hydrate(SessionId(sessionKey), entries);
-				}
-			} catch (error) {
-				ctx.logger.warn(`diff-approval: loading persisted state for workspace ${key} failed: ${errorMessage(error)}`);
-			}
-			loadedWorkspaces.add(key);
-			loadingWorkspaces.delete(key);
-		})();
-		loadingWorkspaces.set(key, task);
-		return task;
-	}
-	/**
-	* Merge the session's workspace's persisted state into the store (a session
-	* with no workspace is the memory-only edge and has nothing to load).
-	* @param sessionId - the session to hydrate for.
-	* @returns resolution after the workspace's persisted state is merged.
-	*/
-	function ensureLoaded(sessionId) {
-		const workspace = registerSession(sessionId);
-		if (workspace === void 0) return Promise.resolve();
-		return ensureWorkspaceLoaded(workspace);
-	}
-	/**
-	* All entries visible to one session: every registered session of its
-	* workspace, merged oldest capture first. This is what makes an unhandled
-	* change survive a restart — the new session lists the workspace's whole
-	* pending set, its own live folds plus the earlier sessions' persisted
-	* entries.
-	* @param sessionId - the viewing session.
-	* @returns the merged entries; a session with no workspace lists only itself.
-	*/
-	async function workspaceEntries(sessionId) {
-		await ensureLoaded(sessionId);
-		const workspace = workspaceOf(sessionId);
-		if (workspace === void 0) return store.list(sessionId);
-		const sessions = sessionsByWorkspace.get(String(workspace.id));
-		if (sessions === void 0) return store.list(sessionId);
-		const entries = [];
-		for (const sessionKey of sessions) entries.push(...store.list(SessionId(sessionKey)));
-		return entries.sort((left, right) => left.updatedAt - right.updatedAt);
-	}
-	/**
-	* Mirror one session's entries to disk. A write fault logs a warning and
-	* leaves the in-memory view intact: the review flow must not break on a
-	* storage fault, and the next successful mutation rewrites the whole file.
-	* @param sessionId - the session whose complete entry list to save.
+	* Mirror the whole (globally-unique) entry set to disk. A write fault logs a
+	* warning and leaves the in-memory view intact: the review flow must not
+	* break on a storage fault, and the next successful mutation rewrites the
+	* file.
 	* @returns resolution after the write settles (successful or logged).
 	*/
-	async function persistSession(sessionId) {
-		await ensureLoaded(sessionId);
-		const workspace = workspaceOf(sessionId);
-		if (workspace === void 0) return;
+	const PERSIST_THROTTLE_MS = 1e3;
+	let persistDirty = false;
+	let persistScheduled = false;
+	let lastPersistAt = 0;
+	let persistTimer;
+	/** Actually write the (dirty) store to disk; one coalesced write. */
+	async function flushPersist() {
+		if (!persistDirty) return;
+		persistDirty = false;
+		lastPersistAt = Date.now();
 		try {
-			await persistence.save(String(workspace.id), String(sessionId), store.list(sessionId));
+			await ensureLoaded();
+			await persistence.save(store.all());
 		} catch (error) {
-			ctx.logger.warn(`diff-approval: persisting session ${String(sessionId)} failed: ${errorMessage(error)}`);
+			ctx.logger.warn(`diff-approval: persisting pending changes failed: ${errorMessage(error)}`);
+		}
+	}
+	/** Mark the store dirty and schedule one throttled, coalesced write. Pass
+	* `force` to write immediately (user actions need durable, immediate results). */
+	function persistSession(force = false) {
+		persistDirty = true;
+		if (force) {
+			if (persistScheduled) {
+				clearTimeout(persistTimer);
+				persistScheduled = false;
+			}
+			flushPersist();
+			return;
+		}
+		if (persistScheduled) return;
+		const delay = PERSIST_THROTTLE_MS - (Date.now() - lastPersistAt);
+		if (delay <= 0) flushPersist();
+		else {
+			persistScheduled = true;
+			persistTimer = setTimeout(() => {
+				persistScheduled = false;
+				flushPersist();
+			}, delay);
+			persistTimer.unref?.();
 		}
 	}
 	ctx.on("tools/result", (exec, result) => {
@@ -1237,22 +1186,21 @@ function apply(ctx, config) {
 		if (outcome === void 0 || outcome.oldText === outcome.newText) return;
 		const sessionId = exec.agent.id;
 		const entry = {
-			id: randomUUID(),
+			id: outcome.path,
 			sessionId,
 			...outcome,
-			updatedAt: Date.now()
+			updatedAt: Date.now(),
+			sessionIds: [sessionId]
 		};
-		(async () => {
-			await ensureLoaded(sessionId);
-			if (store.fold(entry)) await persistSession(sessionId);
-		})();
+		if (store.fold(entry)) persistSession();
 	});
 	const handle = async (endpoint, payload, signal) => {
 		switch (endpoint) {
 			case "list": {
 				const sessionId = sessionOf(payload);
 				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
-				const { files, redoCleared } = await listWithState(sessionId, await workspaceEntries(sessionId));
+				await ensureLoaded();
+				const { files, redoCleared } = await listWithState(sessionId);
 				return {
 					ok: true,
 					value: {
@@ -1265,25 +1213,28 @@ function apply(ctx, config) {
 			case "keep": {
 				const target = targetOf(payload);
 				if (target === void 0) return rpcError("sessionId and id must be non-empty strings");
-				await ensureLoaded(target.sessionId);
-				const entry = store.get(target.sessionId, target.id);
-				if (entry === void 0) return {
-					ok: true,
-					value: { outcome: "missing" }
-				};
-				store.remove(target.sessionId, target.id);
+				let entry = store.get(target.id);
+				if (entry === void 0) {
+					await ensureLoaded();
+					entry = store.get(target.id);
+					if (entry === void 0) return {
+						ok: true,
+						value: { outcome: "missing" }
+					};
+				}
+				store.remove(target.id);
 				pushUndo(target.sessionId, {
-					id: entry.id,
+					id: entry.path,
 					path: entry.path,
 					entry,
 					fileText: void 0
 				}, {
-					id: entry.id,
+					id: entry.path,
 					path: entry.path,
 					entry: void 0,
 					fileText: void 0
 				});
-				await persistSession(target.sessionId);
+				persistSession(true);
 				return {
 					ok: true,
 					value: { outcome: "kept" }
@@ -1292,12 +1243,15 @@ function apply(ctx, config) {
 			case "revert": {
 				const target = targetOf(payload);
 				if (target === void 0) return rpcError("sessionId and id must be non-empty strings");
-				await ensureLoaded(target.sessionId);
-				const entry = store.get(target.sessionId, target.id);
-				if (entry === void 0) return {
-					ok: true,
-					value: { outcome: "missing" }
-				};
+				let entry = store.get(target.id);
+				if (entry === void 0) {
+					await ensureLoaded();
+					entry = store.get(target.id);
+					if (entry === void 0) return {
+						ok: true,
+						value: { outcome: "missing" }
+					};
+				}
 				let undo;
 				try {
 					const resolved = await ctx.fs.resolve(entry.path, { signal });
@@ -1308,13 +1262,13 @@ function apply(ctx, config) {
 						await writeRevert(resolved, content, target.sessionId, signal);
 						undo = {
 							before: {
-								id: entry.id,
+								id: entry.path,
 								path: entry.path,
 								entry,
 								fileText: preWrite
 							},
 							after: {
-								id: entry.id,
+								id: entry.path,
 								path: entry.path,
 								entry: void 0,
 								fileText: content
@@ -1324,9 +1278,9 @@ function apply(ctx, config) {
 				} catch (error) {
 					return rpcError(`revert failed: ${errorMessage(error)}`);
 				}
-				store.remove(target.sessionId, target.id);
+				store.remove(target.id);
 				if (undo !== void 0) pushUndo(target.sessionId, undo.before, undo.after);
-				await persistSession(target.sessionId);
+				persistSession(true);
 				return {
 					ok: true,
 					value: { outcome: "reverted" }
@@ -1335,15 +1289,15 @@ function apply(ctx, config) {
 			case "block-keep": {
 				const blockTarget = blockTargetOf(payload);
 				if (blockTarget === void 0) return rpcError("sessionId, id, and block must be valid");
-				await ensureLoaded(blockTarget.sessionId);
-				const entry = store.get(blockTarget.sessionId, blockTarget.id);
+				await ensureLoaded();
+				const entry = store.get(blockTarget.id);
 				if (entry === void 0) return {
 					ok: true,
 					value: { outcome: "missing" }
 				};
 				const accepted = contentRangeOf(entry.newText, blockTarget.block.newStart, blockTarget.block.newEnd);
 				const updatedOld = replaceContentLines(entry.oldText, blockTarget.block.oldStart, blockTarget.block.oldEnd, accepted);
-				store.update(blockTarget.sessionId, blockTarget.id, { oldText: updatedOld });
+				store.update(blockTarget.id, { oldText: updatedOld });
 				const afterEntry = {
 					...entry,
 					oldText: updatedOld,
@@ -1360,7 +1314,7 @@ function apply(ctx, config) {
 					entry: afterEntry,
 					fileText: void 0
 				});
-				await persistSession(blockTarget.sessionId);
+				persistSession();
 				return {
 					ok: true,
 					value: updatedOld === entry.newText ? {
@@ -1372,8 +1326,8 @@ function apply(ctx, config) {
 			case "block-revert": {
 				const blockTarget = blockTargetOf(payload);
 				if (blockTarget === void 0) return rpcError("sessionId, id, and block must be valid");
-				await ensureLoaded(blockTarget.sessionId);
-				const entry = store.get(blockTarget.sessionId, blockTarget.id);
+				await ensureLoaded();
+				const entry = store.get(blockTarget.id);
 				if (entry === void 0) return {
 					ok: true,
 					value: { outcome: "missing" }
@@ -1381,7 +1335,7 @@ function apply(ctx, config) {
 				const restored = contentRangeOf(entry.oldText, blockTarget.block.oldStart, blockTarget.block.oldEnd);
 				const updatedNew = replaceContentLines(entry.newText, blockTarget.block.newStart, blockTarget.block.newEnd, restored);
 				const content = reencodeEol(updatedNew, detectEol(entry.newText));
-				store.update(blockTarget.sessionId, blockTarget.id, { newText: content });
+				store.update(blockTarget.id, { newText: content });
 				const afterEntry = {
 					...entry,
 					newText: content,
@@ -1413,7 +1367,7 @@ function apply(ctx, config) {
 					return rpcError(`block revert failed: ${errorMessage(error)}`);
 				}
 				if (undo !== void 0) pushUndo(blockTarget.sessionId, undo.before, undo.after);
-				await persistSession(blockTarget.sessionId);
+				persistSession();
 				return {
 					ok: true,
 					value: normalizeEol(updatedNew) === normalizeEol(entry.oldText) ? {
@@ -1425,9 +1379,7 @@ function apply(ctx, config) {
 			case "undo": {
 				const sessionId = sessionOf(payload);
 				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
-				const key = String(sessionId);
-				const stack = undoStacks.get(key) ?? [];
-				const pair = stack.pop();
+				const pair = undoStack.pop();
 				if (pair === void 0) return {
 					ok: true,
 					value: { outcome: "nothing" }
@@ -1435,13 +1387,11 @@ function apply(ctx, config) {
 				try {
 					await restoreState(sessionId, pair.before, pair.after, signal);
 				} catch (error) {
-					stack.push(pair);
+					undoStack.push(pair);
 					return rpcError(`undo failed: ${errorMessage(error)}`);
 				}
-				const redoStack = redoStacks.get(key) ?? [];
 				redoStack.push(pair);
-				redoStacks.set(key, redoStack);
-				await persistSession(sessionId);
+				persistSession(true);
 				return {
 					ok: true,
 					value: {
@@ -1453,9 +1403,7 @@ function apply(ctx, config) {
 			case "redo": {
 				const sessionId = sessionOf(payload);
 				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
-				const key = String(sessionId);
-				const stack = redoStacks.get(key) ?? [];
-				const pair = stack.pop();
+				const pair = redoStack.pop();
 				if (pair === void 0) return {
 					ok: true,
 					value: { outcome: "nothing" }
@@ -1463,13 +1411,11 @@ function apply(ctx, config) {
 				try {
 					await restoreState(sessionId, pair.after, pair.before, signal);
 				} catch (error) {
-					stack.push(pair);
+					redoStack.push(pair);
 					return rpcError(`redo failed: ${errorMessage(error)}`);
 				}
-				const undoStack = undoStacks.get(key) ?? [];
 				undoStack.push(pair);
-				undoStacks.set(key, undoStack);
-				await persistSession(sessionId);
+				persistSession(true);
 				return {
 					ok: true,
 					value: {
@@ -1509,19 +1455,20 @@ function apply(ctx, config) {
 				} catch (error) {
 					return rpcError(`import failed: ${errorMessage(error)}`);
 				}
-				await ensureLoaded(sessionId);
+				await ensureLoaded();
 				const before = new Map(store.list(sessionId).map((entry) => [entry.path, entry]));
 				let imported = 0;
 				const changedPaths = [];
 				for (const change of changes) {
 					const entry = {
-						id: randomUUID(),
+						id: change.path,
 						sessionId,
 						path: change.path,
 						kind: change.kind,
 						oldText: change.oldText,
 						newText: change.newText,
-						updatedAt: Date.now()
+						updatedAt: Date.now(),
+						sessionIds: [sessionId]
 					};
 					if (store.fold(entry)) {
 						imported += 1;
@@ -1529,7 +1476,7 @@ function apply(ctx, config) {
 					}
 				}
 				if (imported > 0) {
-					await persistSession(sessionId);
+					persistSession();
 					const after = new Map(store.list(sessionId).map((entry) => [entry.path, entry]));
 					const batchBefore = [];
 					const batchAfter = [];
@@ -1575,8 +1522,8 @@ function apply(ctx, config) {
 			case "open": {
 				const target = openTargetOf(payload);
 				if (target === void 0) return rpcError("sessionId, id, and action must be valid");
-				await ensureLoaded(target.sessionId);
-				const entry = store.get(target.sessionId, target.id);
+				await ensureLoaded();
+				const entry = store.get(target.id);
 				if (entry === void 0) return {
 					ok: true,
 					value: { outcome: "missing" }