dsh-diff-approval 0.18.0 → 0.19.0

package/lib/index.js

@@ -1,5 +1,5 @@
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join, resolve, sep } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } 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";
@@ -738,6 +738,12 @@ function detectEol(text) {
 function normalizeEol(text) {
 	return text.replace(/\r\n?/g, "\n");
 }
+/** Whether two contents are equal ignoring line endings and a trailing-newline
+*  difference — the same tolerance the whole-file diff uses, so a file that the
+*  diff view shows as "no pending diff" is treated as fully resolved here too. */
+function contentEqual(a, b) {
+	return contentLinesOf(normalizeEol(a)).join("\n") === contentLinesOf(normalizeEol(b)).join("\n");
+}
 /** Re-encode `text`'s line endings to `eol` (its content is unchanged). */
 function reencodeEol(text, eol) {
 	const normalized = normalizeEol(text);
@@ -813,6 +819,26 @@ function sessionOfAgent(agent) {
 	return typeof id === "string" && id.length > 0 ? SessionId(id) : void 0;
 }
 /**
+* The MIME type for an image path by its lowercased extension. An unknown or
+* non-image extension falls back to the generic binary type, which browsers
+* still render when the bytes decode; the common Markdown image formats are
+* covered so a preview inlines as the right content type.
+* @param path - the image's OS path.
+* @returns the MIME type.
+*/
+function imageMimeOf(path) {
+	const lower = path.toLowerCase();
+	if (lower.endsWith(".png")) return "image/png";
+	if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+	if (lower.endsWith(".gif")) return "image/gif";
+	if (lower.endsWith(".webp")) return "image/webp";
+	if (lower.endsWith(".svg")) return "image/svg+xml";
+	if (lower.endsWith(".avif")) return "image/avif";
+	if (lower.endsWith(".bmp")) return "image/bmp";
+	if (lower.endsWith(".ico")) return "image/x-icon";
+	return "application/octet-stream";
+}
+/**
 * Build one channel error in the closed RPC error vocabulary. `internal` is
 * the catch-all: business misses ride the success branch as `outcome: 'missing'`.
 * @param message - the handler-side description.
@@ -1102,6 +1128,40 @@ 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);
 	}
+	/**
+	* Revert one entry's file back to its baseline (the shared per-entry logic
+	* behind both the single `revert` endpoint and the bulk `revert-all`). A
+	* created file's revert deletes it (not undoable: the file is gone), an edit
+	* writes the baseline back and yields the before/after undo snapshot.
+	* @param entry - the entry to revert.
+	* @param sessionId - the entry's session (for the per-session write policy).
+	* @param signal - aborts before atomic publication takes effect.
+	* @returns the undo snapshot, or `undefined` when the revert is not undoable.
+	*/
+	async function revertEntryContent(entry, sessionId, signal) {
+		const resolved = await ctx.fs.resolve(entry.path, { signal });
+		if (entry.kind === "create") {
+			await rm(ctx.fs.processPath(resolved), { force: true });
+			return;
+		}
+		const preWrite = await ctx.fs.readText(resolved, void 0) ?? entry.newText;
+		const content = reencodeEol(entry.oldText, detectEol(entry.newText));
+		await writeRevert(resolved, content, sessionId, signal);
+		return {
+			before: {
+				id: entry.id,
+				path: entry.path,
+				entry,
+				fileText: preWrite
+			},
+			after: {
+				id: entry.id,
+				path: entry.path,
+				entry: void 0,
+				fileText: content
+			}
+		};
+	}
 	const undoStack = [];
 	const redoStack = [];
 	function pushUndo(sessionId, before, after) {
@@ -1264,27 +1324,7 @@ function apply(ctx, config) {
 				}
 				let undo;
 				try {
-					const resolved = await ctx.fs.resolve(entry.path, { signal });
-					if (entry.kind === "create") await rm(ctx.fs.processPath(resolved), { force: true });
-					else {
-						const preWrite = await ctx.fs.readText(resolved, void 0) ?? entry.newText;
-						const content = reencodeEol(entry.oldText, detectEol(entry.newText));
-						await writeRevert(resolved, content, target.sessionId, signal);
-						undo = {
-							before: {
-								id: entry.path,
-								path: entry.path,
-								entry,
-								fileText: preWrite
-							},
-							after: {
-								id: entry.path,
-								path: entry.path,
-								entry: void 0,
-								fileText: content
-							}
-						};
-					}
+					undo = await revertEntryContent(entry, target.sessionId, signal);
 				} catch (error) {
 					return rpcError(`revert failed: ${errorMessage(error)}`);
 				}
@@ -1296,6 +1336,86 @@ function apply(ctx, config) {
 					value: { outcome: "reverted" }
 				};
 			}
+			case "keep-all": {
+				const sessionId = sessionOf(payload);
+				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
+				await ensureLoaded();
+				const entries = store.list(sessionId);
+				const before = [];
+				const after = [];
+				for (const entry of entries) {
+					before.push({
+						id: entry.id,
+						path: entry.path,
+						entry,
+						fileText: void 0
+					});
+					after.push({
+						id: entry.id,
+						path: entry.path,
+						entry: void 0,
+						fileText: void 0
+					});
+					store.remove(entry.id);
+				}
+				if (before.length > 0) pushUndo(sessionId, {
+					id: before[0].id,
+					path: before[0].path,
+					entry: void 0,
+					fileText: void 0,
+					batch: before
+				}, {
+					id: after[0].id,
+					path: after[0].path,
+					entry: void 0,
+					fileText: void 0,
+					batch: after
+				});
+				persistSession(true);
+				return {
+					ok: true,
+					value: { affected: before.length }
+				};
+			}
+			case "revert-all": {
+				const sessionId = sessionOf(payload);
+				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
+				await ensureLoaded();
+				const entries = store.list(sessionId);
+				const batchBefore = [];
+				const batchAfter = [];
+				for (const entry of entries) {
+					let undo;
+					try {
+						undo = await revertEntryContent(entry, sessionId, signal);
+					} catch {
+						return rpcError(`revert-all failed for ${entry.path}`);
+					}
+					if (undo !== void 0) {
+						batchBefore.push(undo.before);
+						batchAfter.push(undo.after);
+					}
+					store.remove(entry.id);
+				}
+				if (batchBefore.length > 0) pushUndo(sessionId, {
+					id: batchBefore[0].id,
+					path: batchBefore[0].path,
+					entry: void 0,
+					fileText: void 0,
+					batch: batchBefore
+				}, {
+					id: batchAfter[0].id,
+					path: batchAfter[0].path,
+					entry: void 0,
+					fileText: void 0,
+					batch: batchAfter
+				});
+				persistSession(true);
+				return {
+					ok: true,
+					value: { affected: entries.length }
+				};
+			}
 			case "block-keep": {
 				const blockTarget = blockTargetOf(payload);
 				if (blockTarget === void 0) return rpcError("sessionId, id, and block must be valid");
@@ -1325,7 +1445,7 @@ function apply(ctx, config) {
 					fileText: void 0
 				});
 				persistSession();
-				const fullyResolved = updatedOld === entry.newText;
+				const fullyResolved = contentEqual(updatedOld, entry.newText);
 				if (fullyResolved && blockTarget.removeWhenResolved === true) {
 					store.remove(blockTarget.id);
 					pushUndo(blockTarget.sessionId, {
@@ -1394,7 +1514,7 @@ function apply(ctx, config) {
 				}
 				if (undo !== void 0) pushUndo(blockTarget.sessionId, undo.before, undo.after);
 				persistSession();
-				const fullyResolved = normalizeEol(updatedNew) === normalizeEol(entry.oldText);
+				const fullyResolved = contentEqual(updatedNew, entry.oldText);
 				if (fullyResolved && blockTarget.removeWhenResolved === true) {
 					store.remove(blockTarget.id);
 					pushUndo(blockTarget.sessionId, {
@@ -1581,6 +1701,29 @@ function apply(ctx, config) {
 					value: { outcome: "opened" }
 				};
 			}
+			case "preview-image": {
+				const image = previewImageTargetOf(payload);
+				if (image === void 0) return rpcError("sessionId and path must be valid");
+				await ensureLoaded();
+				const workspace = workspaceOf(image.sessionId);
+				if (workspace === void 0) return rpcError("image unavailable: the session has no workspace");
+				let dataUri;
+				try {
+					const target = await ctx.fs.resolve(image.path, { signal });
+					const workspaceTarget = await ctx.fs.resolve(workspace.path, {});
+					const osPath = ctx.fs.processPath(target);
+					const workspaceOs = ctx.fs.processPath(workspaceTarget);
+					const inside = relative(workspaceOs, osPath);
+					if (inside !== "" && !inside.startsWith("..") && !isAbsolute(inside)) {
+						const bytes = await readFile(osPath);
+						if (bytes.length > 0) dataUri = `data:${imageMimeOf(osPath)};base64,${bytes.toString("base64")}`;
+					}
+				} catch {}
+				return {
+					ok: true,
+					value: { dataUri }
+				};
+			}
 			default: return rpcError(`unknown endpoint ${JSON.stringify(endpoint)}`);
 		}
 	};
@@ -1681,6 +1824,18 @@ function targetOf(payload) {
 		id
 	};
 }
+/** Narrow a wire payload to one preview-image target. */
+function previewImageTargetOf(payload) {
+	const sessionId = sessionOf(payload);
+	if (sessionId === void 0) return void 0;
+	if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return void 0;
+	const path = payload.path;
+	if (typeof path !== "string" || path.length === 0) return void 0;
+	return {
+		sessionId,
+		path
+	};
+}
 /** Narrow a wire payload to one open target: the keep/revert pair plus the action. */
 function openTargetOf(payload) {
 	const target = targetOf(payload);

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

@@ -64,7 +64,7 @@ interface RowRange {
 /** Imperative surface the parent uses to drive block navigation from the
  *  shared toolbar/keyboard in split mode (its own `focus` is private here). */
 export interface SplitDiffHandle {
-    jump: (direction: -1 | 1, wrapGuard?: boolean) => void;
+    jump: (direction: -1 | 1, wrapGuard?: boolean, singleToast?: boolean) => void;
     openSearch: () => void;
     searchNext: (direction: -1 | 1) => boolean;
 }
@@ -93,5 +93,5 @@ export declare const SplitDiff: import("react").ForwardRefExoticComponent<{
  */
 export declare function selectedPlainText(): string | undefined;
 /** Render the pending-edit review panel and its unified footer action. */
-export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onBlockKeep, onBlockRevert, onOpen, onPasteReference, onUndo, onRedo, onImportVcs, onAckRedoCleared, collapseSidebar, t, }: PendingPanelProps): import("react").JSX.Element;
+export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onBlockKeep, onBlockRevert, onOpen, onPreviewImage, onPasteReference, onUndo, onRedo, onImportVcs, onKeepAll, onRevertAll, onAckRedoCleared, collapseSidebar, t, }: PendingPanelProps): import("react").JSX.Element;
 export {};

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

@@ -36,6 +36,10 @@ export declare const zh: {
     'panel.diffFontSizeDesc': string;
     'panel.diffLineHeight': string;
     'panel.diffLineHeightDesc': string;
+    'panel.mdPreview': string;
+    'panel.mdPreviewDesc': string;
+    'panel.mdMaxWidth': string;
+    'panel.mdMaxWidthDesc': string;
     'panel.diffAddColor': string;
     'panel.diffAddColorDesc': string;
     'panel.diffDelColor': string;
@@ -79,6 +83,13 @@ export declare const zh: {
     'action.hideFileList': string;
     'action.viewSplit': string;
     'action.viewUnified': string;
+    'action.viewPreview': string;
+    'action.viewSource': string;
+    'action.viewBefore': string;
+    'action.viewAfter': string;
+    'action.viewSingle': string;
+    'action.viewDouble': string;
+    'panel.mdPreviewFailed': string;
     'action.copyHint': string;
     'action.copied': string;
     'action.langAuto': string;
@@ -150,6 +161,10 @@ export declare const en: {
     'panel.diffFontSizeDesc': string;
     'panel.diffLineHeight': string;
     'panel.diffLineHeightDesc': string;
+    'panel.mdPreview': string;
+    'panel.mdPreviewDesc': string;
+    'panel.mdMaxWidth': string;
+    'panel.mdMaxWidthDesc': string;
     'panel.diffAddColor': string;
     'panel.diffAddColorDesc': string;
     'panel.diffDelColor': string;
@@ -193,6 +208,13 @@ export declare const en: {
     'action.hideFileList': string;
     'action.viewSplit': string;
     'action.viewUnified': string;
+    'action.viewPreview': string;
+    'action.viewSource': string;
+    'action.viewBefore': string;
+    'action.viewAfter': string;
+    'action.viewSingle': string;
+    'action.viewDouble': string;
+    'panel.mdPreviewFailed': string;
     'action.copyHint': string;
     'action.copied': string;
     'action.langAuto': string;

package/lib/types/client/markdown-images.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Post-render local-image resolver for the Markdown preview. The preview body
+ * is rendered with `innerHTML` from the file's Markdown, so a local `<img
+ * src="details/foo.png">` stays a relative path that a browser cannot load on its
+ * own (the document's base URL is the DSH shell, not the file's folder). This
+ * pass rewrites those srcs to inline base64 data URIs through the host RPC,
+ * leaving absolute URLs and already-inlined data URIs untouched.
+ *
+ * Security: only the host reads the file, and the host confines reads to the
+ * session's workspace (see the `preview-image` endpoint). This module only
+ * computes the path to ask for — it never reads a file itself.
+ * @module dsh-diff-approval/client/markdown-images
+ */
+/**
+ * Resolve every local `<img src>` in a rendered Markdown preview to an inline
+ * data URI. Absolute URLs, fragments, and already-inlined data URIs are left as
+ * written; a reference the host cannot read keeps its original src.
+ * @param container - the preview body element (recently rendered).
+ * @param markdownPath - the Markdown file's backend path (for relative references).
+ * @param workspacePath - the session's workspace root, when known.
+ * @param resolveImage - the host call: maps a backend path to a data URI.
+ * @returns resolution once every image has been considered.
+ */
+export declare function resolvePreviewImages(container: HTMLElement, markdownPath: string, workspacePath: string | undefined, resolveImage: (path: string) => Promise<string | undefined>): Promise<void>;

package/lib/types/client/markdown-preview.d.ts

@@ -0,0 +1,20 @@
+/** Self-contained Markdown preview-diff renderer.
+ *
+ *  Renders the whole-file text diff at the Markdown level: the source diff is
+ *  computed first, then each added/removed/context run is rendered through
+ *  `marked` and presented single-column (merged, like the unified source diff)
+ *  or double-column (before | after). Every rendered block carries its run's
+ *  add/remove/context status so it can be tinted with the diff colors.
+ */
+/**
+ * Render the Markdown preview as sanitized HTML.
+ * @param oldText - the file's tracked baseline (rendered as "before").
+ * @param newText - the file's current content (rendered as "after").
+ * @param mode - 'single' merges add/remove/context (unified-like); 'double'
+ *   shows the before and after renderings aligned row by row, each change block
+ *   tinted (deleted on the before side, added on the after side). Comparable
+ *   edits get word-level highlights on the changed words.
+ * @returns sanitized HTML for the preview body. Local images keep their src so
+ *   a later pass can resolve them to data URIs (see the preview image resolver).
+ */
+export declare function renderMarkdownPreview(oldText: string, newText: string, mode: 'single' | 'double'): 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, DiffApprovalBlockRange, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, VcsImportValue } from '../types.ts';
+import type { DiffApprovalActionValue, DiffApprovalBlockRange, DiffApprovalBulkValue, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, DiffApprovalPreviewImageValue, VcsImportValue } 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. */
@@ -28,6 +28,12 @@ export interface DiffApprovalPort {
     importVcs(sessionId: SessionId, includeUntracked: boolean): Promise<VcsImportValue>;
     /** Open one file with its default application or reveal it in the folder. */
     open(sessionId: SessionId, id: string, action: DiffApprovalOpenAction): Promise<DiffApprovalOpenValue>;
+    /** Keep every pending entry of one session in a single host call (one batch). */
+    keepAll(sessionId: SessionId): Promise<DiffApprovalBulkValue>;
+    /** Revert every pending entry of one session in a single host call (one batch). */
+    revertAll(sessionId: SessionId): Promise<DiffApprovalBulkValue>;
+    /** Read one workspace image and inline it as a base64 data URI (for the Markdown preview). */
+    previewImage(sessionId: SessionId, path: string): Promise<DiffApprovalPreviewImageValue>;
 }
 /** Build the port over one generic RPC caller.
  * @param rpc - the connection's channel caller.

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

@@ -13,6 +13,11 @@ export declare const DIFF_LINE_HEIGHT_MAX = 36;
 export declare const DIFF_FONT_SCALE_DEFAULT = 100;
 export declare const DIFF_FONT_SCALE_MIN = 50;
 export declare const DIFF_FONT_SCALE_MAX = 200;
+/** Markdown-preview content max width (single column): a comfortable reading
+ *  width for mainstream 1080p+ displays. The double-column view is 2x this. */
+export declare const MD_MAX_WIDTH_DEFAULT = 800;
+export declare const MD_MAX_WIDTH_MIN = 480;
+export declare const MD_MAX_WIDTH_MAX = 1600;
 /**
  * Whether copying a reference should also paste it into the chat input and
  * focus it. Defaults to on; only an explicit `'0'` disables it.
@@ -87,6 +92,24 @@ export declare function currentDiffDelColor(): string;
 export declare function splitMode(): boolean;
 /** Persist the split-view preference. */
 export declare function setSplitMode(value: boolean): void;
+/**
+ * Whether the rendered Markdown preview is shown by default (for Markdown files).
+ * Default off: the source diff is shown unless the panel toggle is used. Only an
+ * explicit `'1'` enables the preview default.
+ * @returns whether the Markdown preview default is enabled.
+ */
+export declare function mdPreviewEnabled(): boolean;
+/** Persist the Markdown-preview default preference. */
+export declare function setMdPreviewEnabled(value: boolean): void;
+/**
+ * The Markdown-preview content max width, in pixels (single column). Defaults to
+ * 800; the double-column view totals 2x this. An out-of-range or non-integer
+ * value falls back to the default.
+ * @returns the max width in pixels.
+ */
+export declare function mdMaxWidth(): number;
+/** Persist the Markdown-preview content max width. */
+export declare function setMdMaxWidth(value: number): void;
 /**
  * How many rows of lead the diff block jump leaves above the jumped-to block,
  * and how far the anchored navigation scans. Defaults to 2; an out-of-range or

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

@@ -39,6 +39,9 @@ export interface PendingPanelFace {
     onBlockRevert: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange, removeWhenResolved?: boolean) => Promise<void>;
     /** Open one file with its default application or reveal it in the folder. */
     onOpen: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
+    /** Inline one workspace image as a base64 data URI for the Markdown preview
+     * (empty when the host cannot read it). */
+    onPreviewImage: (sessionId: SessionId, path: string) => Promise<string | undefined>;
     /** Paste a copied reference into the session's chat input and focus it. */
     onPasteReference: (sessionId: SessionId, reference: string) => void;
     /** Undo the session's last keep/revert, then refresh the list; resolves to the affected entry id when it is still pending. */
@@ -47,6 +50,10 @@ export interface PendingPanelFace {
     onRedo: (sessionId: SessionId) => Promise<string | undefined>;
     /** Import the workspace's local VCS changes as pending entries (detection included). */
     onImportVcs: (sessionId: SessionId, includeUntracked: boolean) => Promise<VcsImportValue>;
+    /** Keep every pending entry of one session in a single host call (bulk). */
+    onKeepAll: (sessionId: SessionId) => Promise<void>;
+    /** Revert every pending entry of one session in a single host call (bulk). */
+    onRevertAll: (sessionId: SessionId) => Promise<void>;
     /** Acknowledge the redo-cleared notice so it is only surfaced once. */
     onAckRedoCleared: () => void;
     /** Collapse the DSH sidebar (no-op when already collapsed) before the modal

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

@@ -30,6 +30,12 @@ export interface PendingDiffStore extends HostObservable<PendingDiffSnapshot> {
     importVcs: (sessionId: SessionId, includeUntracked: boolean) => Promise<VcsImportValue>;
     /** Open one file with its default application or reveal it in the folder. */
     open: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
+    /** Keep every pending entry of one session in a single host call, then refresh. */
+    keepAll: (sessionId: SessionId) => Promise<void>;
+    /** Revert every pending entry of one session in a single host call, then refresh. */
+    revertAll: (sessionId: SessionId) => Promise<void>;
+    /** Inline one workspace image as a base64 data URI (empty when unreadable). */
+    previewImage: (sessionId: SessionId, path: string) => Promise<string | undefined>;
     /** Drop every local fact (used on connection reset). */
     reset: () => void;
     /** Acknowledge a redo-cleared notice so the panel surfaces it only once. */

package/lib/types/client/whole-file-diff.d.ts

@@ -67,6 +67,21 @@ export interface IntraRun {
     text: string;
     kind: 'same' | 'del' | 'add';
 }
+/**
+ * Compute the intra-line runs for one del/add line pair, or `undefined` when
+ * the pair should not be annotated: identical lines (no internal change) or
+ * lines too dissimilar to be a modification (a rewrite, not an edit).
+ * Word-based via the `diff` package's `diffArrays` over `tokenizeLine`'s
+ * tokens, so an English edit highlights whole changed words and a CJK edit
+ * highlights the individual changed characters.
+ * @param oldText - the removed side's line text.
+ * @param newText - the added side's line text.
+ * @returns the del-side and add-side runs, or `undefined` to skip annotation.
+ */
+export declare function intraRunsOf(oldText: string, newText: string): {
+    del: IntraRun[];
+    add: IntraRun[];
+} | undefined;
 /** One matched del→add row pair within a change block. */
 interface BlockPair {
     delIndex: number;

package/lib/types/types.d.ts

@@ -105,6 +105,24 @@ export interface VcsImportValue {
     /** Whether a VCS root was found at all (false when the workspace is not in a git/svn/p4 checkout). */
     detected: boolean;
 }
+/** Target of one preview-image read. */
+export interface DiffApprovalPreviewImageTarget {
+    sessionId: SessionId;
+    /** The backend resolution path of the image (workspace-relative or absolute display path). */
+    path: string;
+}
+/** Value returned by the channel's preview-image endpoint. */
+export interface DiffApprovalPreviewImageValue {
+    /** The image's base64 data URI (MIME from the file's extension), or `undefined`
+     * when the host could not read the file (absent, outside the workspace, or
+     * unreadable) — a missing value leaves the image unresolved in the preview. */
+    dataUri?: string | undefined;
+}
+/** Value returned by the channel's keep-all/revert-all endpoints. */
+export interface DiffApprovalBulkValue {
+    /** How many pending entries were kept/reverted (0 when the session had none). */
+    affected: number;
+}
 /** Value returned by the channel's keep and revert endpoints. */
 export interface DiffApprovalActionValue {
     /** What the request did; `missing` means no pending entry existed. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-diff-approval",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "DeepSeek Harness plugin: pending-edit review with whole-file diff and Keep/Revert",
   "packageManager": "pnpm@11.21.0",
   "author": "Wu Zhiwei",
@@ -60,6 +60,8 @@
     "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.5",
     "@shikijs/langs": "^4.4.3",
     "diff": "^9.0.0",
+    "dompurify": "^3.4.15",
+    "marked": "^18.0.11",
     "shiki": "^4.4.3"
   },
   "peerDependencies": {