dsh-coding-sidebar 1.0.8 → 1.0.10

package/lib/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { mkdir, open, opendir, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import { access, lstat, mkdir, open, opendir, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { WebSocket, WebSocketServer } from "ws";
 import z from "schemastery";
@@ -377,7 +377,8 @@ async function ensureWorkspaceWritePath(cwd, target) {
 //#endregion
 //#region src/fs-operations.ts
 /**
-* Workspace-safe file mutations for the sidebar (the upload route today).
+* Workspace-safe file mutations for the sidebar: the upload route plus the
+* file tree's rename and delete.
 *
 * Every write is confined to the real session workspace: the upload
 * directory is resolved absolute and its target is checked through existing
@@ -387,6 +388,13 @@ async function ensureWorkspaceWritePath(cwd, target) {
 * to a uniquely named temp sibling
 * and are renamed into place, so a failed, aborted, or oversized upload never
 * leaves a partial file at the target path.
+*
+* The tree's rename/delete (below) are link-aware: existence and containment
+* are verified against the fully resolved target (a symlink pointing outside
+* the workspace is refused), but the operation itself addresses the lexical
+* row path — renaming or deleting a symlink row renames/unlinks the LINK,
+* never its target, matching what the tree row visually names (VS Code
+* semantics). Containment is always enforced (no fence toggle on this fork).
 */
 /**
 * Stream `chunks` into `dir/relativePath` atomically: a uniquely named temp
@@ -443,6 +451,144 @@ async function writeWorkspaceUpload(input) {
 		throw error;
 	}
 }
+/** Resolve a tree-row path against the session workspace (absolute rows pass through). */
+function resolveRowPath(cwd, target) {
+	return isAbsolute(target) ? target : join(cwd, target);
+}
+/** Resolve one existing entry for a link-aware mutation: the lexical row path
+* plus its fully resolved real target (containment-checked). Resolution
+* failures become fs-errors, mirroring path-security's semantics. */
+async function resolveEntry(cwd, target) {
+	const absolute = requireAbsolute(resolveRowPath(cwd, target));
+	let real;
+	let realCwd;
+	try {
+		[realCwd, real] = await Promise.all([realpath(cwd), realpath(absolute)]);
+	} catch (error) {
+		throw new SidebarError("fs-error", `cannot resolve "${target}": ${error instanceof Error ? error.message : String(error)}`, 400);
+	}
+	if (!isWithin(realCwd, real)) throw new SidebarError("forbidden", `path "${target}" is outside workspace`, 403);
+	return {
+		absolute,
+		real,
+		realCwd
+	};
+}
+/** Whether a path exists (ENOENT → false; other failures propagate). */
+async function pathExists(target) {
+	try {
+		await access(target);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+/**
+* Rename one tree row within its directory: `path` → `<parent>/<name>`.
+* The new name must be a single path segment (this is rename, not move);
+* an existing destination is refused (POSIX rename would clobber it
+* silently); the workspace root itself is never renamable; a symlink row
+* renames the link, not its target. A no-op rename (same name) succeeds
+* without touching the filesystem.
+*
+* @throws SidebarError with a wire code for shape, containment, existence
+* and root failures.
+*/
+async function renameWorkspaceEntry(input) {
+	const { cwd, path, name } = input;
+	if (name === "" || name === "." || name === ".." || name.includes("/") || name.includes("\\")) throw new SidebarError("bad-request", "name must be a single path segment", 400);
+	const { absolute, real, realCwd } = await resolveEntry(cwd, path);
+	if (real === realCwd) throw new SidebarError("fs-error", "cannot rename the workspace root", 400);
+	if (basename(absolute) === name) return { path: absolute };
+	const safeDestination = await ensureWorkspaceWritePath(cwd, join(dirname(absolute), name));
+	if (await pathExists(safeDestination)) throw new SidebarError("fs-error", `"${name}" already exists`, 409);
+	try {
+		await rename(absolute, safeDestination);
+	} catch (error) {
+		throw new SidebarError("fs-error", `cannot rename "${path}" to "${name}": ${error instanceof Error ? error.message : String(error)}`, 400);
+	}
+	return { path: safeDestination };
+}
+/**
+* Delete one tree row permanently (there is no trash on the host): files are
+* unlinked, directories removed recursively, a symlink row unlinks the LINK
+* only (lstat decides, so a link to a directory does not recurse into its
+* target). The workspace root itself is never removable.
+*
+* @throws SidebarError with a wire code for containment, existence and
+* root failures.
+*/
+async function removeWorkspaceEntry(input) {
+	const { cwd, path } = input;
+	const { absolute, real, realCwd } = await resolveEntry(cwd, path);
+	if (real === realCwd) throw new SidebarError("fs-error", "cannot remove the workspace root", 400);
+	try {
+		if ((await lstat(absolute)).isDirectory()) await rm(absolute, { recursive: true });
+		else await unlink(absolute);
+	} catch (error) {
+		throw new SidebarError("fs-error", `cannot remove "${path}": ${error instanceof Error ? error.message : String(error)}`, 400);
+	}
+	return { path: absolute };
+}
+//#endregion
+//#region src/changes-ops.ts
+/** Argument keys a file-addressing tool may use for its target path. */
+const PATH_KEYS = [
+	"path",
+	"file_path",
+	"filePath",
+	"notebook_path",
+	"filename"
+];
+/**
+* Whether a tool name looks like it MUTATES files. Deliberately coarse
+* (substring match on the mutating verbs) so host-side and plugin-side
+* file tools both qualify; read-only tools never match.
+*/
+function isWriteTool(name) {
+	const lowered = name.toLowerCase();
+	return /write|edit|patch|apply|create_file|insert/.test(lowered);
+}
+/** Extract the addressed path from one tool call's arguments JSON. */
+function argumentPath(args) {
+	if (args === "") return void 0;
+	try {
+		const parsed = JSON.parse(args);
+		for (const key of PATH_KEYS) {
+			const value = parsed[key];
+			if (typeof value === "string" && value !== "") return value;
+		}
+	} catch {}
+}
+/**
+* Fold a session event log into the deduplicated file-operation list,
+* newest first. `tool/call` events with a mutating tool name and an
+* addressable path are collected; every path keeps only its latest call
+* (plus a touch count). Rows outside a live sessions registry read come
+* back as an empty list — the page degrades to the empty state.
+* @param events - the session's append-only event log (oldest → newest).
+*/
+function sessionFileOps(events) {
+	const byPath = /* @__PURE__ */ new Map();
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (event === void 0 || event.type !== "tool/call") continue;
+		const name = typeof event.data.name === "string" ? event.data.name : "";
+		if (name === "" || !isWriteTool(name)) continue;
+		const path = argumentPath(typeof event.data.arguments === "string" ? event.data.arguments : "");
+		if (path === void 0) continue;
+		const existing = byPath.get(path);
+		if (existing === void 0) byPath.set(path, {
+			path,
+			tool: name,
+			time: event.time,
+			count: 1
+		});
+		else existing.count += 1;
+	}
+	return [...byPath.values()].sort((left, right) => right.time - left.time);
+}
 //#endregion
 //#region src/fs-search.ts
 /**
@@ -1201,6 +1347,36 @@ async function show(cwd, rev, path, selected) {
 		return null;
 	}
 }
+/**
+* Both sides' full file contents for a diff-fold expansion. `path` is
+* repo-relative. The sides resolve per diff kind: a commit reads
+* `<hash>^` vs `<hash>`; a staged change reads HEAD vs the index (`:`);
+* an unstaged change reads HEAD vs the working tree file on disk (a side
+* that does not exist — untracked, deleted, binary-refused — comes back
+* null and the client degrades the fold to a static marker).
+*/
+async function foldContents(cwd, path, opts = {}, selected) {
+	const root = await repoRoot(cwd, selected);
+	if (opts.hash !== void 0) {
+		const [old, neu] = await Promise.all([show(root, `${opts.hash}^`, path, selected), show(root, opts.hash, path, selected)]);
+		return {
+			old,
+			new: neu
+		};
+	}
+	if (opts.staged === true) {
+		const [old, neu] = await Promise.all([show(root, "HEAD", path, selected), show(root, ":", path, selected)]);
+		return {
+			old,
+			new: neu
+		};
+	}
+	const [old, neu] = await Promise.all([show(root, "HEAD", path, selected), readFile(isAbsolute(path) ? path : join(root, path), "utf8").catch(() => null)]);
+	return {
+		old,
+		new: neu
+	};
+}
 /** Full patch text of one commit (`git show` with the commit header suppressed).
 *  Merge commits show their diff against the first parent (`-m --first-parent`
 *  is a no-op for regular commits), so a history click always has content. */
@@ -4133,6 +4309,21 @@ function buildApi(ctx, ptyManager, agentPtyRegistry, resolved, terminalShell, ge
 			}
 			return { ok: true };
 		},
+		"fs.rename": async (payload) => {
+			const { cwd } = await cwdOf(payload);
+			return renameWorkspaceEntry({
+				cwd,
+				path: requireString(payload, "path"),
+				name: requireString(payload, "name")
+			});
+		},
+		"fs.remove": async (payload) => {
+			const { cwd } = await cwdOf(payload);
+			return removeWorkspaceEntry({
+				cwd,
+				path: requireString(payload, "path")
+			});
+		},
 		"git.worktrees": async (payload) => {
 			const { cwd } = await gitCwdOf(payload);
 			const selected = selectedRepoOf(payload);
@@ -4203,6 +4394,15 @@ function buildApi(ctx, ptyManager, agentPtyRegistry, resolved, terminalShell, ge
 			const path = await resolveGitPath(cwd, requireString(payload, "path"), repoRoot);
 			return { content: await show(cwd, requireString(payload, "rev"), path, repoRoot) };
 		},
+		"git.fold-contents": async (payload) => {
+			const { cwd } = await gitCwdOf(payload);
+			const repoRoot = selectedRepoOf(payload);
+			const record = payload;
+			return await foldContents(cwd, await resolveGitPath(cwd, requireString(record, "path"), repoRoot), {
+				staged: record.staged === true,
+				hash: typeof record.hash === "string" ? record.hash : void 0
+			}, repoRoot);
+		},
 		"pty.close": (payload) => {
 			const sessionId = requireString(payload, "sessionId");
 			const tab = requireString(payload, "tab");
@@ -4214,9 +4414,21 @@ function buildApi(ctx, ptyManager, agentPtyRegistry, resolved, terminalShell, ge
 			agentPtyRegistry?.close(uuid);
 			return { ok: true };
 		},
+		"agent-pty.skip-wait": (payload) => {
+			const uuid = requireString(payload, "uuid");
+			return {
+				ok: true,
+				skipped: agentPtyRegistry?.skipWait(uuid) ?? 0
+			};
+		},
 		"terminal.deps": () => depsStatus(),
 		"jobs.output": (payload) => jobsApi.output(payload),
 		"jobs.kill": (payload) => jobsApi.kill(payload),
+		"changes.ops": async (payload) => {
+			const sessionId = requireString(payload, "sessionId");
+			const stored = ctx.sessions.get(sessionId);
+			return { ops: sessionFileOps(stored?.snapshotEvents !== void 0 ? stored.snapshotEvents() : []) };
+		},
 		"subagents.live": (payload) => subagentLiveApi.live(payload),
 		"shell.get": () => ({
 			shell: terminalShell,

package/lib/types/changes-ops.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure derivation of the "session lens": the file operations the model
+ * performed in one session, parsed from the session's own event log (the
+ * same durable log the side chat reads — nothing here touches the host
+ * registry or the model's cursors). Kept framework-free so the parser is
+ * unit-testable in the node environment.
+ */
+import type { SidebarSessionEvent } from './context-types.ts';
+/**
+ * One deduplicated file operation: the LATEST write-shaped tool call that
+ * touched `path` (earlier calls to the same file fold into it).
+ */
+export interface SessionFileOp {
+    /** The file path as the tool call addressed it (verbatim). */
+    path: string;
+    /** The tool that performed the latest operation (e.g. write_file). */
+    tool: string;
+    /** Epoch ms of the event. */
+    time: number;
+    /** How many write-shaped calls touched this path in total. */
+    count: number;
+}
+/**
+ * Fold a session event log into the deduplicated file-operation list,
+ * newest first. `tool/call` events with a mutating tool name and an
+ * addressable path are collected; every path keeps only its latest call
+ * (plus a touch count). Rows outside a live sessions registry read come
+ * back as an empty list — the page degrades to the empty state.
+ * @param events - the session's append-only event log (oldest → newest).
+ */
+export declare function sessionFileOps(events: readonly SidebarSessionEvent[]): SessionFileOp[];

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

@@ -1,3 +1,5 @@
+import { type SessionScope } from './api.ts';
+import type { SidebarDiffRef } from './state.ts';
 /** One rendered diff line. */
 export interface DiffLine {
     kind: 'ctx' | 'del' | 'add' | 'meta';
@@ -41,11 +43,41 @@ export interface ParsedDiff {
  * can still draw its path.
  */
 export declare function parseUnifiedDiff(text: string): ParsedDiff;
+/** The old/new line range one hidden gap spans (both sides derive from the
+ *  surrounding hunk headers and their counted rows). */
+interface DiffFoldRange {
+    oldStart: number;
+    oldEnd: number;
+    newStart: number;
+    newEnd: number;
+}
+/**
+ * Materialize a git gap fold's hidden rows from the two sides' full file
+ * contents, by the fold's known line ranges: the old side drives context
+ * rows (each mapped onto the new side through the fold's offset — a gap is
+ * an unchanged run, so the sides align), and new-side lines the old range
+ * never reaches become pure additions. Line numbers clip to the actual
+ * content (a no-newline file's ranges can overrun by one); `\r` endings
+ * survive verbatim, like git's own context lines.
+ */
+export declare function foldRowsFromContents(fold: DiffFoldRange, oldContent: string, newContent: string): DiffLine[];
 export interface DiffViewProps {
     /** Unified diff text (`git.diff` or `git.commit-diff` payloads). */
     diff: string;
     /** Untracked-file content: when present, renders as a full-file addition instead of parsing. */
     untrackedPath?: string;
     untrackedContent?: string;
+    /**
+     * When present (a worktree/commit diff ref plus its scope), hunk gaps
+     * render an expandable fold: clicking resolves both sides' full contents
+     * (`git.fold-contents`) and materializes the hidden context rows. Absent
+     * (or an untracked full-addition render) — no fold rows at all.
+     */
+    foldSource?: {
+        scope: SessionScope;
+        ref: SidebarDiffRef;
+        cwd: string | undefined;
+    };
 }
-export declare function DiffView({ diff, untrackedPath, untrackedContent }: DiffViewProps): import("react").JSX.Element | null;
+export declare function DiffView({ diff, untrackedPath, untrackedContent, foldSource }: DiffViewProps): import("react").JSX.Element | null;
+export {};

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

@@ -10,4 +10,7 @@ export declare function EditorHost(props: {
     revealed: string[];
     onToggleDir: (path: string) => void;
     onReferenceFile: (path: string, isDir: boolean) => void;
+    /** Tree-row mutations (passed through to the file tree; absent → hidden). */
+    onPathRenamed?: (oldPath: string, newPath: string) => void;
+    onPathRemoved?: (path: string) => void;
 }): import("react").JSX.Element;

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

@@ -35,4 +35,8 @@ export declare function FileTree(props: {
     onUploadRequest: (dir: string, items: UploadItem[]) => void;
     /** True while an upload is in flight (drops are ignored). */
     busy: boolean;
+    /** A tree row was renamed (retarget open tabs; absent → no rename entry). */
+    onPathRenamed?: (oldPath: string, newPath: string) => void;
+    /** A tree row was removed (close affected tabs; absent → no delete entry). */
+    onPathRemoved?: (path: string) => void;
 }): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+import { type SessionScope } from './api.ts';
+export declare function SessionLens(props: {
+    scope: SessionScope;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,6 @@
+/** Truncate one needle for inline display (title attr carries the full text). */
+export declare function truncateNeedle(needle: string): string;
+export declare function TerminalWaitBanner(props: {
+    needle: string;
+    onSkip: () => void;
+}): import("react").JSX.Element;

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

@@ -18,6 +18,9 @@ export declare function TreePanel(props: {
     onOpenWith?: (targetId: string, path: string) => void;
     onToggleOpenWithPin?: (targetId: string) => void;
     onReferenceFile: (path: string, isDir: boolean) => void;
+    /** Tree-row mutations (passed through to the file tree; absent → hidden). */
+    onPathRenamed?: (oldPath: string, newPath: string) => void;
+    onPathRemoved?: (path: string) => void;
     /** Full-window presentation: the panel fills its host instead of docking
      *  at a fixed width. */
     full?: boolean;

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

@@ -138,6 +138,16 @@ export declare const api: {
     fsWrite: (scope: SessionScope, path: string, content: string) => Promise<{
         ok: true;
     }>;
+    /** Rename one tree row within its directory (single-segment name; a
+     *  destination-existence clash is a 409; symlink rows rename the link). */
+    fsRename: (scope: SessionScope, path: string, name: string) => Promise<{
+        path: string;
+    }>;
+    /** Delete one tree row permanently (recursive for directories; a symlink
+     *  row unlinks the link only). */
+    fsRemove: (scope: SessionScope, path: string) => Promise<{
+        path: string;
+    }>;
     /** Upload one file's raw bytes into `dir` (keeps the folder tree via
      *  `relativePath`); the host streams it under the session workspace. */
     uploadFile: (scope: SessionScope, dir: string, relativePath: string, body: Blob, signal?: AbortSignal) => Promise<{
@@ -171,6 +181,16 @@ export declare const api: {
     gitCommitDiff: (scope: SessionScope, hash: string, worktree?: string, signal?: AbortSignal) => Promise<{
         diff: string;
     }>;
+    /** Both sides' full file contents for a diff-fold expansion; a missing
+     *  side is null (untracked / deleted) and the view degrades the fold. */
+    gitFoldContents: (scope: SessionScope, opts: {
+        path: string;
+        staged?: boolean;
+        hash?: string;
+    }, worktree?: string, signal?: AbortSignal) => Promise<{
+        old: string | null;
+        new: string | null;
+    }>;
     /** Discard the worktree changes of one file (the index is untouched). */
     gitDiscard: (scope: SessionScope, path: string, worktree?: string) => Promise<{
         ok: true;
@@ -193,6 +213,22 @@ export declare const api: {
     agentPtyClose: (uuid: string) => Promise<{
         ok: true;
     }>;
+    /** Skip every active terminal_wait_for on one agent terminal (the wait
+     *  banner's skip button). Idempotent: {skipped:0} when none is active. */
+    agentSkipWait: (uuid: string) => Promise<{
+        ok: true;
+        skipped: number;
+    }>;
+    /** The session lens: file operations the model performed in one session
+     *  (parsed from the session's own event log; newest first). */
+    changesOps: (scope: SessionScope, signal?: AbortSignal) => Promise<{
+        ops: Array<{
+            path: string;
+            tool: string;
+            time: number;
+            count: number;
+        }>;
+    }>;
     /** Terminal dependency status (issue #140): after a WS close 1011 with
      *  reason `pty-deps-missing` the view fetches the full repair details here
      *  (the close reason itself is capped at 123 bytes). */

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

@@ -159,6 +159,26 @@ export declare const zh: {
     producedOpen: string;
     showInFolder: string;
     disconnected: string;
+    terminalWaitBanner: string;
+    terminalSkipWait: string;
+    gitFoldExpand: string;
+    gitFoldLoading: string;
+    gitFoldFailed: string;
+    rename: string;
+    renameInvalid: string;
+    delete: string;
+    deleteTitle: string;
+    deleteDescFile: string;
+    deleteDescDir: string;
+    dismiss: string;
+    changesSessionGit: string;
+    changesSessionLens: string;
+    changesEmpty: string;
+    changesCount: string;
+    changesRedacted: string;
+    changesBinary: string;
+    changesPreviewError: string;
+    changesLens: string;
     exited: string;
     noSession: string;
     pluginNotLoaded: string;

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

@@ -0,0 +1,14 @@
+/**
+ * Secret redaction for the session lens' file preview: heuristic masking of
+ * credential-shaped strings (API keys, bearer tokens, private key blocks,
+ * password assignments) before file content is shown in the sidebar. This
+ * layer applies ONLY to the session lens' preview pane — ordinary file reads
+ * (editor, untracked diff fallback) never pass through it, so ordinary
+ * files' content is untouched.
+ */
+/**
+ * Mask credential-shaped strings in `text`. Best-effort by design: the goal
+ * is to keep the common accident (a key echoed into a file the model wrote)
+ * out of the sidebar, not to parse every secret format ever shipped.
+ */
+export declare function redactSecrets(text: string): string;

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

@@ -110,6 +110,17 @@ export interface SidebarState {
     splits: SplitNode;
     /** Free windows (tabs dragged out onto the conversation area). */
     floats: FloatWindow[];
+    /**
+     * Live agent-terminal wait state (uuid → the wait the model currently
+     * blocks on in `terminal_wait_for`), mirrored from the host's
+     * agent-terminals push. Transient by design: sanitizeState never restores
+     * it, so a reload starts clean and the next push (sent immediately on WS
+     * attach) repopulates it.
+     */
+    agentWaits: Record<string, {
+        needle: string;
+        since: number;
+    }>;
 }
 export declare const PANEL_MIN = 280;
 export declare const PANEL_MAX = 640;
@@ -325,6 +336,10 @@ export declare function agentTabId(uuid: string): string;
 export declare function reconcileAgentTerminals(state: SidebarState, agentTerminals: ReadonlyArray<{
     uuid: string;
     title: string;
+    waiting?: {
+        needle: string;
+        since: number;
+    } | null;
 }>): SidebarState;
 /** Immutable snapshot handed to React (replaced only on real changes). */
 export interface SidebarSnapshot {

package/lib/types/fs-operations.d.ts

@@ -26,3 +26,45 @@ export declare function writeWorkspaceUpload(input: WorkspaceUploadInput): Promi
     path: string;
     size: number;
 }>;
+/** Inputs of one tree-row rename. */
+export interface WorkspaceRenameInput {
+    /** The session workspace root; the renamed entry must stay inside it. */
+    cwd: string;
+    /** Absolute path of the row as the tree displays it (may be a symlink). */
+    path: string;
+    /** The new base name (single segment — rename never moves across directories). */
+    name: string;
+}
+/**
+ * Rename one tree row within its directory: `path` → `<parent>/<name>`.
+ * The new name must be a single path segment (this is rename, not move);
+ * an existing destination is refused (POSIX rename would clobber it
+ * silently); the workspace root itself is never renamable; a symlink row
+ * renames the link, not its target. A no-op rename (same name) succeeds
+ * without touching the filesystem.
+ *
+ * @throws SidebarError with a wire code for shape, containment, existence
+ * and root failures.
+ */
+export declare function renameWorkspaceEntry(input: WorkspaceRenameInput): Promise<{
+    path: string;
+}>;
+/** Inputs of one tree-row delete. */
+export interface WorkspaceRemoveInput {
+    /** The session workspace root; the removed entry must stay inside it. */
+    cwd: string;
+    /** Absolute path of the row as the tree displays it (may be a symlink). */
+    path: string;
+}
+/**
+ * Delete one tree row permanently (there is no trash on the host): files are
+ * unlinked, directories removed recursively, a symlink row unlinks the LINK
+ * only (lstat decides, so a link to a directory does not recurse into its
+ * target). The workspace root itself is never removable.
+ *
+ * @throws SidebarError with a wire code for containment, existence and
+ * root failures.
+ */
+export declare function removeWorkspaceEntry(input: WorkspaceRemoveInput): Promise<{
+    path: string;
+}>;

package/lib/types/git.d.ts

@@ -112,6 +112,21 @@ export declare function log(cwd: string, count?: number, skip?: number, selected
  * revision has no such path (a new/untracked file has no HEAD side).
  */
 export declare function show(cwd: string, rev: string, path: string, selected?: string): Promise<string | null>;
+/**
+ * Both sides' full file contents for a diff-fold expansion. `path` is
+ * repo-relative. The sides resolve per diff kind: a commit reads
+ * `<hash>^` vs `<hash>`; a staged change reads HEAD vs the index (`:`);
+ * an unstaged change reads HEAD vs the working tree file on disk (a side
+ * that does not exist — untracked, deleted, binary-refused — comes back
+ * null and the client degrades the fold to a static marker).
+ */
+export declare function foldContents(cwd: string, path: string, opts?: {
+    staged?: boolean;
+    hash?: string;
+}, selected?: string): Promise<{
+    old: string | null;
+    new: string | null;
+}>;
 /** Full patch text of one commit (`git show` with the commit header suppressed).
  *  Merge commits show their diff against the first parent (`-m --first-parent`
  *  is a no-op for regular commits), so a history click always has content. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-coding-sidebar",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "DSH web plugin: a VSCode-like right sidebar (explorer / editor / terminal / git / browser), isolated per conversation session. Exposes the betterSidebar service for other plugins to register sidebar tabs and file viewers. KCoder-maintained fork of DSH-better-sidebar 0.17.2 (bottom panel removed, upstream-decoupled release line).",
   "type": "module",
   "repository": {