dsh-diff-approval 0.2.0 → 0.4.0

package/lib/index.js

@@ -1,8 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { dshHomePath, expandHomePath } from "@deepseek-ai/dsh-home-paths";
 import { SessionId } from "@deepseek-ai/dsh-session";
+import { spawn } from "node:child_process";
 //#region lib/types/pending.js
 /**
 * In-memory pending-diff store: one entry per (session, path), holding the
@@ -235,6 +236,29 @@ var PendingPersistence = class {
 		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) {
+				const entry = pendingEntryOf(row);
+				if (entry !== void 0) entries.push(entry);
+			}
+		}
+		return entries.sort((left, right) => left.updatedAt - right.updatedAt);
+	}
+	/**
 	* 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.
@@ -269,17 +293,70 @@ var PendingPersistence = class {
 	}
 };
 //#endregion
+//#region lib/types/open.js
+/**
+* OS-level "open file" and "reveal in folder" launches for the host half's
+* `open` endpoint. The plugin's own tests inject a double instead of running
+* these; real profiles get the platform commands below.
+* @module dsh-diff-approval/open
+*/
+/** Run one detached command; resolves once the process spawns, never waits for exit. */
+function launch(command, args) {
+	return new Promise((resolvePromise, reject) => {
+		const child = spawn(command, [...args], {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true
+		});
+		child.once("error", reject);
+		child.once("spawn", () => {
+			child.unref();
+			resolvePromise();
+		});
+	});
+}
+/**
+* Launch a path through the current platform's default handler: `open` runs
+* the file with its default application, `reveal` selects it in the file
+* manager.
+* @param path - backend execution-world path to act on.
+* @param action - what to do with the path.
+* @returns resolution once the launcher process has spawned.
+*/
+function defaultOpenPath(path, action) {
+	switch (process.platform) {
+		case "win32": return action === "open" ? launch("cmd", [
+			"/c",
+			"start",
+			"",
+			path
+		]) : launch("cmd", [
+			"/c",
+			"start",
+			"",
+			"explorer.exe",
+			`/select,${path}`
+		]);
+		case "darwin": return action === "open" ? launch("open", [path]) : launch("open", ["-R", path]);
+		default: return action === "open" ? launch("xdg-open", [path]) : launch("xdg-open", [dirname(path)]);
+	}
+}
+//#endregion
 //#region lib/types/index.js
 /**
 * Pending-edit review, host half. Captures every successful `edit` and `write`
 * tool result (an unscoped `tools/result` listener receives per-session tool
 * executions because scoped emissions route through the shared root hook
-* table), folds each operation into its file's entry in the
+* table) and every `str_replace_editor` mutation (whose result carries only a
+* success message, so its pre-write basis is snapshotted at the
+* `fs/edit-intent` / `fs/write-intent` seams and paired with the settle),
+* folds each operation into its file's entry in the
 * {@link PendingDiffStore} (one entry per path), serves the `/diff-approval`
-* connection RPC channel (list/keep/revert), and applies a revert by writing
-* the entry's `oldText` back through `ctx.fs` (a created file's revert
-* removes it, and a tracked file that has since disappeared is restored by
-* its revert).
+* connection RPC channel (list/keep/revert/open), and applies a revert by
+* writing the entry's `oldText` back through `ctx.fs` (a created file's
+* revert removes it, and a tracked file that has since disappeared is
+* restored by its revert). `open` launches the file with its default
+* application or reveals it in the file manager.
 *
 * Mount this row in any profile's `cordis.patch.yml`:
 *
@@ -294,9 +371,10 @@ var PendingPersistence = class {
 * ```
 *
 * Pending entries persist per (workspace, session) so an unhandled operation
-* survives a harness restart; the list endpoint re-reads the live file, so a
-* change or deletion made after the tracked operation is reported after
-* restart exactly as it is mid-session.
+* survives a harness restart; the list endpoint hydrates the whole workspace
+* and merges every registered session's entries, so a fresh session after a
+* restart still reports the earlier sessions' pending changes, live-verified
+* exactly as it is mid-session.
 *
 * @module dsh-diff-approval
 */
@@ -363,6 +441,22 @@ function writeOutcomeOf(value) {
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
+/** Narrow a tool-execution-shaped value to its name, call id, and agent. */
+function actorOf(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const { name, callId, agent } = value;
+	return {
+		name,
+		callId,
+		agent
+	};
+}
+/** Narrow an agent-shaped value to its session id. */
+function sessionOfAgent(agent) {
+	if (typeof agent !== "object" || agent === null) return void 0;
+	const id = agent.id;
+	return typeof id === "string" && id.length > 0 ? SessionId(id) : void 0;
+}
 /**
 * Build one channel error in the closed RPC error vocabulary. `internal` is
 * the catch-all: business misses ride the success branch as `outcome: 'missing'`.
@@ -389,8 +483,81 @@ function apply(ctx, config) {
 	if (storageDir !== void 0 && (typeof storageDir !== "string" || storageDir.trim().length === 0)) throw new Error("diff-approval: storageDir must be a non-empty string");
 	const store = new PendingDiffStore();
 	const persistence = new PendingPersistence(resolve(expandHomePath(storageDir ?? defaultStorageDir())));
-	const loaded = /* @__PURE__ */ new Set();
-	const loading = /* @__PURE__ */ new Map();
+	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();
+	/** Pre-write bases captured at the intent seams, keyed by the tool call id. */
+	const editorIntents = /* @__PURE__ */ new Map();
+	/**
+	* Snapshot one str_replace_editor mutation's basis at its intent seam. A
+	* `create` has an empty basis; an edit reads the pre-write content. Any
+	* failure tracks nothing — the settle-side pairing then sees no basis.
+	* @param target - the resolved target about to be written.
+	* @param actor - the tool execution running the mutation.
+	* @param kind - whether the mutation creates or edits the file.
+	*/
+	async function stashEditorIntent(target, actor, kind) {
+		const shaped = actorOf(actor);
+		if (shaped === void 0 || shaped.name !== "str_replace_editor") return;
+		if (typeof shaped.callId !== "string") return;
+		const sessionId = sessionOfAgent(shaped.agent);
+		if (sessionId === void 0) return;
+		if (kind === "create") {
+			editorIntents.set(shaped.callId, {
+				target,
+				kind,
+				before: "",
+				sessionId
+			});
+			return;
+		}
+		try {
+			const before = await ctx.fs.readText(target, void 0) ?? "";
+			editorIntents.set(shaped.callId, {
+				target,
+				kind,
+				before,
+				sessionId
+			});
+		} catch {}
+	}
+	/**
+	* Fold one str_replace_editor mutation into its file's entry. The tool's
+	* result carries only a success message, so the settle reads the post-write
+	* content and pairs it with the basis snapshotted at the intent seam.
+	* @param exec - the settled str_replace_editor execution.
+	* @param result - its outcome.
+	*/
+	async function captureEditorMutation(exec, result) {
+		const basis = editorIntents.get(exec.callId);
+		editorIntents.delete(exec.callId);
+		if (basis === void 0 || basis.sessionId === void 0 || result.isError) return;
+		const argumentsValue = exec.arguments;
+		const command = typeof argumentsValue === "object" && argumentsValue !== null ? argumentsValue.command : void 0;
+		if (!(basis.kind === "create" ? command === "create" : command === "str_replace" || command === "insert")) return;
+		let after;
+		try {
+			after = await ctx.fs.readText(basis.target, void 0) ?? "";
+		} catch {
+			return;
+		}
+		if (basis.kind === "edit" && after === basis.before) return;
+		const sessionId = basis.sessionId;
+		const entry = {
+			id: randomUUID(),
+			sessionId,
+			path: basis.target.displayPath,
+			kind: basis.kind,
+			oldText: basis.before,
+			newText: after,
+			updatedAt: Date.now()
+		};
+		await ensureLoaded(sessionId);
+		if (store.fold(entry)) await persistSession(sessionId);
+	}
 	/**
 	* Read one path's live state: present content, an unresolvable (missing)
 	* path, or a resolved-but-unreadable file.
@@ -462,31 +629,94 @@ function apply(ctx, config) {
 		for (const workspace of ctx.workspaceRegistry.list()) if (workspace.sessionIds.includes(sessionId)) return workspace;
 	}
 	/**
-	* Merge one session's persisted entries into the store, once per session.
-	* Concurrent callers share the in-flight load, and folds arriving while the
-	* load runs stay safe: `hydrate` never overwrites a live entry.
-	* @param sessionId - the session to hydrate.
-	* @returns resolution after the session's persisted state is merged (or skipped).
+	* 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 ensureLoaded(sessionId) {
-		const key = String(sessionId);
-		if (loaded.has(key)) return Promise.resolve();
-		const pending = loading.get(key);
+	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;
+	}
+	/**
+	* 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 () => {
-			const workspace = workspaceOf(sessionId);
-			if (workspace !== void 0) try {
-				store.hydrate(sessionId, await persistence.load(String(workspace.id), key));
+			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 session ${key} failed: ${errorMessage(error)}`);
+				ctx.logger.warn(`diff-approval: loading persisted state for workspace ${key} failed: ${errorMessage(error)}`);
 			}
-			loaded.add(key);
-			loading.delete(key);
+			loadedWorkspaces.add(key);
+			loadingWorkspaces.delete(key);
 		})();
-		loading.set(key, task);
+		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.
@@ -504,6 +734,10 @@ function apply(ctx, config) {
 		}
 	}
 	ctx.on("tools/result", (exec, result) => {
+		if (exec.name === "str_replace_editor") {
+			captureEditorMutation(exec, result);
+			return;
+		}
 		if (result.isError || exec.agent === void 0) return;
 		const outcome = exec.name === "edit" ? editOutcomeOf(result.value) : exec.name === "write" ? writeOutcomeOf(result.value) : void 0;
 		if (outcome === void 0 || outcome.oldText === outcome.newText) return;
@@ -524,10 +758,9 @@ function apply(ctx, config) {
 			case "list": {
 				const sessionId = sessionOf(payload);
 				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
-				await ensureLoaded(sessionId);
 				return {
 					ok: true,
-					value: { files: await listWithState(store.list(sessionId)) }
+					value: { files: await listWithState(await workspaceEntries(sessionId)) }
 				};
 			}
 			case "keep": {
@@ -564,10 +797,38 @@ function apply(ctx, config) {
 					value: { outcome: "reverted" }
 				};
 			}
+			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);
+				if (entry === void 0) return {
+					ok: true,
+					value: { outcome: "missing" }
+				};
+				try {
+					const resolved = await ctx.fs.resolve(entry.path, { signal });
+					await launchPath(ctx.fs.processPath(resolved), target.action);
+				} catch (error) {
+					return rpcError(`${target.action} failed: ${errorMessage(error)}`);
+				}
+				return {
+					ok: true,
+					value: { outcome: "opened" }
+				};
+			}
 			default: return rpcError(`unknown endpoint ${JSON.stringify(endpoint)}`);
 		}
 	};
 	ctx.effect(() => ctx.connection.rpc.handle(DIFF_APPROVAL_CHANNEL, handle, { authority: "trusted-host" }), "diff-approval: review channel");
+	ctx.effect(() => ctx.on("fs/edit-intent", async (target, actor, next) => {
+		await stashEditorIntent(target, actor, "edit");
+		return next();
+	}, { prepend: true }), "diff-approval: str_replace_editor edit basis");
+	ctx.effect(() => ctx.on("fs/write-intent", async (target, actor, next) => {
+		await stashEditorIntent(target, actor, "create");
+		return next();
+	}, { prepend: true }), "diff-approval: str_replace_editor create basis");
 }
 /** Narrow a wire payload's `sessionId` field to a branded session id. */
 function sessionOf(payload) {
@@ -587,5 +848,16 @@ function targetOf(payload) {
 		id
 	};
 }
+/** Narrow a wire payload to one open target: the keep/revert pair plus the action. */
+function openTargetOf(payload) {
+	const target = targetOf(payload);
+	if (target === void 0) return void 0;
+	const action = payload.action;
+	if (action !== "open" && action !== "reveal") return void 0;
+	return {
+		...target,
+		action
+	};
+}
 //#endregion
-export { DIFF_APPROVAL_CHANNEL, PendingDiffStore, PendingPersistence, apply, defaultStorageDir, inject, name };
+export { DIFF_APPROVAL_CHANNEL, PendingDiffStore, PendingPersistence, apply, defaultOpenPath, defaultStorageDir, inject, name };

package/lib/types/client/PendingPanel.d.ts

@@ -1,7 +1,7 @@
-/** Sidebar-foot pending-edit review action and the whole-file diff list it opens. */
+/** Sidebar-foot pending-edit review action and the split review panel it opens. */
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import type { PendingPanelFace } from './slots.ts';
 /** Full panel props composed by the sidebar footer-action slot. */
 export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFace<PendingPanelFace> & PropsLocale<'diff-approval'>;
 /** Render the pending-edit review panel and its unified footer action. */
-export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, t, }: PendingPanelProps): import("react").JSX.Element;
+export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onOpen, t, }: PendingPanelProps): import("react").JSX.Element;

package/lib/types/client/highlight.d.ts

@@ -15,6 +15,8 @@ export interface HighlightSpan {
     text: string;
     style: CSSProperties;
 }
+/** Supported grammar ids, in picker order, for the viewer's language selector. */
+export declare const HIGHLIGHT_LANGS: string[];
 /**
  * Tokenize `code` into per-line highlighted runs when `lang` names a
  * registered grammar; `undefined` means the caller renders its plain fallback.

package/lib/types/client/locales.d.ts

@@ -15,13 +15,21 @@ export declare const zh: {
     'panel.missingHint': string;
     'panel.createHint': string;
     'row.create': string;
+    'row.added': string;
+    'row.removed': string;
     'action.keep': string;
     'action.revert': string;
+    'action.openFile': string;
+    'action.revealFile': string;
     'action.busy': string;
     'action.prevDiff': string;
     'action.nextDiff': string;
-    'action.copyRange': string;
+    'action.copyHint': string;
     'action.copied': string;
+    'action.langAuto': string;
+    'action.langAutoDetected': string;
+    'action.langSelect': string;
+    'action.close': string;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;
@@ -49,13 +57,21 @@ export declare const en: {
     'panel.missingHint': string;
     'panel.createHint': string;
     'row.create': string;
+    'row.added': string;
+    'row.removed': string;
     'action.keep': string;
     'action.revert': string;
+    'action.openFile': string;
+    'action.revealFile': string;
     'action.busy': string;
     'action.prevDiff': string;
     'action.nextDiff': string;
-    'action.copyRange': string;
+    'action.copyHint': string;
     'action.copied': string;
+    'action.langAuto': string;
+    'action.langAutoDetected': string;
+    'action.langSelect': string;
+    'action.close': string;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;

package/lib/types/client/port.d.ts

@@ -5,7 +5,7 @@
  * @module dsh-diff-approval/client/port
  */
 import type { ClientConnectionRpc, SessionId } from '@deepseek-ai/dsh-client-connection/client';
-import type { DiffApprovalActionValue, PendingFileDiff } from '../types.ts';
+import type { DiffApprovalActionValue, DiffApprovalOpenAction, DiffApprovalOpenValue, PendingFileDiff } from '../types.ts';
 /** The channel the host half registers and this port calls. */
 export declare const DIFF_APPROVAL_CHANNEL = "/diff-approval";
 /** This package's business verbs over the review channel. */
@@ -16,6 +16,8 @@ export interface DiffApprovalPort {
     keep(sessionId: SessionId, id: string): Promise<DiffApprovalActionValue>;
     /** Revert one operation. */
     revert(sessionId: SessionId, id: string): Promise<DiffApprovalActionValue>;
+    /** Open one file with its default application or reveal it in the folder. */
+    open(sessionId: SessionId, id: string, action: DiffApprovalOpenAction): Promise<DiffApprovalOpenValue>;
 }
 /** Build the port over one generic RPC caller.
  * @param rpc - the connection's channel caller.

package/lib/types/client/slots.d.ts

@@ -1,7 +1,7 @@
 /** The panel's injected business face and its observable snapshot. */
 import type { HostObservable } from '@deepseek-ai/dsh-client-ui-slots';
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
-import type { PendingFileDiff } from '../types.ts';
+import type { DiffApprovalOpenAction, PendingFileDiff } from '../types.ts';
 /** What the panel reads and drives: the pending list plus in-flight entries. */
 export interface PendingDiffSnapshot {
     /** Whether a list read has completed at least once. */
@@ -25,4 +25,6 @@ export interface PendingPanelFace {
     onKeep: (sessionId: SessionId, id: string) => Promise<void>;
     /** Revert one operation (restore its prior content, or remove a created file). */
     onRevert: (sessionId: SessionId, id: string) => Promise<void>;
+    /** Open one file with its default application or reveal it in the folder. */
+    onOpen: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
 }

package/lib/types/client/store.d.ts

@@ -7,6 +7,7 @@
  */
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
 import type { HostObservable } from '@deepseek-ai/dsh-client-ui-slots';
+import type { DiffApprovalOpenAction } from '../types.ts';
 import type { PendingDiffSnapshot } from './slots.ts';
 import type { DiffApprovalPort } from './port.ts';
 /** The observable the panel reads and the plugin body drives. */
@@ -17,6 +18,8 @@ export interface PendingDiffStore extends HostObservable<PendingDiffSnapshot> {
     keep: (sessionId: SessionId, id: string) => Promise<void>;
     /** Revert one operation. */
     revert: (sessionId: SessionId, id: string) => Promise<void>;
+    /** Open one file with its default application or reveal it in the folder. */
+    open: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
     /** Drop every local fact (used on connection reset). */
     reset: () => void;
 }

package/lib/types/index.d.ts

@@ -2,12 +2,16 @@
  * Pending-edit review, host half. Captures every successful `edit` and `write`
  * tool result (an unscoped `tools/result` listener receives per-session tool
  * executions because scoped emissions route through the shared root hook
- * table), folds each operation into its file's entry in the
+ * table) and every `str_replace_editor` mutation (whose result carries only a
+ * success message, so its pre-write basis is snapshotted at the
+ * `fs/edit-intent` / `fs/write-intent` seams and paired with the settle),
+ * folds each operation into its file's entry in the
  * {@link PendingDiffStore} (one entry per path), serves the `/diff-approval`
- * connection RPC channel (list/keep/revert), and applies a revert by writing
- * the entry's `oldText` back through `ctx.fs` (a created file's revert
- * removes it, and a tracked file that has since disappeared is restored by
- * its revert).
+ * connection RPC channel (list/keep/revert/open), and applies a revert by
+ * writing the entry's `oldText` back through `ctx.fs` (a created file's
+ * revert removes it, and a tracked file that has since disappeared is
+ * restored by its revert). `open` launches the file with its default
+ * application or reveals it in the file manager.
  *
  * Mount this row in any profile's `cordis.patch.yml`:
  *
@@ -22,16 +26,19 @@
  * ```
  *
  * Pending entries persist per (workspace, session) so an unhandled operation
- * survives a harness restart; the list endpoint re-reads the live file, so a
- * change or deletion made after the tracked operation is reported after
- * restart exactly as it is mid-session.
+ * survives a harness restart; the list endpoint hydrates the whole workspace
+ * and merges every registered session's entries, so a fresh session after a
+ * restart still reports the earlier sessions' pending changes, live-verified
+ * exactly as it is mid-session.
  *
  * @module dsh-diff-approval
  */
 import { Context } from '@deepseek-ai/cordis';
-export type { DiffApprovalActionOutcome, DiffApprovalActionValue, DiffApprovalListValue, PendingEntry, PendingEntryKind, PendingFileDiff, } from './types.ts';
+import type { DiffApprovalOpenAction } from './types.ts';
+export type { DiffApprovalActionOutcome, DiffApprovalActionValue, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, PendingEntry, PendingEntryKind, PendingFileDiff, } from './types.ts';
 export { PendingDiffStore } from './pending.ts';
 export { PendingPersistence, defaultStorageDir } from './persist.ts';
+export { defaultOpenPath } from './open.ts';
 /** Stable Cordis plugin name. */
 export declare const name = "diff-approval";
 /** Services required before the review surface activates. */
@@ -48,6 +55,11 @@ export interface DiffApprovalConfig {
      * `~` prefixes expand to the OS home.
      */
     storageDir?: string;
+    /**
+     * Launcher for the `open` endpoint, defaulting to the platform commands.
+     * Injectable for tests; receives the backend execution-world path.
+     */
+    openPath?: (path: string, action: DiffApprovalOpenAction) => Promise<void>;
 }
 /**
  * Mount the pending-edit review surface.

package/lib/types/open.d.ts

@@ -0,0 +1,17 @@
+/**
+ * OS-level "open file" and "reveal in folder" launches for the host half's
+ * `open` endpoint. The plugin's own tests inject a double instead of running
+ * these; real profiles get the platform commands below.
+ * @module dsh-diff-approval/open
+ */
+/** What the open endpoint asks the OS to do with a path. */
+export type OpenAction = 'open' | 'reveal';
+/**
+ * Launch a path through the current platform's default handler: `open` runs
+ * the file with its default application, `reveal` selects it in the file
+ * manager.
+ * @param path - backend execution-world path to act on.
+ * @param action - what to do with the path.
+ * @returns resolution once the launcher process has spawned.
+ */
+export declare function defaultOpenPath(path: string, action: OpenAction): Promise<void>;

package/lib/types/persist.d.ts

@@ -37,6 +37,16 @@ export declare class PendingPersistence {
      * @returns the persisted entries; empty when none were saved.
      */
     load(workspaceId: string, sessionId: string): Promise<PendingEntry[]>;
+    /**
+     * 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.
+     */
+    loadWorkspace(workspaceId: string): Promise<PendingEntry[]>;
     /**
      * Replace one session's entries durably. Saves to one file are serialized;
      * a previous save's failure does not block the next one.

package/lib/types/types.d.ts

@@ -52,6 +52,13 @@ export interface DiffApprovalListValue {
     /** Pending entries for the requested session, oldest capture first. */
     files: PendingFileDiff[];
 }
+/** What the open endpoint asks the OS to do with a file. */
+export type DiffApprovalOpenAction = 'open' | 'reveal';
+/** Value returned by the channel's open endpoint. */
+export interface DiffApprovalOpenValue {
+    /** What the request did; `missing` means no pending entry existed. */
+    outcome: 'opened' | 'missing';
+}
 /** Outcome of one keep/revert request. */
 export type DiffApprovalActionOutcome = 'kept' | 'reverted' | 'missing';
 /** Value returned by the channel's keep and revert endpoints. */