dsh-vscode-mode 0.1.30 → 0.1.32

package/lib/index.js

@@ -1,8 +1,8 @@
 import { createRequire } from "node:module";
-import { readFile, stat } from "node:fs/promises";
-import { dirname, extname, join, normalize, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, normalize, resolve, sep } from "node:path";
 import { existsSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 //#region src/mcp.ts
@@ -368,6 +368,258 @@ async function runPnpmInstall(ctx, profileDir) {
 	}
 }
 //#endregion
+//#region src/shared/rpc.ts
+/** webServer 精确路由。 */
+const RPC_PATH = "/edrv/rpc";
+//#endregion
+//#region src/paths.ts
+/**
+* dsh-vscode-mode host — 路径常量与动态路径统一出口（PathConst）。
+* 所有 host 侧文件路径/缓存键/路由前缀从这里取，避免散落内联：
+* - 静态：插件缓存根（~/.dsh/dsh-vscode-mode/cache，下分 workspace/ 工作区级与
+*   user/ 用户级）、日志根、工作区侧车名、路由前缀、静态资源目录（import.meta.url 派生）
+* - 动态：每工作区树缓存文件（workspace/<id>/tree.v<schema>.json）、home 解析
+*   （DSH_HOME → ~/.dsh）
+* - 清理：缓存 sweep（分级：工作区级按版本/TTL/空目录、用户级按版本/保留期、根级残留）
+* 纯函数可单测；raw fs 写入与引擎自身插件（settings-file 用 node:fs + DSH_HOME）一致。
+* 作者 ddj 2026-09-01
+*/
+/** 插件 id（也是 .dsh 下插件工作区目录名）。 */
+const PLUGIN_ID = "dsh-vscode-mode";
+/** DSH 工作区目录名（默认 home 下）。 */
+const DSH_DIR_NAME = ".dsh";
+/** home 覆盖环境变量（与引擎 resolveDshHome 一致）。 */
+const DSH_HOME_ENV = "DSH_HOME";
+/** 插件缓存目录总预算：超限按 mtime 从旧到新删文件，防任意增长撑爆磁盘（最后兜底）。 */
+const CACHE_TOTAL_CAP = 209715200;
+/** 工作区根侧车：审查记录（用户数据，随项目走，不迁移）。 */
+const SIDECAR = ".dsh-edit-review.json";
+/** 工作区根侧车：归档（用户数据）。 */
+const SIDECAR_ARCHIVE = ".dsh-edit-review-archive.json";
+/** 旧 debug 日志文件名（工作区，迁移后由插件清理）。 */
+const DEBUG_LOG = ".dsh-edit-review-debug.log";
+/** 旧树缓存 sidecar 名（工作区，迁移后由插件清理；缓存可重建，删除无损）。 */
+const LEGACY_TREE_SIDECARS = [".dsh-edit-review-tree.json", ".dsh-vscode-mode-tree.json"];
+/** 路由前缀（兼容性检查用）。 */
+const ROUTE_PREFIX = "/edrv";
+/** Monaco 静态资源前缀。 */
+const VENDOR_PREFIX = "/edrv/vendor";
+/** 稳定短哈希（cwd → 缓存文件名段；sha1 截断，跨运行稳定）。 */
+function hashOf(text) {
+	return createHash("sha1").update(String(text)).digest("hex").slice(0, 16);
+}
+/**
+* 可读安全路径段编码：非安全码位 → ~XXXX 大写十六进制（`~` 本身也转义）。
+* 与 DSH 引擎 dsh-session-persistence-jsonl 的 encodeSegment 逐字节一致，
+* 用于从 cwd/id 反推 `~/.dsh/sessions` 下的会话目录，纯函数可单测。
+* @author ddj 2026年09月02号
+* @param raw 原始路径段（非空）
+* @returns 路径安全段（`.`/`..` 特判为 ~002E / ~002E~002E）
+*/
+function encodeSegment(raw) {
+	if (raw.length === 0) throw new Error("cannot encode an empty path segment");
+	if (raw === ".") return "~002E";
+	if (raw === "..") return "~002E~002E";
+	let out = "";
+	for (let i = 0; i < raw.length; i++) {
+		const code = raw.charCodeAt(i);
+		const ch = String.fromCharCode(code);
+		if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) out += ch;
+		else out += "~" + code.toString(16).toUpperCase().padStart(4, "0");
+	}
+	return out;
+}
+/**
+* DSH 工作区目录键：cwd → `--<可读键>--`。分隔符（/ \ :）折叠为单个 `-`，
+* 其余非安全码位转 ~XXXX，`--` 包裹、251 截断。与引擎 projectKey 一致。
+* @author ddj 2026年09月02号
+* @param cwd 会话工作区绝对路径（非空）
+* @returns `~/.dsh/sessions` 下的工作区目录名
+*/
+function sessionWorkspaceKey(cwd) {
+	if (cwd.length === 0) throw new Error("cannot encode an empty project path");
+	let readable = "";
+	let separatorRun = false;
+	for (let i = 0; i < cwd.length; i++) {
+		const code = cwd.charCodeAt(i);
+		const ch = String.fromCharCode(code);
+		if (ch === "/" || ch === "\\" || ch === ":") {
+			if (!separatorRun) readable += "-";
+			separatorRun = true;
+		} else if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) {
+			readable += ch;
+			separatorRun = false;
+		} else {
+			readable += "~" + code.toString(16).toUpperCase().padStart(4, "0");
+			separatorRun = false;
+		}
+	}
+	return `--${(readable.replace(/^-+/, "") || "root").slice(0, 251)}--`;
+}
+/** DSH 会话目录段：id → 路径安全段（与引擎 encodeSegment 一致）。 */
+function sessionIdSegment(id) {
+	return encodeSegment(id);
+}
+/** DSH 会话根目录（~/.dsh/sessions；引擎 dsh-base 默认 root）。 */
+function sessionsRoot(home = dshHome()) {
+	return join(home, "sessions");
+}
+/**
+* 解析 DSH home：DSH_HOME（去空白）→ ~/.dsh。
+* @author ddj 2026年09月01号
+* @param env 环境映射（缺省 process.env；测试可注入）
+* @returns 归一化的 DSH home 绝对路径
+*/
+function dshHome(env = process.env) {
+	const value = env[DSH_HOME_ENV];
+	if (value && value.trim()) return value;
+	return join(homedir(), DSH_DIR_NAME);
+}
+/** 插件缓存根（~/.dsh/dsh-vscode-mode/cache，下分 workspace/ 与 user/ 两级）。 */
+function pluginCacheRoot(home = dshHome()) {
+	return join(home, PLUGIN_ID, "cache");
+}
+/** 工作区级缓存目录：按工作区 id（cwd hash）隔离，换工作区即失效。 */
+function workspaceCacheDir(workspaceId, home = dshHome()) {
+	return join(pluginCacheRoot(home), "workspace", workspaceId);
+}
+/** 插件日志根（~/.dsh/dsh-vscode-mode/logs，用户级）。 */
+function pluginLogRoot(home = dshHome()) {
+	return join(home, PLUGIN_ID, "logs");
+}
+/** 每工作区树缓存文件（工作区级：workspace/<id>/tree.v<schema>.json，文件名含版本便于 sweep）。 */
+function treeCacheFile(cwd, home = dshHome(), schema = 1) {
+	return join(workspaceCacheDir(hashOf(cwd), home), "tree.v" + schema + ".json");
+}
+/** 每工作区 debug 日志文件（用户级日志根下，按 cwd hash 隔离）。 */
+function debugLogFile(cwd, home = dshHome()) {
+	return join(pluginLogRoot(home), "debug." + hashOf(cwd) + ".log");
+}
+/** 插件包 assets 目录（import.meta.url 派生；config.imageDir 可覆盖，见 imageDirOf）。 */
+function assetsDirOf(moduleUrl) {
+	return join(dirname(fileURLToPath(moduleUrl)), "..", "assets");
+}
+/** Monaco AMD 静态目录（随包发布）。 */
+function vendorDirOf(moduleUrl) {
+	return join(assetsDirOf(moduleUrl), "vendor");
+}
+/** 图标目录：config.imageDir 覆盖优先，否则插件包 assets/。 */
+function imageDirOf(config, moduleUrl) {
+	const cfg = config;
+	if (cfg && typeof cfg.imageDir === "string" && cfg.imageDir) return cfg.imageDir.replace(/\\/g, "/");
+	return assetsDirOf(moduleUrl);
+}
+/** 树缓存文件名 → schema 版本（不匹配返回 null）。 */
+function treeSchemaOf(filename) {
+	const m = /^tree\.v(\d+)\./.exec(filename);
+	return m ? Number(m[1]) : null;
+}
+/** 按「schema 版本 + 保留期」清扫某目录内文件（目录级，返回相对路径清单）。 */
+async function sweepDirFiles(dir, removed, now, dropAll) {
+	const names = await readdir(dir).catch(() => []);
+	for (const name of names) {
+		const full = join(dir, name);
+		let drop = dropAll;
+		if (!drop) {
+			const schema = treeSchemaOf(name);
+			if (schema === null) drop = true;
+			else if (schema !== 1) drop = true;
+			else try {
+				if (now - (await stat(full)).mtimeMs > 2592e6) drop = true;
+			} catch (error) {
+				drop = true;
+			}
+		}
+		if (!drop) continue;
+		try {
+			await rm(full, { force: true });
+			removed.push(name);
+		} catch (error) {}
+	}
+}
+/** 清扫工作区级缓存：逐工作区目录按版本/TTL 清文件，空目录删除。 */
+async function sweepWorkspaceTier(dir, removed, now) {
+	const ids = await readdir(dir).catch(() => []);
+	for (const id of ids) {
+		const wsDir = join(dir, id);
+		await sweepDirFiles(wsDir, removed, now, false);
+		if (!(await readdir(wsDir).catch(() => [])).length) await rm(wsDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	}
+}
+/** 总预算兜底：递归收集全部缓存文件，按 mtime 从旧到新删，直到总大小 ≤ 预算。 */
+async function sweepByTotalCap(root, removed, cap) {
+	const files = [];
+	const walk = async (dir) => {
+		const names = await readdir(dir).catch(() => []);
+		for (const name of names) {
+			const full = join(dir, name);
+			try {
+				const info = await stat(full);
+				if (info.isDirectory()) await walk(full);
+				else files.push({
+					path: full,
+					mtime: info.mtimeMs,
+					size: info.size
+				});
+			} catch (error) {}
+		}
+	};
+	await walk(root);
+	let total = files.reduce((sum, f) => sum + f.size, 0);
+	files.sort((a, b) => a.mtime - b.mtime);
+	for (const f of files) {
+		if (total <= cap) break;
+		try {
+			await rm(f.path, { force: true });
+			total -= f.size;
+			removed.push(f.path.slice(root.length + 1));
+		} catch (error) {}
+	}
+}
+/**
+* 清理插件缓存根（分级 + 总预算兜底）：
+* - 根级残留文件（旧扁平格式/未知）→ 删
+* - workspace/ 工作区级 → 按「schema 版本 + 保留期」清文件，空目录删除
+* - user/ 用户级 → 按「schema 版本 + 保留期」清文件
+* - 总大小超预算 → 按最旧先删（最后防线，防任意增长撑爆磁盘）
+* best-effort 静默。
+* @author ddj 2026年09月01号
+* @param home DSH home（测试可注入）
+* @param cap 总预算字节数（缺省 CACHE_TOTAL_CAP；测试可注入小预算）
+* @returns 删除的文件相对路径清单
+*/
+async function sweepTreeCache(home = dshHome(), cap = CACHE_TOTAL_CAP) {
+	const dir = pluginCacheRoot(home);
+	const names = await readdir(dir).catch(() => []);
+	if (!names.length) return [];
+	const removed = [];
+	const now = Date.now();
+	await Promise.all(names.map(async (name) => {
+		const full = join(dir, name);
+		try {
+			if ((await stat(full)).isDirectory()) {
+				if (name === "workspace") await sweepWorkspaceTier(full, removed, now);
+				else if (name === "user") await sweepDirFiles(full, removed, now, false);
+				else {
+					await rm(full, {
+						recursive: true,
+						force: true
+					});
+					removed.push(name);
+				}
+			} else {
+				await rm(full, { force: true });
+				removed.push(name);
+			}
+		} catch (error) {}
+	}));
+	await sweepByTotalCap(dir, removed, cap);
+	return removed;
+}
+//#endregion
 //#region src/compat.ts
 /**
 * dsh-vscode-mode host — 兼容层：与其他插件 / DSH 版本的统一探测、适配、护栏与自诊断。
@@ -381,8 +633,6 @@ const PLUGIN_NAME = "dsh-vscode-mode";
 const MCP_PACKAGE = "@deepseek-ai/dsh-mcp-client";
 /** 项目级 MCP 的 loader entry id 固定前缀（区分 profile 全局 MCP；loader id 不能用 ':'，故用 '.'）。 */
 const PROJECT_ENTRY_PREFIX = "vsm-mcp.";
-/** webServer 路由前缀（RPC 精确路由 + 静态资源前缀共用）。 */
-const ROUTE_PREFIX = "/edrv";
 /** 判断新旧格式项目 MCP 条目 id（旧残留不被视为全局 MCP）。 */
 function isProjectEntryId(id) {
 	return id.startsWith("vsm-mcp.") || id.startsWith("vsm-mcp:");
@@ -508,10 +758,6 @@ async function buildReport(ctx, options) {
 	};
 }
 //#endregion
-//#region src/shared/rpc.ts
-/** webServer 精确路由。 */
-const RPC_PATH = "/edrv/rpc";
-//#endregion
 //#region src/routes.ts
 /**
 * dsh-vscode-mode host — webServer 路由注册（/edrv/rpc、/edrv/assets/*、/edrv/vendor/*）。
@@ -526,7 +772,6 @@ const IMG_ROUTES = [{
 	file: "compare_select.png"
 }];
 /** Monaco AMD 构建静态资源（随包发布，离线可用；前缀路由 /edrv/vendor/*）。 */
-const VENDOR_PREFIX = "/edrv/vendor";
 const VENDOR_MIME = {
 	".js": "text/javascript; charset=utf-8",
 	".css": "text/css; charset=utf-8",
@@ -543,14 +788,10 @@ const VENDOR_MIME = {
 	".html": "text/html; charset=utf-8",
 	".md": "text/markdown"
 };
-/** 图标目录：默认插件包内 assets/（随包发布）；config.imageDir 可覆盖（用于自定义换图）。 */
-function imageDirOf(config) {
-	const cfg = config;
-	if (cfg && typeof cfg.imageDir === "string" && cfg.imageDir) return cfg.imageDir.replace(/\\/g, "/");
-	return join(dirname(fileURLToPath(import.meta.url)), "..", "assets");
-}
-/** Monaco AMD 静态目录（随包发布）。 */
-const vendorDir = join(dirname(fileURLToPath(import.meta.url)), "..", "assets", "vendor");
+/** 图标目录（paths.ts 统一解析：config.imageDir 覆盖优先，否则插件包 assets/）。 */
+const imgDirOf = (config) => imageDirOf(config, import.meta.url);
+/** Monaco AMD 静态目录（随包发布，paths.ts 统一解析）。 */
+const vendorDir = vendorDirOf(import.meta.url);
 /**
 * 注册全部 webServer 路由（带兼容护栏：前缀冲突预警 + 注册失败降级跳过）。
 * @author ddj 2026年08月20号
@@ -560,7 +801,7 @@ const vendorDir = join(dirname(fileURLToPath(import.meta.url)), "..", "assets",
 * @param onWarning 兼容性警告收集（可选）
 */
 function registerRoutes(ctx, config, handleRpc, onWarning) {
-	const imgDir = imageDirOf(config);
+	const imgDir = imgDirOf(config);
 	const web = ctx.get("webServer");
 	if (!web) return;
 	resetOwnRoutes();
@@ -1068,10 +1309,6 @@ function archiveEntryFor(recs, cwd, reason) {
 		}))
 	};
 }
-//#endregion
-//#region src/store.ts
-const SIDECAR = ".dsh-edit-review.json";
-const SIDECAR_ARCHIVE = ".dsh-edit-review-archive.json";
 /** 会话沙箱策略（policyOf）：可能不存在，调用方需容忍 undefined。 */
 function policyOf(ctx, session) {
 	const svc = ctx.get("sandboxPolicy");
@@ -1333,6 +1570,459 @@ function bucketOf(registry, ctx, cwd) {
 	});
 }
 //#endregion
+//#region src/tree.ts
+/** 目录在文件前、名称按小写字母序的比较器（对齐 VSCode 资源管理器习惯）。 */
+function entryOrder(a, b) {
+	const aDir = a.type === "directory" ? 0 : 1;
+	const bDir = b.type === "directory" ? 0 : 1;
+	if (aDir !== bDir) return aDir - bDir;
+	const la = a.name.toLocaleLowerCase("en-US");
+	const lb = b.name.toLocaleLowerCase("en-US");
+	return la < lb ? -1 : la > lb ? 1 : 0;
+}
+/**
+* 归一化目录相对路径：去空白、反斜杠→斜杠、去首尾斜杠、`.`→''。
+* 任一路径段为 `..` 返回 null（拒绝越界）。
+* @author ddj 2026年08月26号
+* @param path 原始相对路径（'' 表示根目录）
+* @returns 归一化相对路径（'' = 根），非法返回 null
+*/
+function normalizeRel(path) {
+	const rel = String(path ?? "").trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+	if (!rel) return "";
+	const segs = rel.split("/").filter((seg) => seg !== ".");
+	if (!segs.length) return "";
+	for (const seg of segs) if (seg === "..") return null;
+	return segs.join("/");
+}
+/**
+* fs.listDir 结果 → TreeEntry 数组：相对路径拼接 + 目录优先排序。
+* @author ddj 2026年08月26号
+* @param rel 父目录相对路径（'' = 根）
+* @param children 目录子项
+* @returns 排序后的树条目
+*/
+function toTreeEntries(rel, children) {
+	const out = [];
+	for (const child of children) {
+		if (!child || typeof child.name !== "string" || !child.name) continue;
+		out.push({
+			name: child.name,
+			path: rel ? rel + "/" + child.name : child.name,
+			type: child.type === "directory" ? "directory" : child.type === "file" ? "file" : "other",
+			size: typeof child.size === "number" ? child.size : void 0
+		});
+	}
+	return out.sort(entryOrder);
+}
+/** 列取失败（带稳定语义 code，调用方转文案）。 */
+var DirListError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+/** node fs 错误码 → 稳定语义错误。 */
+function codeOf(err) {
+	const code = err?.code;
+	if (code === "ENOENT") return new DirListError("not-found", "目录不存在");
+	if (code === "ENOTDIR") return new DirListError("not-dir", "不是目录");
+	if (code === "EACCES" || code === "EPERM" || code === "EBUSY") return new DirListError("permission", "权限不足");
+	return new DirListError("io", String(err?.message ?? err));
+}
+/** 并行 stat 一批绝对路径 → 目录/文件/other（follow symlink，失败按 other）。 */
+async function statTypes(paths, out) {
+	const cap = Math.min(paths.length, 256);
+	for (let i = 0; i < cap; i += 32) {
+		const chunk = paths.slice(i, i + 32);
+		await Promise.all(chunk.map(async (p) => {
+			try {
+				const info = await stat(p);
+				out.set(p, info.isDirectory() ? "directory" : info.isFile() ? "file" : "other");
+			} catch (error) {
+				out.set(p, "other");
+			}
+		}));
+	}
+}
+/**
+* 快速列取目录：一次 readdir(withFileTypes) 判型；symlink 并行 follow-stat。
+* @author ddj 2026年08月31号
+* @param absDir 绝对目录路径（fs.resolve 后的 targetKey）
+* @returns 子项列表（name/type；size 缺省，树界面不展示大小）
+* @throws DirListError 目录不存在/不是目录/权限不足/IO 失败
+*/
+async function listDirCheap(absDir) {
+	let dirents;
+	try {
+		dirents = await readdir(absDir, {
+			withFileTypes: true,
+			encoding: "utf8"
+		});
+	} catch (error) {
+		throw codeOf(error);
+	}
+	const out = [];
+	const syms = [];
+	for (const d of dirents) if (d.isDirectory()) out.push({
+		name: d.name,
+		type: "directory"
+	});
+	else if (d.isFile()) out.push({
+		name: d.name,
+		type: "file"
+	});
+	else if (d.isSymbolicLink()) syms.push(d.name);
+	else out.push({
+		name: d.name,
+		type: "other"
+	});
+	if (syms.length) {
+		const symAbs = syms.map((name) => join(absDir, name));
+		const types = /* @__PURE__ */ new Map();
+		await statTypes(symAbs, types);
+		for (let i = 0; i < syms.length; i++) out.push({
+			name: syms[i],
+			type: types.get(symAbs[i]) ?? "other"
+		});
+	}
+	return out;
+}
+/** 落盘单目录条目上限：超出截断并标 full=false（截断仍可即时渲染，客户端后台刷新补全）。 */
+const PERSIST_DIR_ENTRIES = 1500;
+/** 落盘防抖：变更后静默 10s 再写一次。 */
+const PERSIST_DEBOUNCE_MS = 1e4;
+/** re-heal 防抖：写入密集期合并为 3s 后一轮。 */
+const HEAL_DEBOUNCE_MS = 3e3;
+/** cwd → 索引状态（随会话销毁清理）。 */
+const states = /* @__PURE__ */ new Map();
+/** 单调时钟：连续 put 的 ts 严格递增（同毫秒不并列，逐出/裁剪顺序可预期）。 */
+let clock = 0;
+/** 取下一时间戳（不小于真实时间且严格递增）。 */
+function nextTs() {
+	clock = Math.max(Date.now(), clock + 1);
+	return clock;
+}
+/** 条目原始值 → 合法条目（非法返回 null）。 */
+function entryOf(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const e = raw;
+	if (typeof e.name !== "string" || !e.name) return null;
+	const type = e.type === "directory" ? "directory" : e.type === "file" ? "file" : "other";
+	return {
+		name: e.name,
+		type
+	};
+}
+/** 写入路径 → 相对工作区根的 rel（绝对路径按 cwd 前缀裁剪；越界/非法 → null）。 */
+function relOf(cwd, path) {
+	let rel = String(path ?? "").trim().replace(/\\/g, "/");
+	const cl = cwd.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+	if (rel.toLowerCase().startsWith(cl + "/")) rel = rel.slice(cl.length + 1);
+	else if (rel.startsWith("/") || /^[a-z]:\//i.test(rel)) return null;
+	rel = rel.replace(/^\/+|\/+$/g, "");
+	if (!rel) return null;
+	const segs = rel.split("/").filter((s) => s !== "" && s !== ".");
+	if (!segs.length) return null;
+	for (const s of segs) if (s === "..") return null;
+	return segs.join("/");
+}
+/** rel 的父目录 + 全部祖先（'a/b/c' → ['a/b','a','']；'a' → ['']）。 */
+function ancestorsOf(rel) {
+	const segs = rel.split("/");
+	const out = [];
+	for (let i = segs.length - 1; i >= 1; i--) out.push(segs.slice(0, i).join("/"));
+	out.push("");
+	return out;
+}
+/** 序列化索引数据。 */
+function indexSerialize(data) {
+	const lean = {
+		v: 1,
+		root: data.root,
+		dirs: {}
+	};
+	for (const [rel, dir] of Object.entries(data.dirs)) lean.dirs[rel] = {
+		ts: dir.ts,
+		full: dir.full,
+		entries: dir.entries.map((e) => ({
+			name: e.name,
+			type: e.type
+		}))
+	};
+	return JSON.stringify(lean);
+}
+/** 解析索引文本；损坏/格式不符 → null。 */
+function indexParse(text) {
+	if (!text) return null;
+	try {
+		const raw = JSON.parse(text);
+		if (!raw || raw.v !== 1 || !raw.dirs || typeof raw.dirs !== "object") return null;
+		const dirs = {};
+		for (const [rel, d] of Object.entries(raw.dirs)) {
+			if (!d || typeof d !== "object") continue;
+			const dir = d;
+			if (!Array.isArray(dir.entries)) continue;
+			const entries = [];
+			for (const rawEntry of dir.entries) {
+				const e = entryOf(rawEntry);
+				if (!e) continue;
+				entries.push({
+					name: e.name,
+					path: rel ? rel + "/" + e.name : e.name,
+					type: e.type
+				});
+			}
+			if (!entries.length) continue;
+			dirs[rel] = {
+				ts: typeof dir.ts === "number" ? dir.ts : 0,
+				full: dir.full === true,
+				entries
+			};
+		}
+		return {
+			v: 1,
+			root: typeof raw.root === "string" ? raw.root : null,
+			dirs
+		};
+	} catch (error) {
+		return null;
+	}
+}
+/** 落盘裁剪：目录按 ts 取新裁旧、单目录超限截断标 full=false（内存不受影响）。 */
+function trimPersist(data, maxDirs = 400, maxEntries = PERSIST_DIR_ENTRIES) {
+	const dirs = {};
+	const sorted = Object.entries(data.dirs).sort((a, b) => b[1].ts - a[1].ts);
+	for (const [rel, dir] of sorted) {
+		if (Object.keys(dirs).length >= maxDirs) break;
+		const full = dir.entries.length <= maxEntries;
+		dirs[rel] = {
+			ts: dir.ts,
+			full,
+			entries: full ? dir.entries : dir.entries.slice(0, maxEntries)
+		};
+	}
+	return {
+		v: 1,
+		root: data.root,
+		dirs
+	};
+}
+/** 取（或建）某 cwd 的索引状态，并惰性加载落盘快照（合并：文件 ts 更新才采纳）。 */
+function ensureState(ctx, cwd) {
+	const existing = states.get(cwd);
+	if (existing) return existing;
+	const state = {
+		ctx,
+		cwd,
+		data: {
+			v: 1,
+			root: null,
+			dirs: {}
+		},
+		stale: /* @__PURE__ */ new Set(),
+		dirty: false,
+		persistTimer: null,
+		healTimer: null,
+		pending: /* @__PURE__ */ new Map(),
+		loading: false,
+		loadPromise: null
+	};
+	states.set(cwd, state);
+	state.loadPromise = loadIndex(state);
+	removeLegacyTreeSidecars(state.cwd);
+	return state;
+}
+/** 清理旧工作区树 sidecar（.dsh-edit-review-tree.json/.dsh-vscode-mode-tree.json）。 */
+async function removeLegacyTreeSidecars(cwd) {
+	await Promise.all(LEGACY_TREE_SIDECARS.map(async (name) => {
+		try {
+			await rm(join(cwd, name), { force: true });
+		} catch (error) {}
+	}));
+}
+/** 惰性加载落盘快照一次（缺失/损坏 → 空索引；失败静默）。 */
+async function loadIndex(state) {
+	if (state.loading) return;
+	state.loading = true;
+	try {
+		const parsed = indexParse(await readFile(treeCacheFile(state.cwd), "utf8"));
+		if (!parsed) return;
+		for (const [rel, dir] of Object.entries(parsed.dirs)) {
+			const cur = state.data.dirs[rel];
+			if (!cur || dir.ts > cur.ts) state.data.dirs[rel] = dir;
+		}
+		if (parsed.root && !state.data.root) state.data.root = parsed.root;
+	} catch (error) {} finally {
+		state.loading = false;
+	}
+}
+/** 命中：新鲜且未失效 → 条目（并刷新 ts 保活）；否则 null。 */
+function hitIndex(cwd, rel) {
+	const state = states.get(cwd);
+	if (!state) return null;
+	const dir = state.data.dirs[rel];
+	if (!dir || state.stale.has(rel)) return null;
+	const now = Date.now();
+	if (now - dir.ts > 6e4) return null;
+	dir.ts = now;
+	return dir.entries;
+}
+/** 更新某目录条目：写内存 + 打脏 + 防抖落盘；stale 撤销。 */
+function putIndex(ctx, cwd, rel, entries) {
+	const state = ensureState(ctx, cwd);
+	const dirs = state.data.dirs;
+	if (!dirs[rel] && Object.keys(dirs).length >= 2e3) {
+		let oldest = rel;
+		let oldestTs = Infinity;
+		for (const [k, v] of Object.entries(dirs)) if (v.ts < oldestTs) {
+			oldestTs = v.ts;
+			oldest = k;
+		}
+		delete dirs[oldest];
+	}
+	dirs[rel] = {
+		ts: nextTs(),
+		full: entries.length <= PERSIST_DIR_ENTRIES,
+		entries
+	};
+	state.stale.delete(rel);
+	state.dirty = true;
+	schedulePersist(state);
+}
+/** 写入路径失效：父目录+祖先进 stale，并调度后台 re-heal。 */
+function invalidateIndex(ctx, cwd, path) {
+	const rel = relOf(cwd, path);
+	if (rel === null) return;
+	const state = ensureState(ctx, cwd);
+	for (const anc of ancestorsOf(rel)) state.stale.add(anc);
+	scheduleHeal(state);
+}
+/** 调度 re-heal（防抖合并；已有定时器则复用）。 */
+function scheduleHeal(state) {
+	if (state.healTimer) return;
+	state.healTimer = setTimeout(() => {
+		state.healTimer = null;
+		healRound(state);
+	}, HEAL_DEBOUNCE_MS);
+}
+/** 后台自愈一轮：并行重列 ≤HEAL_ROUND_MAX 个 stale 目录；失败移出（交给 TTL/展开路径自愈）。 */
+async function healRound(state) {
+	if (!state.stale.size) return;
+	const targets = [...state.stale].slice(0, 20);
+	await Promise.all(targets.map(async (rel) => {
+		if ("error" in await listDirCached(state.ctx, state.cwd, rel, true)) state.stale.delete(rel);
+	}));
+	if (state.stale.size) scheduleHeal(state);
+}
+/** 调度落盘（防抖；已有定时器则重置）。 */
+function schedulePersist(state) {
+	if (state.persistTimer) clearTimeout(state.persistTimer);
+	state.persistTimer = setTimeout(() => {
+		state.persistTimer = null;
+		persistNow(state);
+	}, PERSIST_DEBOUNCE_MS);
+}
+/** 落盘快照（裁剪 + 序列化 + 超限跳过；raw fs 写 ~/.dsh 缓存根，失败静默）。 */
+async function persistNow(state) {
+	if (!state.dirty) return;
+	try {
+		const json = indexSerialize(trimPersist(state.data));
+		if (json.length > 8388608) {
+			state.dirty = false;
+			return;
+		}
+		await mkdir(dirname(treeCacheFile(state.cwd)), { recursive: true });
+		await writeFile(treeCacheFile(state.cwd), json, "utf8");
+		state.dirty = false;
+	} catch (error) {}
+}
+/** 清理某 cwd 索引（会话销毁时）：清定时器，dirty 则尽力补写一次。 */
+function disposeIndex(cwd) {
+	const state = states.get(cwd);
+	if (!state) return;
+	if (state.persistTimer) {
+		clearTimeout(state.persistTimer);
+		state.persistTimer = null;
+	}
+	if (state.healTimer) {
+		clearTimeout(state.healTimer);
+		state.healTimer = null;
+	}
+	if (state.dirty) persistNow(state);
+	states.delete(cwd);
+}
+/** 错误 → 用户文案（DirListError 用自身 message，其余带上下文）。 */
+function errorText(error) {
+	if (error instanceof DirListError) return error.message;
+	return "读取目录失败：" + String(error);
+}
+/**
+* 目录列取统一入口（RPC handler 用）：命中索引直出；失效/force 走快路径
+* （resolve + listDirCheap + putIndex）；同 (cwd,rel) 在途请求复用同一 Promise。
+* @author ddj 2026年08月31号 / 2026年09月01号
+* @param ctx DSH 上下文（仅用于工作区 IO）
+* @param cwd 工作区根
+* @param rel 归一化相对路径（'' = 根）
+* @param force 跳过索引命中，强制实列
+* @returns 目录条目与工作区根，或错误文案
+*/
+async function listDirCached(ctx, cwd, rel, force) {
+	const state = ensureState(ctx, cwd);
+	if (state.loadPromise) await state.loadPromise;
+	const fs = ctx.get("fs");
+	if (!fs) return { error: "缺少 fs" };
+	if (!state.data.root) try {
+		state.data.root = String(fs.processPath(await fs.resolve(".", { cwd })));
+	} catch (error) {
+		return { error: errorText(error) };
+	}
+	const root = state.data.root;
+	if (!force) {
+		const hit = hitIndex(cwd, rel);
+		if (hit) return {
+			entries: hit,
+			root
+		};
+	}
+	const inflight = state.pending.get(rel);
+	if (inflight) {
+		const res = await inflight;
+		return "entries" in res ? {
+			entries: res.entries,
+			root
+		} : res;
+	}
+	const task = (async () => {
+		try {
+			const entries = toTreeEntries(rel, await listDirCheap((await fs.resolve(rel || ".", { cwd })).targetKey));
+			putIndex(ctx, cwd, rel, entries);
+			return { entries };
+		} catch (error) {
+			if (error instanceof DirListError && error.code === "not-found") {
+				if (state.data.dirs[rel]) {
+					delete state.data.dirs[rel];
+					state.dirty = true;
+					schedulePersist(state);
+				}
+				state.stale.delete(rel);
+			}
+			return { error: errorText(error) };
+		}
+	})();
+	state.pending.set(rel, task);
+	try {
+		const res = await task;
+		return "entries" in res ? {
+			entries: res.entries,
+			root
+		} : res;
+	} finally {
+		if (state.pending.get(rel) === task) state.pending.delete(rel);
+	}
+}
+//#endregion
 //#region src/capture.ts
 /** 校验并提取工具 result meta 中的文件 hunk。 */
 function validHunks(raw) {
@@ -1432,6 +2122,7 @@ async function captureToolResult(ctx, registry, exec, result) {
 		bucket.set(exec.callId, record);
 		prune(bucket);
 		await saveBucket(ctx, cwd, bucket, session);
+		invalidateIndex(ctx, cwd, path);
 	} catch (error) {
 		console.error("edrv capture failed", error);
 	}
@@ -1579,6 +2270,65 @@ function parseOutput(handle, maxResults) {
 	};
 }
 /**
+* 读取已收集的 stderr（无收集器 → 空文本）。
+* @author ddj 2026年08月27号
+* @param handle subprocess handle
+* @returns stderr 文本
+*/
+function readStderr(handle) {
+	const reader = handle.collected?.stderr;
+	return reader ? reader.readFrom(0) : { text: "" };
+}
+/**
+* 取 stderr 首条非空行（去 \r，截断 300 字符防撑爆 UI）。
+* @author ddj 2026年08月27号
+* @param text stderr 全文
+* @returns 首条诊断行（无则空串）
+*/
+function firstStderrLine(text) {
+	for (const raw of String(text ?? "").split(/\r?\n/)) {
+		const line = raw.trim();
+		if (!line) continue;
+		return line.length > 300 ? line.slice(0, 300) + "…" : line;
+	}
+	return "";
+}
+/**
+* 分类 rg 非 0/1 退出：pattern=模式错误（正则/glob 无效，无结果），
+* partial=遍历错误（rg 已输出的命中仍有效，结果不完整），hard=硬失败（其他退出码/超时被杀）。
+* @author ddj 2026年08月27号
+* @param code 退出码（null/undefined = 被终止，通常为 20s 超时）
+* @param stderrText stderr 全文
+* @returns 分类与中文提示文案（partial 的 message 即 warning 内容）
+*/
+function rgExitFailure(code, stderrText) {
+	const detail = firstStderrLine(stderrText);
+	if (/regex parse error/i.test(detail)) return {
+		kind: "pattern",
+		message: "正则表达式无效：" + detail
+	};
+	if (/error parsing glob/i.test(detail)) return {
+		kind: "pattern",
+		message: "文件过滤模式无效：" + detail
+	};
+	if (code === 2) {
+		const count = String(stderrText ?? "").split(/\r?\n/).filter((line) => line.trim()).length;
+		const suffix = count > 1 ? "（共 " + count + " 处）" : "";
+		return {
+			kind: "partial",
+			message: detail ? "部分路径无法访问，结果可能不完整：" + detail + suffix : "部分路径无法访问，结果可能不完整"
+		};
+	}
+	if (code === null || code === void 0) return {
+		kind: "hard",
+		message: "搜索超时（20 秒内未完成，已终止）"
+	};
+	return {
+		kind: "hard",
+		message: "ripgrep 退出码：" + String(code) + (detail ? "（" + detail + "）" : "")
+	};
+}
+/**
 * 使用打包 ripgrep 搜索工作区文件。
 * @author ddj 2026年08月24号
 * @param input provider 输入
@@ -1621,7 +2371,16 @@ async function searchRipgrep(input) {
 		throw new Error("ripgrep 启动失败：" + String(error));
 	}
 	const code = outcome.exitCode ?? outcome.code;
-	if (code !== 0 && code !== 1) throw new Error("ripgrep 退出码：" + String(code));
+	if (code !== 0 && code !== 1) {
+		const failure = rgExitFailure(code, readStderr(handle).text);
+		if (failure.kind !== "partial") throw new Error(failure.message);
+		return {
+			...parseOutput(handle, input.maxResults),
+			warning: failure.message,
+			complete: false,
+			source: "ripgrep"
+		};
+	}
 	const parsed = parseOutput(handle, input.maxResults);
 	if (!handle.collected?.stdout) throw new Error("ripgrep stdout 不可用");
 	return {
@@ -2239,17 +2998,23 @@ async function searchRipgrepContent(input) {
 		throw new Error("ripgrep 启动失败：" + String(error));
 	}
 	const code = outcome.exitCode ?? outcome.code;
-	if (code !== 0 && code !== 1) throw new Error("ripgrep 退出码：" + String(code));
+	const failure = code !== 0 && code !== 1 ? rgExitFailure(code, readStderr(handle).text) : null;
+	if (failure && failure.kind !== "partial") throw new Error(failure.message);
 	const reader = handle.collected?.stdout;
 	if (!reader) throw new Error("ripgrep stdout 不可用");
 	const output = reader.readFrom(0);
 	const capped = applyCaps(parseRgJsonLines(output.text, root), Math.max(1, Math.min(input.maxResults ?? DEFAULT_MAX_MATCHES, DEFAULT_MAX_MATCHES)), DEFAULT_MAX_FILES);
 	const truncated = Boolean(output.lossy) || capped.truncated;
-	return {
+	const result = {
 		...capped,
 		complete: !truncated,
 		source: "ripgrep"
 	};
+	if (failure) {
+		result.complete = false;
+		result.warning = failure.message;
+	}
+	return result;
 }
 /**
 * 内容搜索编排器：短期缓存 + 同根在途取消 + 会话清理。
@@ -2314,7 +3079,8 @@ var ContentSearcher = class {
 		const cached = this.cache.get(key);
 		if (cached) return {
 			matches: cached.matches,
-			truncated: cached.truncated
+			truncated: cached.truncated,
+			warning: cached.warning
 		};
 		this.inflight.get(root)?.abort();
 		const controller = new AbortController();
@@ -2341,7 +3107,8 @@ var ContentSearcher = class {
 			this.cache.set(key, result);
 			return {
 				matches: result.matches,
-				truncated: result.truncated
+				truncated: result.truncated,
+				warning: result.warning
 			};
 		} catch (error) {
 			if (controller.signal.aborted) return {
@@ -2813,53 +3580,7 @@ async function projectRefresh(ctx, workspacePath, serverName) {
 	return projectOf(ctx, workspacePath, workspace.title ?? "");
 }
 //#endregion
-//#region src/tree.ts
-/** 目录在文件前、名称按小写字母序的比较器（对齐 VSCode 资源管理器习惯）。 */
-function entryOrder(a, b) {
-	const aDir = a.type === "directory" ? 0 : 1;
-	const bDir = b.type === "directory" ? 0 : 1;
-	if (aDir !== bDir) return aDir - bDir;
-	const la = a.name.toLocaleLowerCase("en-US");
-	const lb = b.name.toLocaleLowerCase("en-US");
-	return la < lb ? -1 : la > lb ? 1 : 0;
-}
-/**
-* 归一化目录相对路径：去空白、反斜杠→斜杠、去首尾斜杠、`.`→''。
-* 任一路径段为 `..` 返回 null（拒绝越界）。
-* @author ddj 2026年08月26号
-* @param path 原始相对路径（'' 表示根目录）
-* @returns 归一化相对路径（'' = 根），非法返回 null
-*/
-function normalizeRel(path) {
-	const rel = String(path ?? "").trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-	if (!rel) return "";
-	const segs = rel.split("/").filter((seg) => seg !== ".");
-	if (!segs.length) return "";
-	for (const seg of segs) if (seg === "..") return null;
-	return segs.join("/");
-}
-/**
-* fs.listDir 结果 → TreeEntry 数组：相对路径拼接 + 目录优先排序。
-* @author ddj 2026年08月26号
-* @param rel 父目录相对路径（'' = 根）
-* @param children 目录子项
-* @returns 排序后的树条目
-*/
-function toTreeEntries(rel, children) {
-	const out = [];
-	for (const child of children) {
-		if (!child || typeof child.name !== "string" || !child.name) continue;
-		out.push({
-			name: child.name,
-			path: rel ? rel + "/" + child.name : child.name,
-			type: child.type === "directory" ? "directory" : child.type === "file" ? "file" : "other",
-			size: typeof child.size === "number" ? child.size : void 0
-		});
-	}
-	return out.sort(entryOrder);
-}
-//#endregion
-//#region src/reveal.ts
+//#region src/reveal.ts
 /**
 * dsh-vscode-mode host — 在 OS 文件浏览器中打开/定位路径（reveal 能力）。
 * 纯函数 revealCommand 平台分发 + revealInExplorer 经 ctx.subprocess.spawn 发射
@@ -2926,6 +3647,462 @@ async function revealInExplorer(ctx, absPath, isDir) {
 	}
 }
 //#endregion
+//#region src/perf.ts
+/**
+* dsh-vscode-mode host — DSH 会话性能管理（会话卫生 + 体积 stat + 侧车摘要）。
+* 职责：
+* - 盘点 ~/.dsh/sessions 全部工作区会话（每会话仅 stat 日志文件，不解压，轻量）；
+* - 移出/恢复/清除：会话目录在 ~/.dsh/sessions 与 ~/.dsh/sessions-archive 间可逆搬迁；
+* - 当前会话体积 stat（对话头部指示器用，纯 stat）；
+* - 侧车摘要：agent/脚本取关键字段，避免整份读 .dsh-edit-review.json 进对话。
+* 纯函数可单测（路径编码/移出规划）；fs 操作 best-effort 返回逐项结果不抛。
+* 作者 ddj 2026-09-02
+*/
+/** 会话日志文件名（zstd 优先，降级纯 jsonl）。 */
+const LOG_NAMES = ["session.jsonl.zstd", "session.jsonl"];
+/** 归档根（~/.dsh/sessions-archive，与 sessions 同级，可逆移出的落点）。 */
+function sessionsArchiveRoot(home = dshHome()) {
+	return join(home, "sessions-archive");
+}
+/** 路径段校验：非空、非 . / ..、不含分隔符与 Windows 非法字符（防 join 逃逸）。 */
+function validDirName(name) {
+	return typeof name === "string" && name.length > 0 && name !== "." && name !== ".." && !/[/\\]/.test(name) && !/[:*?"<>|]/.test(name);
+}
+/** target 必须落在 root 内（自身或其子路径），防路径穿越。 */
+function withinDir(target, root) {
+	const rel = resolve(target);
+	const base = resolve(root);
+	return rel === base || rel.startsWith(base + sep);
+}
+/** stat 一个会话目录里的日志文件（首个存在的），缺失 → null。 */
+async function statSessionLog(sessionDir) {
+	for (const name of LOG_NAMES) try {
+		const info = await stat(join(sessionDir, name));
+		if (info.isFile()) return {
+			size: info.size,
+			mtimeMs: info.mtimeMs
+		};
+	} catch (error) {}
+	return null;
+}
+/**
+* 盘点 ~/.dsh/sessions：按工作区分组，每会话仅 stat 日志文件体积与 mtime。
+* 不解压日志（V8 展开成本高），活跃标记由调用方传入后置。
+* @author ddj 2026年09月02号
+* @param home DSH home（测试可注入）
+* @param archive 归档根（默认 sessions-archive；测试可注入）
+* @returns 工作区聚合（按体积降序）+ 会话明细（按体积降序）+ 汇总
+*/
+async function scanSessionInventory(home = dshHome(), archive = sessionsArchiveRoot(home)) {
+	const root = sessionsRoot(home);
+	const workspaces = [];
+	const sessions = [];
+	let totalBytes = 0;
+	let totalCount = 0;
+	const wsDirs = await readdir(root, { withFileTypes: true }).catch(() => []);
+	for (const ws of wsDirs) {
+		if (!ws.isDirectory() || !validDirName(ws.name)) continue;
+		const wsDir = join(root, ws.name);
+		const wsSessions = [];
+		let wsBytes = 0;
+		let minMtime = Number.POSITIVE_INFINITY;
+		let maxMtime = 0;
+		const sessionDirs = await readdir(wsDir, { withFileTypes: true }).catch(() => []);
+		for (const sd of sessionDirs) {
+			if (!sd.isDirectory()) continue;
+			const info = await statSessionLog(join(wsDir, sd.name));
+			if (!info) continue;
+			const row = {
+				sessionId: sd.name,
+				workspaceKey: ws.name,
+				bytes: info.size,
+				mtime: info.mtimeMs,
+				active: false
+			};
+			wsSessions.push(row);
+			wsBytes += info.size;
+			totalBytes += info.size;
+			totalCount += 1;
+			if (info.mtimeMs < minMtime) minMtime = info.mtimeMs;
+			if (info.mtimeMs > maxMtime) maxMtime = info.mtimeMs;
+		}
+		wsSessions.sort((a, b) => b.bytes - a.bytes);
+		sessions.push(...wsSessions);
+		workspaces.push({
+			workspaceKey: ws.name,
+			sessionCount: wsSessions.length,
+			totalBytes: wsBytes,
+			minMtime: Number.isFinite(minMtime) ? minMtime : 0,
+			maxMtime
+		});
+	}
+	workspaces.sort((a, b) => b.totalBytes - a.totalBytes);
+	return {
+		workspaces,
+		sessions,
+		totals: {
+			workspaces: workspaces.length,
+			sessions: totalCount,
+			totalBytes
+		}
+	};
+}
+/** 标记活跃会话（live id 与目录段名双向匹配，兼容编码差异）。 */
+function markActiveSessions(sessions, activeIds) {
+	const raw = new Set(activeIds);
+	const encoded = /* @__PURE__ */ new Set();
+	for (const id of raw) encoded.add(sessionIdSegment(id));
+	for (const s of sessions) if (raw.has(s.sessionId) || encoded.has(s.sessionId)) s.active = true;
+}
+/**
+* 移出规划（纯函数）：从盘点中按「显式集合」或「规则（minBytes / olderThanDays）」
+* 圈选可移出会话。活跃会话一律排除；无显式集合且无规则时不选（防误移）。
+* @author ddj 2026年09月02号
+* @param inventory 盘点结果
+* @param criteria 圈选条件
+* @returns 待移出清单与释放字节
+*/
+function planMoveOut(inventory, criteria) {
+	const items = [];
+	const explicit = Array.isArray(criteria.sessionIds) && criteria.sessionIds.length > 0;
+	const cutoff = criteria.olderThanDays ? Date.now() - criteria.olderThanDays * 24 * 60 * 60 * 1e3 : 0;
+	for (const s of inventory.sessions) {
+		if (s.active) continue;
+		if (criteria.workspaceKey && s.workspaceKey !== criteria.workspaceKey) continue;
+		if (explicit) {
+			if (!criteria.sessionIds.includes(s.sessionId)) continue;
+		} else {
+			if (criteria.minBytes && s.bytes < criteria.minBytes) continue;
+			if (criteria.olderThanDays && s.mtime > cutoff) continue;
+			if (!criteria.minBytes && !criteria.olderThanDays) continue;
+		}
+		items.push({
+			workspaceKey: s.workspaceKey,
+			sessionId: s.sessionId,
+			bytes: s.bytes
+		});
+	}
+	return {
+		items,
+		reclaimedBytes: items.reduce((sum, i) => sum + i.bytes, 0)
+	};
+}
+/**
+* 移出会话目录到归档区（同卷 rename，可逆）。活跃会话拒绝；路径越界拒绝；
+* 逐项 best-effort，成功项写归档 manifest。默认不 dry-run（dryRun 时只校验不搬迁）。
+* @author ddj 2026年09月02号
+* @param home DSH home
+* @param archive 归档根
+* @param items 待移出清单（来自 planMoveOut 或用户确认）
+* @param activeIds 活跃会话 id 集合（执行期再校验一次）
+* @param dryRun 仅校验不搬迁
+*/
+async function moveOutSessions(home, archive, items, activeIds, dryRun = false) {
+	const root = sessionsRoot(home);
+	const rawActive = new Set(activeIds);
+	const encodedActive = /* @__PURE__ */ new Set();
+	for (const id of rawActive) encodedActive.add(sessionIdSegment(id));
+	const isActive = (id) => rawActive.has(id) || encodedActive.has(id);
+	const moved = [];
+	const failures = [];
+	for (const item of items) {
+		if (!validDirName(item.workspaceKey)) {
+			failures.push({
+				workspaceKey: item.workspaceKey,
+				sessionId: item.sessionId,
+				error: "工作区键不合法"
+			});
+			continue;
+		}
+		if (isActive(item.sessionId)) {
+			failures.push({
+				workspaceKey: item.workspaceKey,
+				sessionId: item.sessionId,
+				error: "活跃会话，拒绝移出"
+			});
+			continue;
+		}
+		const seg = sessionIdSegment(item.sessionId);
+		const src = join(root, item.workspaceKey, seg);
+		const dst = join(archive, item.workspaceKey, seg);
+		if (!withinDir(src, root) || !withinDir(dst, archive)) {
+			failures.push({
+				workspaceKey: item.workspaceKey,
+				sessionId: item.sessionId,
+				error: "路径越界，拒绝执行"
+			});
+			continue;
+		}
+		if (dryRun) {
+			try {
+				if ((await stat(src)).isDirectory()) moved.push({
+					...item,
+					bytes: (await statSessionLog(src))?.size ?? item.bytes
+				});
+				else failures.push({
+					workspaceKey: item.workspaceKey,
+					sessionId: item.sessionId,
+					error: "源目录不存在"
+				});
+			} catch (error) {
+				failures.push({
+					workspaceKey: item.workspaceKey,
+					sessionId: item.sessionId,
+					error: "源目录不存在"
+				});
+			}
+			continue;
+		}
+		try {
+			await mkdir(dirname(dst), { recursive: true });
+			await rename(src, dst);
+			const bytes = (await statSessionLog(dst))?.size ?? item.bytes;
+			moved.push({
+				...item,
+				bytes
+			});
+		} catch (error) {
+			failures.push({
+				workspaceKey: item.workspaceKey,
+				sessionId: item.sessionId,
+				error: String(error)
+			});
+		}
+	}
+	if (moved.length && !dryRun) await appendMoveManifest(archive, moved);
+	return {
+		moved,
+		failures,
+		reclaimedBytes: moved.reduce((sum, i) => sum + i.bytes, 0)
+	};
+}
+/** 恢复单个会话：归档 → sessions。目标已存在则拒绝（不覆盖）。 */
+async function restoreSession(home, archive, workspaceKey, sessionId) {
+	if (!validDirName(workspaceKey)) return {
+		ok: false,
+		error: "工作区键不合法"
+	};
+	const seg = sessionIdSegment(sessionId);
+	const root = sessionsRoot(home);
+	const src = join(archive, workspaceKey, seg);
+	const dst = join(root, workspaceKey, seg);
+	if (!withinDir(src, archive) || !withinDir(dst, root)) return {
+		ok: false,
+		error: "路径越界，拒绝执行"
+	};
+	try {
+		await stat(src);
+	} catch (error) {
+		return {
+			ok: false,
+			error: "归档中不存在该会话"
+		};
+	}
+	try {
+		await stat(dst);
+		return {
+			ok: false,
+			error: "目标位置已存在同名会话"
+		};
+	} catch (error) {}
+	try {
+		await mkdir(dirname(dst), { recursive: true });
+		await rename(src, dst);
+		return { ok: true };
+	} catch (error) {
+		return {
+			ok: false,
+			error: String(error)
+		};
+	}
+}
+/** 清除归档区早于 N 天的会话（破坏性，仅限归档区）。 */
+async function purgeArchive(archive, olderThanDays) {
+	const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1e3;
+	let removed = 0;
+	let reclaimedBytes = 0;
+	const wsDirs = await readdir(archive, { withFileTypes: true }).catch(() => []);
+	for (const ws of wsDirs) {
+		if (!ws.isDirectory()) continue;
+		const wsDir = join(archive, ws.name);
+		const sessionDirs = await readdir(wsDir, { withFileTypes: true }).catch(() => []);
+		for (const sd of sessionDirs) {
+			if (!sd.isDirectory()) continue;
+			const info = await statSessionLog(join(wsDir, sd.name));
+			if (!info || info.mtimeMs > cutoff) continue;
+			try {
+				await rm(join(wsDir, sd.name), {
+					recursive: true,
+					force: true
+				});
+				removed += 1;
+				reclaimedBytes += info.size;
+			} catch (error) {}
+		}
+	}
+	return {
+		removed,
+		reclaimedBytes
+	};
+}
+/** 当前会话持久化体积（对话头部指示器用）：仅 stat，近零成本。 */
+async function sessionSizeOf(home, cwd, sessionId) {
+	const dir = join(sessionsRoot(home), sessionWorkspaceKey(cwd), sessionIdSegment(sessionId));
+	for (const name of LOG_NAMES) try {
+		const info = await stat(join(dir, name));
+		if (info.isFile()) return {
+			bytes: info.size,
+			exists: true
+		};
+	} catch (error) {}
+	return {
+		bytes: 0,
+		exists: false
+	};
+}
+/**
+* 侧车摘要：返回活跃记录数、每文件 pending 计数、归档体积。
+* agent/脚本取关键字段即可，不必整份读 .dsh-edit-review.json（避免大对象进对话）。
+* @author ddj 2026年09月02号
+* @param ctx DSH host 上下文（fs 服务）
+* @param cwd 工作区路径（null 时返回空摘要）
+*/
+async function sidecarSummaryOf(ctx, cwd) {
+	const fs = ctx.get("fs");
+	const summary = {
+		active: 0,
+		pendingByFile: [],
+		archiveBytes: 0
+	};
+	if (!fs || !cwd) return summary;
+	try {
+		const recs = parseSidecar(await fs.readText(await fs.resolve(SIDECAR, { cwd })))?.workspaces?.[cwd]?.records;
+		if (recs) {
+			const byFile = /* @__PURE__ */ new Map();
+			let active = 0;
+			for (const rec of Object.values(recs)) {
+				if (rec.archived) continue;
+				active += 1;
+				const sm = recSummary(rec);
+				if (sm.pending > 0 && rec.path) byFile.set(rec.path, (byFile.get(rec.path) ?? 0) + sm.pending);
+			}
+			summary.active = active;
+			summary.pendingByFile = [...byFile.entries()].map(([path, pending]) => ({
+				path,
+				pending
+			})).sort((a, b) => b.pending - a.pending);
+		}
+		try {
+			summary.archiveBytes = (await fs.stat(await fs.resolve(".dsh-edit-review-archive.json", { cwd })))?.size ?? 0;
+		} catch (error) {}
+	} catch (error) {}
+	return summary;
+}
+/** 解析归档 manifest（损坏/缺失 → 空）。 */
+function parseMoveManifest(text) {
+	if (!text) return {
+		version: 1,
+		items: []
+	};
+	try {
+		const data = JSON.parse(text);
+		return {
+			version: 1,
+			items: Array.isArray(data.items) ? data.items : []
+		};
+	} catch (error) {
+		return {
+			version: 1,
+			items: []
+		};
+	}
+}
+/** 追加移出记录到归档 manifest（best-effort，失败不影响主流程）。 */
+async function appendMoveManifest(archive, items) {
+	try {
+		const file = join(archive, ".manifest.json");
+		const prev = parseMoveManifest(await readFile(file, "utf8").catch(() => null));
+		const at = (/* @__PURE__ */ new Date()).toISOString();
+		for (const item of items) prev.items.push({
+			at,
+			workspaceKey: item.workspaceKey,
+			sessionId: item.sessionId
+		});
+		await mkdir(archive, { recursive: true });
+		await writeFile(file, JSON.stringify(prev, null, 2), "utf8");
+	} catch (error) {}
+}
+//#endregion
+//#region src/perfPatch.ts
+/**
+* dsh-vscode-mode host — profile patch 压缩调优（文本行级，零 YAML 依赖）。
+* 在 ~/.dsh/profiles/<profile>/cordis.patch.yml 末尾追加/移除一段带标记注释的
+* id 定向覆盖块（compaction-basic / tool-result-pruner 更低阈值）。
+* 纯文本函数可单测：幂等追加、整段移除、无块原样返回。
+* 作者 ddj 2026-09-02
+*/
+/** 性能块起始标记注释（文件内唯一锚点）。 */
+const PERF_MARK_START = "# dsh-vscode-mode perf tuning (start)";
+/** 性能块结束标记注释。 */
+const PERF_MARK_END = "# dsh-vscode-mode perf tuning (end)";
+/**
+* 建议的压缩调优 YAML 块（顶层 loader patch 条目，id 定向覆盖）。
+* - compaction-basic：thresholdRatio 0.8→0.6、retainRatio 0.16→0.12（更早触发压缩）；
+* - tool-result-pruner：thresholdChars 8192→4096、head/tail 同步收窄（大 tool result 提前截断）。
+* 注意：压缩只降低模型可见上下文压力，不重写已持久化会话日志（append-only）。
+* @author ddj 2026年09月02号
+* @returns 带前后标记注释与尾换行的 YAML 块
+*/
+function perfConfigBlock() {
+	return [
+		PERF_MARK_START,
+		"# 更早触发会话内压缩：降低模型可见上下文压力（仅影响后续轮次，不缩小已持久化日志）。",
+		"- id: compaction-basic",
+		"  config:",
+		"    thresholdRatio: 0.6",
+		"    retainRatio: 0.12",
+		"- id: tool-result-pruner",
+		"  config:",
+		"    thresholdChars: 4096",
+		"    headChars: 2048",
+		"    tailChars: 512",
+		PERF_MARK_END,
+		""
+	].join("\n");
+}
+/** 当前文本是否已包含性能块。 */
+function patchHasPerfConfig(text) {
+	return text.includes(PERF_MARK_START);
+}
+/**
+* 移除性能块（起止标记注释之间的整段，含所在行），无块时原样返回。
+* 移除后压缩多余空行、确保以单个换行结尾。
+* @author ddj 2026年09月02号
+* @param text 原 patch 文本
+* @returns 移除后的文本
+*/
+function patchRemovePerfConfig(text) {
+	const start = text.indexOf(PERF_MARK_START);
+	if (start === -1) return text;
+	const end = text.indexOf(PERF_MARK_END, start);
+	const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+	if (end === -1) return text.slice(0, lineStart).replace(/\n+$/, "\n");
+	const after = (() => {
+		const nl = text.indexOf("\n", end);
+		return nl === -1 ? text.length : nl + 1;
+	})();
+	return (text.slice(0, lineStart) + text.slice(after)).replace(/\n{3,}/g, "\n\n").replace(/\n+$/, "\n");
+}
+/**
+* 幂等追加性能块：已有块先整段移除再追加到文件末尾（保证全文件只有一份、位置固定）。
+* @author ddj 2026年09月02号
+* @param text 原 patch 文本
+* @returns 追加后的文本
+*/
+function patchInsertPerfConfig(text) {
+	return patchRemovePerfConfig(text).replace(/\n+$/, "") + "\n" + perfConfigBlock();
+}
+//#endregion
 //#region src/rpc.ts
 /** cwd → 内存缓冲：行数组 + 累计字节数 + 待触发 flush 定时器（攒批落盘，避免每条日志全文件读改写）。 */
 const debugBuffers = /* @__PURE__ */ new Map();
@@ -2944,13 +4121,12 @@ const STALE_CHECK_MIN_MS = 1e4;
 /**
 * 调试日志入队：先攒内存缓冲（行 + 字节数），满 DEBUG_BUF_CAP 立即落盘，
 * 否则空闲 DEBUG_FLUSH_IDLE_MS 后落盘；落盘 = 读旧文件 + 追加整批 + 超限截断 + 一次写入。
-* @author ddj 2026年08月26号
+* @author ddj 2026年08月26号 / 2026年09月01号
 * @param ctx DSH 上下文
-* @param cwd 工作区（日志文件按工作区旁车存放）
-* @param policy 会话沙箱策略（入队时刻捕获）
+* @param cwd 工作区（日志按 cwd hash 存 ~/.dsh/dsh-vscode-mode/logs/）
 * @param line 单条日志文本（不含换行）
 */
-function enqueueDebug(ctx, cwd, policy, line) {
+function enqueueDebug(ctx, cwd, line) {
 	const st = debugBuffers.get(cwd) ?? {
 		lines: [],
 		len: 0,
@@ -2963,7 +4139,7 @@ function enqueueDebug(ctx, cwd, policy, line) {
 		const batch = st.lines;
 		st.lines = [];
 		st.len = 0;
-		flushDebug(ctx, cwd, policy, batch);
+		flushDebug(cwd, batch);
 	};
 	if (st.len >= DEBUG_BUF_CAP) {
 		if (st.timer) clearTimeout(st.timer);
@@ -2971,24 +4147,27 @@ function enqueueDebug(ctx, cwd, policy, line) {
 	} else if (!st.timer) st.timer = setTimeout(flush, DEBUG_FLUSH_IDLE_MS);
 	debugBuffers.set(cwd, st);
 }
+/** cwd → 已清理旧工作区 debug 日志标记（一次性）。 */
+const debugLegacyCleaned = /* @__PURE__ */ new Set();
 /**
 * 批量落盘一条 debug 日志缓冲：读旧文件 → 追加 → 超上限截断保留尾部 → 一次写回。
 * 串行链保证同一 cwd 的读改写不交错丢行；写失败静默忽略（调试日志不阻塞业务）。
-* @author ddj 2026年08月26号
-* @param ctx DSH 上下文
-* @param cwd 工作区
-* @param policy 会话沙箱策略（enqueue 时刻捕获）
+* @author ddj 2026年08月26号 / 2026年09月01号
+* @param cwd 工作区（日志落 ~/.dsh/dsh-vscode-mode/logs/debug.<cwdHash>.log）
 * @param batch 本批日志行
 */
-function flushDebug(ctx, cwd, policy, batch) {
+function flushDebug(cwd, batch) {
 	const task = (debugWriteQueues.get(cwd) ?? Promise.resolve()).then(async () => {
 		try {
-			const fs = ctx.get("fs");
-			if (!fs) return;
-			const target = await fs.resolve(".dsh-edit-review-debug.log", { cwd });
-			const appended = await fs.readText(target).catch(() => "") + batch.map((l) => (/* @__PURE__ */ new Date()).toISOString() + " " + l + "\n").join("");
+			await mkdir(pluginLogRoot(), { recursive: true });
+			const target = debugLogFile(cwd);
+			const appended = await readFile(target, "utf8").catch(() => "") + batch.map((l) => (/* @__PURE__ */ new Date()).toISOString() + " " + l + "\n").join("");
 			const next = appended.length > DEBUG_LOG_CAP ? appended.slice(-Math.floor(DEBUG_LOG_CAP / 2)) : appended;
-			await fs.writeText(target, next, void 0, void 0, policy);
+			await writeFile(target, next, "utf8");
+			if (!debugLegacyCleaned.has(cwd)) {
+				debugLegacyCleaned.add(cwd);
+				await rm(join(cwd, DEBUG_LOG), { force: true }).catch(() => {});
+			}
 		} catch (e) {}
 	});
 	debugWriteQueues.set(cwd, task);
@@ -3073,6 +4252,27 @@ async function applyDecisions(ctx, session, cwd, bucket, items) {
 	if (changed) await saveBucket(ctx, cwd, bucket, session);
 	return results;
 }
+/** 当前活跃会话 id 集合（live sessions，用于移出/恢复护栏）。 */
+function activeSessionIds(ctx) {
+	const sessions = ctx.get("sessions");
+	if (!sessions || typeof sessions.list !== "function") return /* @__PURE__ */ new Set();
+	return new Set(sessions.list().map((s) => s.id).filter(Boolean));
+}
+/** profile patch 文件定位（依赖本插件的 profile，同 devForm）。 */
+async function patchFileInfo() {
+	const profileDir = findProfileDir();
+	if (!profileDir) return {};
+	return {
+		profileDir,
+		patchPath: join(profileDir, "cordis.patch.yml")
+	};
+}
+/** 最新一次压缩配置备份文件名（cordis.patch.yml.bak-<ts>，按名倒序取新）。 */
+async function latestPatchBackup(patchPath) {
+	const dir = join(patchPath, "..");
+	const base = basename(patchPath);
+	return (await readdir(dir).catch(() => [])).filter((n) => n.startsWith(base + ".bak-")).sort().reverse()[0];
+}
 /** 各方法 handler 表（类型由 shared/rpc 的 RpcHandlerMap 约束）。 */
 function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearcher = newContentSearcher(ctx)) {
 	return {
@@ -3261,6 +4461,7 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 			try {
 				const target = await resolveTarget(ctx, sc.session, args.path);
 				await fs.writeText(target, args.content, void 0, void 0, policyOf(ctx, sc.session));
+				invalidateIndex(ctx, sc.cwd, args.path);
 				const bucket = await bucketOf(registry, ctx, sc.cwd);
 				let changed = false;
 				for (const rec of bucket.values()) if (rec.path === args.path && rec.superseded !== true) {
@@ -3397,7 +4598,7 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				error: sc.err
 			};
 			const text = String(args.text ?? "");
-			enqueueDebug(ctx, sc.cwd, policyOf(ctx, sc.session), text);
+			enqueueDebug(ctx, sc.cwd, text);
 			console.error("[edrv-debug] " + text);
 			return { ok: true };
 		},
@@ -3454,40 +4655,22 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				ok: false,
 				error: sc.err
 			};
-			const fs = ctx.get("fs");
-			if (!fs) return {
+			const rel = normalizeRel(args.path);
+			if (rel === null) return {
 				ok: false,
-				error: "缺少 fs"
+				error: "路径不合法"
+			};
+			const res = await listDirCached(ctx, sc.cwd, rel, args.force === true);
+			if ("error" in res) return {
+				ok: false,
+				error: res.error
+			};
+			return {
+				ok: true,
+				root: res.root,
+				path: rel,
+				entries: res.entries
 			};
-			try {
-				const rel = normalizeRel(args.path);
-				if (rel === null) return {
-					ok: false,
-					error: "路径不合法"
-				};
-				const target = await resolveTarget(ctx, sc.session, rel || ".");
-				const info = await fs.stat(target);
-				if (!info) return {
-					ok: false,
-					error: "目录不存在"
-				};
-				if (info.type !== "directory") return {
-					ok: false,
-					error: "不是目录"
-				};
-				const children = await fs.listDir(target);
-				return {
-					ok: true,
-					root: fs.processPath(await fs.resolve(".", { cwd: sc.cwd })),
-					path: rel,
-					entries: toTreeEntries(rel, children)
-				};
-			} catch (error) {
-				return {
-					ok: false,
-					error: "读取目录失败：" + String(error)
-				};
-			}
 		},
 		"edrv.revealInExplorer": async (args) => {
 			const sc = await requireSession(ctx, args.sessionId);
@@ -3705,6 +4888,211 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 					error: String(error)
 				};
 			}
+		},
+		"edrv.perf.inventory": async () => {
+			try {
+				const home = dshHome();
+				const inventory = await scanSessionInventory(home, sessionsArchiveRoot(home));
+				const active = activeSessionIds(ctx);
+				markActiveSessions(inventory.sessions, active);
+				return {
+					ok: true,
+					...inventory,
+					activeIds: [...active]
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "盘点失败：" + String(error)
+				};
+			}
+		},
+		"edrv.perf.sessionSize": async (args) => {
+			try {
+				return {
+					ok: true,
+					...await sessionSizeOf(dshHome(), args.cwd, args.sessionId ?? "")
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "读取会话体积失败：" + String(error)
+				};
+			}
+		},
+		"edrv.perf.movePlan": async (args) => {
+			try {
+				const home = dshHome();
+				const inventory = await scanSessionInventory(home, sessionsArchiveRoot(home));
+				markActiveSessions(inventory.sessions, activeSessionIds(ctx));
+				return {
+					ok: true,
+					...planMoveOut(inventory, {
+						workspaceKey: args.workspaceKey,
+						sessionIds: args.sessionIds,
+						minBytes: args.minBytes,
+						olderThanDays: args.olderThanDays
+					})
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "移出规划失败：" + String(error)
+				};
+			}
+		},
+		"edrv.perf.moveOut": async (args) => {
+			try {
+				const home = dshHome();
+				const items = (args.sessionIds ?? []).map((sessionId) => ({
+					workspaceKey: args.workspaceKey,
+					sessionId,
+					bytes: 0
+				}));
+				return {
+					ok: true,
+					...await moveOutSessions(home, sessionsArchiveRoot(home), items, activeSessionIds(ctx), args.dryRun === true)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "移出失败：" + String(error)
+				};
+			}
+		},
+		"edrv.perf.restore": async (args) => {
+			try {
+				const result = await restoreSession(dshHome(), sessionsArchiveRoot(dshHome()), args.workspaceKey, args.sessionId);
+				return result.ok ? {
+					ok: true,
+					restored: true
+				} : {
+					ok: false,
+					error: result.error ?? "恢复失败"
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "恢复失败：" + String(error)
+				};
+			}
+		},
+		"edrv.perf.purgeArchive": async (args) => {
+			try {
+				return {
+					ok: true,
+					...await purgeArchive(sessionsArchiveRoot(dshHome()), args.olderThanDays)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "清除失败：" + String(error)
+				};
+			}
+		},
+		"edrv.perf.sidecarSummary": async (args) => {
+			const sc = await requireSession(ctx, args.sessionId);
+			const cwd = "err" in sc ? null : sc.cwd;
+			try {
+				return {
+					ok: true,
+					...await sidecarSummaryOf(ctx, cwd)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "读取侧车摘要失败：" + String(error)
+				};
+			}
+		},
+		"edrv.perf.configGet": async () => {
+			try {
+				const { profileDir, patchPath } = await patchFileInfo();
+				const block = perfConfigBlock();
+				if (!patchPath) return {
+					ok: true,
+					applied: false,
+					block
+				};
+				const text = await readFile(patchPath, "utf8").catch(() => "");
+				const backup = await latestPatchBackup(patchPath);
+				return {
+					ok: true,
+					profileDir,
+					patchPath,
+					applied: patchHasPerfConfig(text),
+					block,
+					backup
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "读取压缩配置失败：" + String(error)
+				};
+			}
+		},
+		"edrv.perf.configApply": async () => {
+			try {
+				const { patchPath } = await patchFileInfo();
+				if (!patchPath) return {
+					ok: false,
+					error: "未找到依赖本插件的 profile（检查 DSH_HOME/profiles）"
+				};
+				const text = await readFile(patchPath, "utf8").catch(() => "");
+				const backup = patchPath + ".bak-" + Date.now();
+				if (text) await writeFile(backup, text, "utf8");
+				await mkdir(join(patchPath, ".."), { recursive: true });
+				await writeFile(patchPath, patchInsertPerfConfig(text), "utf8");
+				return {
+					ok: true,
+					applied: true,
+					backup,
+					restart: true
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "写入压缩配置失败：" + String(error)
+				};
+			}
+		},
+		"edrv.perf.configUndo": async () => {
+			try {
+				const { patchPath } = await patchFileInfo();
+				if (!patchPath) return {
+					ok: false,
+					error: "未找到依赖本插件的 profile（检查 DSH_HOME/profiles）"
+				};
+				const backup = await latestPatchBackup(patchPath);
+				if (backup) {
+					const backupPath = join(join(patchPath, ".."), backup);
+					const saved = await readFile(backupPath, "utf8").catch(() => null);
+					if (saved !== null) {
+						await writeFile(patchPath, saved, "utf8");
+						await rm(backupPath, { force: true }).catch(() => {});
+						return {
+							ok: true,
+							restored: true,
+							backup
+						};
+					}
+				}
+				const text = await readFile(patchPath, "utf8").catch(() => "");
+				if (!patchHasPerfConfig(text)) return {
+					ok: false,
+					error: "没有可撤销的压缩配置"
+				};
+				await writeFile(patchPath, patchRemovePerfConfig(text), "utf8");
+				return {
+					ok: true,
+					restored: true
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "撤销压缩配置失败：" + String(error)
+				};
+			}
 		}
 	};
 }
@@ -3898,10 +5286,12 @@ function apply(ctx, config) {
 			dropFileIndex(cwd);
 			searcher.dispose(cwd);
 			contentSearcher.dispose(cwd);
+			disposeIndex(cwd);
 		}
 	});
 	registerRoutes(ctx, config, (method, args) => handleRpc(ctx, registry, method, args, searcher, contentSearcher), (warning) => warnings.push(warning));
 	installIsolation(ctx);
+	sweepTreeCache();
 	logCompatSummary(ctx, warnings);
 	ctx.logger?.info?.("[dsh-vscode-mode] 编辑差异审查已装配（/edrv/rpc 路由就绪，项目 MCP 隔离已启用）");
 }