dsh-vscode-mode 0.1.30 → 0.1.35

package/lib/index.js

@@ -1,10 +1,12 @@
 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 { existsSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+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, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+import { inflateRawSync } from "node:zlib";
 //#region src/mcp.ts
 /**
 * dsh-vscode-mode host — MCP 运行时管理适配层。
@@ -368,6 +370,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 +635,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 +760,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 +774,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 +790,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 +803,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 +1311,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 +1572,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 +2124,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);
 	}
@@ -1487,7 +2180,7 @@ function pathMatch(value, query) {
 * 作者 ddj 2026年08月24号
 */
 const STDOUT_CAP$1 = 4 << 20;
-const STDERR_CAP$1 = 65536;
+const STDERR_CAP$2 = 65536;
 const GRACE_MS$1 = 2e4;
 /** 默认排除目录（文件/内容搜索共用，导出供 provider 复用）。 */
 const EXCLUDES = [
@@ -1579,6 +2272,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 输入
@@ -1609,7 +2361,7 @@ async function searchRipgrep(input) {
 		stdio: {
 			stdin: "ignore",
 			stdout: { maxBytes: STDOUT_CAP$1 },
-			stderr: { maxBytes: STDERR_CAP$1 }
+			stderr: { maxBytes: STDERR_CAP$2 }
 		},
 		graceMs: GRACE_MS$1,
 		signal: input.signal
@@ -1621,7 +2373,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 {
@@ -2065,7 +2826,7 @@ function newSearcher(ctx) {
 //#endregion
 //#region src/search/content.ts
 const STDOUT_CAP = 16 << 20;
-const STDERR_CAP = 65536;
+const STDERR_CAP$1 = 65536;
 const GRACE_MS = 2e4;
 const DEFAULT_MAX_MATCHES = 500;
 const DEFAULT_MAX_FILES = 100;
@@ -2227,7 +2988,7 @@ async function searchRipgrepContent(input) {
 		stdio: {
 			stdin: "ignore",
 			stdout: { maxBytes: STDOUT_CAP },
-			stderr: { maxBytes: STDERR_CAP }
+			stderr: { maxBytes: STDERR_CAP$1 }
 		},
 		graceMs: GRACE_MS,
 		signal: input.signal
@@ -2239,17 +3000,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 +3081,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 +3109,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 +3582,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 +3649,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 +4123,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 +4141,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 +4149,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,9 +4254,31 @@ 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)) {
+function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearcher = newContentSearcher(ctx), lspHandlers) {
 	return {
+		...lspHandlers ?? {},
 		"edrv.list": async (args) => {
 			const sc = await requireSession(ctx, args.sessionId);
 			if ("err" in sc) return {
@@ -3261,6 +4464,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 +4601,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 +4658,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,58 +4891,263 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 					error: String(error)
 				};
 			}
-		}
-	};
-}
-/**
-* 统一入口：按方法分发到 handler 表。
-* @author ddj 2026年08月20号 / 2026年08月26号
-*/
-async function handleRpc(ctx, registry, method, args, searcher = newSearcher(ctx), contentSearcher = newContentSearcher(ctx)) {
-	const handler = buildHandlers(ctx, registry, searcher, contentSearcher)[method];
-	if (!handler) return {
-		ok: false,
-		error: "未知方法: " + String(method)
-	};
-	return handler(args);
-}
-//#endregion
-//#region src/mcpIsolation.ts
-/**
-* dsh-vscode-mode host — 项目 MCP 的 agent 级隔离。
-* 项目 MCP 连接仍由 Host 维护，但每个 agent 只继承当前 workspace 的项目工具；
-* tools.restrict() 负责模型可见性，tools.guard() 负责执行层兜底拒绝。
-* 作者 ddj 2026年08月22号
-*/
-const UNKNOWN_PROJECT = "__unknown_project__";
-/** 统一 workspace 路径，供 cwd 父路径匹配。 */
-function normalizePath(path) {
-	return String(path ?? "").replace(/\\/g, "/").replace(/\/+/g, "/").replace(/\/$/, "").toLowerCase();
-}
-/** 在已注册 workspace 中匹配 cwd，优先最长父路径。 */
-function matchWorkspace(cwd, paths) {
-	if (!cwd) return void 0;
-	const target = normalizePath(cwd);
-	const matches = paths.filter((path) => {
-		const root = normalizePath(path);
-		return target === root || target.startsWith(root + "/");
-	});
-	matches.sort((a, b) => normalizePath(b).length - normalizePath(a).length);
-	return matches[0];
-}
-/** 根据 entry id 判断是否为新旧格式项目 MCP（兼容层统一判定）。 */
-const isProjectEntry = isProjectEntryId;
-/** 返回一个 agent 不应继承的项目工具名。 */
-function denyTools(toolProjects, currentPath) {
-	return [...toolProjects.entries()].filter(([, owner]) => owner !== currentPath).map(([name]) => name).sort();
-}
-/** 从 loader entry 和工具注册表建立工具到项目路径的映射。 */
-function projectTools(ctx) {
-	const result = /* @__PURE__ */ new Map();
-	const workspaces = ctx.get("workspaceRegistry")?.list?.() ?? [];
-	const byHash = new Map(workspaces.map((ws) => [hashWorkspace(ws.path), ws.path]));
-	const visible = ctx.get("tools")?.view?.(void 0)?.visible;
-	if (!(visible instanceof Map)) return result;
+		},
+		"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)
+				};
+			}
+		}
+	};
+}
+/**
+* 统一入口：按方法分发到 handler 表。
+* @author ddj 2026年08月20号 / 2026年08月26号
+*/
+async function handleRpc(ctx, registry, method, args, searcher = newSearcher(ctx), contentSearcher = newContentSearcher(ctx), lspHandlers) {
+	const handler = buildHandlers(ctx, registry, searcher, contentSearcher, lspHandlers)[method];
+	if (!handler) return {
+		ok: false,
+		error: "未知方法: " + String(method)
+	};
+	return handler(args);
+}
+//#endregion
+//#region src/mcpIsolation.ts
+/**
+* dsh-vscode-mode host — 项目 MCP 的 agent 级隔离。
+* 项目 MCP 连接仍由 Host 维护，但每个 agent 只继承当前 workspace 的项目工具；
+* tools.restrict() 负责模型可见性，tools.guard() 负责执行层兜底拒绝。
+* 作者 ddj 2026年08月22号
+*/
+const UNKNOWN_PROJECT = "__unknown_project__";
+/** 统一 workspace 路径，供 cwd 父路径匹配。 */
+function normalizePath(path) {
+	return String(path ?? "").replace(/\\/g, "/").replace(/\/+/g, "/").replace(/\/$/, "").toLowerCase();
+}
+/** 在已注册 workspace 中匹配 cwd，优先最长父路径。 */
+function matchWorkspace(cwd, paths) {
+	if (!cwd) return void 0;
+	const target = normalizePath(cwd);
+	const matches = paths.filter((path) => {
+		const root = normalizePath(path);
+		return target === root || target.startsWith(root + "/");
+	});
+	matches.sort((a, b) => normalizePath(b).length - normalizePath(a).length);
+	return matches[0];
+}
+/** 根据 entry id 判断是否为新旧格式项目 MCP（兼容层统一判定）。 */
+const isProjectEntry = isProjectEntryId;
+/** 返回一个 agent 不应继承的项目工具名。 */
+function denyTools(toolProjects, currentPath) {
+	return [...toolProjects.entries()].filter(([, owner]) => owner !== currentPath).map(([name]) => name).sort();
+}
+/** 从 loader entry 和工具注册表建立工具到项目路径的映射。 */
+function projectTools(ctx) {
+	const result = /* @__PURE__ */ new Map();
+	const workspaces = ctx.get("workspaceRegistry")?.list?.() ?? [];
+	const byHash = new Map(workspaces.map((ws) => [hashWorkspace(ws.path), ws.path]));
+	const visible = ctx.get("tools")?.view?.(void 0)?.visible;
+	if (!(visible instanceof Map)) return result;
 	for (const entry of entriesOf(ctx)) {
 		const id = String(entry.id ?? entry.options?.id ?? "");
 		if (!isProjectEntry(id)) continue;
@@ -3856,54 +5247,1960 @@ function dropFileIndex(cwd) {
 	fileIndex.delete(cwd);
 }
 //#endregion
-//#region src/index.ts
+//#region src/lsp/jsonrpc.ts
 /**
-* @dsh-external 生态 → dsh-vscode-mode：DSH 上的类 VSCode 编码体验（Host 半入口）。
-* 职责：装配 capture（tools/result 捕获 edit/write 差异）、RPC 分发（edrv.* / mcp.* / vscode.* / compat）、
-*       webServer 路由（/edrv/rpc、/edrv/assets/*、/edrv/vendor/*）、工作区旁车持久化、
-*       兼容层装配（依赖守卫 + 重复装配自诊断 + 启动日志兼容性报告）。
-* 结构：shared/（双面契约） + model/store/capture/workspace/revert/registry/rpc/routes/compat（host 模块）。
-* 作者 ddj 2026-08-20
+* dsh-vscode-mode host — LSP JSON-RPC 帧编解码（纯函数，node 可测）。
+* LSP over stdio 用 Content-Length 帧：
+*   Content-Length: <n>\r\n\r\n<恰好 n 字节 JSON>
+* 导出：encodeMessage（对象→帧 Buffer）、createFrameParser（流式粘包/拆包）、parseFrame（单帧）。
+* 作者 ddj 2026-08-27
 */
-const name = "dsh-vscode-mode";
-const inject = [
-	"sessions",
-	"fs",
-	"webServer",
-	"loader",
-	"tools",
-	"workspaceRegistry",
-	"agents"
-];
+const HEADER_END = "\r\n\r\n";
+/** 消息头正则（仅取 Content-Length；其它头忽略）。 */
+const HEADER_RE = /^Content-Length:\s*(\d+)\s*$/im;
+/** 将对象编码为带 Content-Length 头的帧。 */
+function encodeMessage(message) {
+	const body = JSON.stringify(message);
+	const head = "Content-Length: " + Buffer.byteLength(body, "utf8") + "\r\n\r\n";
+	return Buffer.from(head + body, "utf8");
+}
 /**
-* 装配插件：挂事件监听、注册路由、安装兼容层。
-* @author ddj 2026年08月20号
-* @param ctx DSH 上下文（sessions/fs/webServer 由 inject 提供；sandboxPolicy/subprocess 惰性获取）
-* @param config 插件配置（可选 imageDir 覆盖图标目录）
+* 尝试从 buffer 解析单个帧；成功返回 { body, rest }，数据不足返回 null。
+* @author ddj 2026年08月27号
+* @param buffer 已累积的字节
+* @returns 解析结果（rest 为剩余未消费字节）
 */
-function apply(ctx, config) {
-	const registry = /* @__PURE__ */ new Map();
-	const searcher = newSearcher(ctx);
-	const contentSearcher = newContentSearcher(ctx);
-	/** 兼容性警告收集（route 护栏等写入，启动日志一并输出）。 */
-	const warnings = [];
-	setupOpenSettings(ctx, config, () => {});
-	ctx.on("tools/result", (exec, result) => {
-		captureToolResult(ctx, registry, exec, result);
+function parseFrame(buffer) {
+	const headEnd = buffer.indexOf(HEADER_END);
+	if (headEnd < 0) return null;
+	const header = buffer.subarray(0, headEnd).toString("utf8");
+	const m = HEADER_RE.exec(header);
+	if (!m) {
+		const next = buffer.indexOf("Content-Length:");
+		return next >= 0 ? parseFrame(buffer.subarray(next)) : null;
+	}
+	const length = Number(m[1]);
+	const bodyStart = headEnd + 4;
+	if (buffer.length < bodyStart + length) return null;
+	return {
+		body: buffer.subarray(bodyStart, bodyStart + length).toString("utf8"),
+		rest: buffer.subarray(bodyStart + length)
+	};
+}
+/** 帧解析器：push 数据块，吐出完整消息（可能拆包后重组、也可能一包多帧）。 */
+function createFrameParser() {
+	let buffer = Buffer.alloc(0);
+	return {
+		push(chunk) {
+			if (chunk.length) buffer = Buffer.concat([buffer, chunk]);
+			const out = [];
+			for (;;) {
+				const parsed = parseFrame(buffer);
+				if (!parsed) break;
+				buffer = parsed.rest;
+				try {
+					out.push(JSON.parse(parsed.body));
+				} catch (error) {
+					out.push({
+						jsonrpc: "2.0",
+						error: {
+							code: -32700,
+							message: "Parse error: " + String(error)
+						},
+						id: null
+					});
+				}
+			}
+			return out;
+		},
+		clear() {
+			buffer = Buffer.alloc(0);
+		}
+	};
+}
+/** 构造标准 JSON-RPC 请求消息。 */
+function requestMessage(id, method, params) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		method,
+		params
+	};
+}
+/** 构造标准 JSON-RPC 通知消息（无 id，fire-and-forget）。 */
+function notifyMessage(method, params) {
+	return {
+		jsonrpc: "2.0",
+		method,
+		params
+	};
+}
+//#endregion
+//#region src/lsp/transport.ts
+/**
+* dsh-vscode-mode host — LSP 语言服务器进程传输层。
+* 基于 node:child_process.spawn（stdio pipe 双向流）。刻意不用 DSH ctx.subprocess
+* 抽象：LSP 需要持续写 stdin + 流式读 stdout，而该抽象 stdin 不可写、输出为一次性收集。
+* 作者 ddj 2026-08-27
+*/
+const STDERR_CAP = 262144;
+const running = /* @__PURE__ */ new Set();
+/**
+* 启动语言服务器进程。
+* @author ddj 2026年08月27号
+* @param spec 启动参数（argv 数组，不经 shell，Windows 引号安全）
+* @param onMessage stdout 消息回调
+* @param logger 诊断日志（可选）
+* @returns 传输句柄
+*/
+function spawnServer(spec, onMessage, logger) {
+	const { argv, cwd, env } = spec;
+	const child = spawn(argv[0], argv.slice(1), {
+		cwd,
+		env: {
+			...process.env,
+			...env
+		},
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true
 	});
-	ctx.on("session/disposed", (session) => {
-		const cwd = cwdOf(session);
-		if (cwd) {
-			registry.delete(cwd);
-			dropFileIndex(cwd);
-			searcher.dispose(cwd);
-			contentSearcher.dispose(cwd);
+	running.add(child);
+	let stderrBuf = Buffer.alloc(0);
+	let alive = true;
+	const parser = createFrameParser();
+	child.stderr.on("data", (chunk) => {
+		if (stderrBuf.length < STDERR_CAP) stderrBuf = Buffer.concat([stderrBuf, chunk], Math.min(stderrBuf.length + chunk.length, STDERR_CAP));
+		logger?.(chunk.toString("utf8"));
+	});
+	let exited = false;
+	const emitExit = (code, signal) => {
+		if (exited) return;
+		exited = true;
+		alive = false;
+		running.delete(child);
+		transport.onExit?.(code, signal);
+	};
+	child.on("error", (error) => {
+		logger?.("spawn error: " + String(error));
+		emitExit(null, null);
+	});
+	child.on("exit", (code, signal) => emitExit(code, signal));
+	child.on("close", (code, signal) => emitExit(code, signal));
+	const transport = {
+		write(chunk) {
+			if (!alive || !child.stdin.writable) return false;
+			child.stdin.write(chunk);
+			return true;
+		},
+		onMessage,
+		stderr() {
+			return stderrBuf.toString("utf8");
+		},
+		onExit: null,
+		dispose() {
+			if (!alive) return;
+			child.kill();
+			setTimeout(() => {
+				if (!alive) return;
+				alive = false;
+				running.delete(child);
+				try {
+					if (process.platform === "win32") spawn("taskkill", [
+						"/PID",
+						String(child.pid),
+						"/T",
+						"/F"
+					], {
+						windowsHide: true,
+						stdio: "ignore"
+					});
+					else child.kill("SIGKILL");
+				} catch (error) {
+					logger?.("force kill error: " + String(error));
+				}
+			}, 1500).unref?.();
+		},
+		get alive() {
+			return alive;
+		},
+		get pid() {
+			return child.pid;
 		}
+	};
+	child.stdout.on("data", (chunk) => {
+		for (const message of parser.push(chunk)) transport.onMessage?.(message);
 	});
-	registerRoutes(ctx, config, (method, args) => handleRpc(ctx, registry, method, args, searcher, contentSearcher), (warning) => warnings.push(warning));
-	installIsolation(ctx);
-	logCompatSummary(ctx, warnings);
-	ctx.logger?.info?.("[dsh-vscode-mode] 编辑差异审查已装配（/edrv/rpc 路由就绪，项目 MCP 隔离已启用）");
+	return transport;
+}
+/** 强杀全部运行中的 LSP 子进程（插件卸载/退出用）。 */
+function disposeAllServers() {
+	for (const child of running) try {
+		if (process.platform === "win32" && child.pid) spawn("taskkill", [
+			"/PID",
+			String(child.pid),
+			"/T",
+			"/F"
+		], {
+			windowsHide: true,
+			stdio: "ignore"
+		});
+		else child.kill("SIGKILL");
+	} catch (error) {}
+	running.clear();
+}
+//#endregion
+//#region src/lsp/client.ts
+/**
+* dsh-vscode-mode host — LSP 客户端（JSON-RPC over stdio）。
+* 职责：请求/通知/握手/超时/服务器端请求处理/生命周期。transport 无关性：
+* 只依赖 write/onMessage 契约，便于单测时注入假传输。
+* 作者 ddj 2026-08-27
+*/
+const DEFAULT_TIMEOUT_MS = 2e4;
+var LspError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+/**
+* 创建 LSP 客户端。
+* @author ddj 2026年08月27号
+* @param transport 传输句柄（write/onMessage/alive/dispose）
+* @param events 事件回调
+* @returns LSP 客户端
+*/
+function createLspClient(transport, events = {}) {
+	let nextId = 1;
+	let alive = transport.alive;
+	const pending = /* @__PURE__ */ new Map();
+	let serverCapabilities = {
+		definition: false,
+		references: false,
+		documentSymbol: false,
+		workspaceSymbol: false,
+		hover: false
+	};
+	const log = (line) => events.onLog?.(line);
+	createFrameParser();
+	transport.onMessage = (message) => {
+		const msg = message;
+		if (typeof msg.method === "string") {
+			if (msg.method === "$/progress") events.onProgress?.(msg.params);
+			handleServerRequest(msg);
+			return;
+		}
+		if (typeof msg.id === "number" || typeof msg.id === "string") {
+			const entry = pending.get(Number(msg.id));
+			if (!entry) return;
+			pending.delete(Number(msg.id));
+			clearTimeout(entry.timer);
+			if (msg.error) {
+				const err = msg.error;
+				entry.reject(new LspError(err.code ?? -32e3, err.message ?? "LSP error"));
+			} else entry.resolve(msg.result);
+		}
+	};
+	/** 服务器端请求：消息/日志类打日志，配置/能力类回 result:null，其余回 method not found。 */
+	const handleServerRequest = async (msg) => {
+		const { method, params, id } = msg;
+		const respond = (payload) => {
+			transport.write(encodeMessage(payload));
+		};
+		try {
+			if (method === "window/logMessage" || method === "window/showMessage" || method === "window/showMessageRequest") {
+				const p = params;
+				log("[server " + (p?.type ?? "") + "] " + String(p?.message ?? ""));
+				if (id !== void 0) respond({
+					jsonrpc: "2.0",
+					id,
+					result: null
+				});
+				return;
+			}
+			if (method === "workspace/configuration") {
+				const p = params;
+				const items = Array.isArray(p?.items) ? p.items.map(() => null) : [];
+				if (id !== void 0) respond({
+					jsonrpc: "2.0",
+					id,
+					result: items
+				});
+				return;
+			}
+			if (method === "window/workDoneProgress/create" || method === "client/registerCapability" || method === "workspace/workspaceFolders") {
+				if (id !== void 0) respond({
+					jsonrpc: "2.0",
+					id,
+					result: null
+				});
+				return;
+			}
+			if (id !== void 0) respond({
+				jsonrpc: "2.0",
+				id,
+				error: {
+					code: -32601,
+					message: "Method not found: " + method
+				}
+			});
+		} catch (error) {
+			log("server request handler error: " + String(error));
+			if (id !== void 0) respond({
+				jsonrpc: "2.0",
+				id,
+				error: {
+					code: -32603,
+					message: String(error)
+				}
+			});
+		}
+	};
+	const transportExit = transport.onExit;
+	transport.onExit = (code, signal) => {
+		alive = false;
+		for (const entry of pending.values()) {
+			clearTimeout(entry.timer);
+			entry.reject(/* @__PURE__ */ new Error("LSP 服务器已退出（" + String(code) + "/" + String(signal) + "）"));
+		}
+		pending.clear();
+		events.onExit?.(code, signal);
+		transportExit?.(code, signal);
+	};
+	const client = {
+		async request(method, params, timeoutMs = DEFAULT_TIMEOUT_MS) {
+			if (!alive) throw new Error("LSP 服务器未运行");
+			const id = nextId++;
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					pending.delete(id);
+					reject(/* @__PURE__ */ new Error("LSP 请求超时：" + method + "（" + timeoutMs + "ms）"));
+				}, timeoutMs);
+				pending.set(id, {
+					resolve,
+					reject,
+					timer
+				});
+				transport.write(encodeMessage(requestMessage(id, method, params)));
+			});
+		},
+		notify(method, params) {
+			if (!alive) return;
+			transport.write(encodeMessage(notifyMessage(method, params)));
+		},
+		async initialize(rootUri, workspaceFolders) {
+			const caps = (await client.request("initialize", {
+				processId: process.pid,
+				rootUri: rootUri || null,
+				rootPath: null,
+				workspaceFolders: workspaceFolders.length ? workspaceFolders.map((uri) => ({
+					uri,
+					name: uri
+				})) : null,
+				capabilities: {
+					window: { workDoneProgress: true },
+					workspace: { configuration: true },
+					textDocument: {
+						synchronization: {
+							dynamicRegistration: false,
+							willSave: false,
+							didSave: true
+						},
+						definition: { dynamicRegistration: false },
+						references: { dynamicRegistration: false },
+						documentSymbol: { dynamicRegistration: false },
+						hover: { dynamicRegistration: false }
+					}
+				}
+			}))?.capabilities ?? {};
+			serverCapabilities = {
+				definition: Boolean(caps.definitionProvider),
+				references: Boolean(caps.referencesProvider),
+				documentSymbol: Boolean(caps.documentSymbolProvider),
+				workspaceSymbol: Boolean(caps.workspaceSymbolProvider),
+				hover: Boolean(caps.hoverProvider)
+			};
+			client.notify("initialized", {});
+			events.onReady?.(serverCapabilities);
+			return serverCapabilities;
+		},
+		async shutdown() {
+			try {
+				await client.request("shutdown", null, 3e3);
+			} catch (error) {
+				log("shutdown: " + String(error));
+			}
+			try {
+				client.notify("exit", null);
+			} catch (error) {
+				log("exit: " + String(error));
+			}
+		},
+		get alive() {
+			return alive;
+		}
+	};
+	return client;
+}
+//#endregion
+//#region src/lsp/uri.ts
+/**
+* dsh-vscode-mode host — 路径 ↔ file:// URI 转换（纯函数，node 可测）。
+* LSP 的 uri 字段必须是 file:// 绝对 URI；客户端 Monaco 用 edrv:///<encodeURI(path)>。
+* 作者 ddj 2026-08-27
+*/
+/**
+* 绝对路径 → file:// URI（Windows 盘符保留：D:/x → file:///D:/x）。
+* @author ddj 2026年08月27号
+* @param absPath 绝对路径（正/反斜杠均可）
+* @returns file:// URI
+*/
+function pathToFileUri(absPath) {
+	const normalized = absPath.replace(/\\/g, "/");
+	const drive = /^([A-Za-z]:)(?:\/(.*))?$/.exec(normalized);
+	if (drive) {
+		const tail = drive[2] ? "/" + drive[2].split("/").map(encodeURIComponent).join("/") : "";
+		return "file:///" + drive[1] + tail;
+	}
+	return pathToFileURL(normalized).toString();
+}
+//#endregion
+//#region src/lsp/server.ts
+/**
+* dsh-vscode-mode host — 单语言服务器会话（绑定 工作区根 + 语言）。
+* 负责：启动传输 + LSP 客户端握手、文档同步（didOpen/didChange/didSave/didClose）、
+* 请求封装（definition/references/documentSymbol/workspaceSymbol/hover）、状态上报。
+* 作者 ddj 2026-08-27
+*/
+/**
+* 创建语言服务器会话。
+* @author ddj 2026年08月27号
+* @param spec provider 规格（argv/cwd）
+* @param root 工作区根（绝对路径）
+* @param languageId 语言 id
+* @param logger 诊断日志
+* @returns 会话句柄
+*/
+function createLspServer(spec, root, languageId, logger) {
+	const rootUri = pathToFileUri(root);
+	const docs = /* @__PURE__ */ new Map();
+	let phase = "idle";
+	let transport = null;
+	let client = null;
+	let capabilities = {
+		definition: false,
+		references: false,
+		documentSymbol: false,
+		workspaceSymbol: false,
+		hover: false
+	};
+	let disposed = false;
+	let readyWait = Promise.resolve(false);
+	let resolveReady = null;
+	let lastProgress = {};
+	let lastStatus = {
+		languageId,
+		source: spec.kind,
+		phase: "idle",
+		reason: spec.ready ? void 0 : spec.reason,
+		root
+	};
+	const log = (line) => logger?.("[" + languageId + "@" + root + "] " + line);
+	const setPhase = (next, reason) => {
+		phase = next;
+		lastStatus = {
+			languageId,
+			source: spec.kind,
+			phase: next,
+			reason,
+			root,
+			...progressFields()
+		};
+		server.onStateChange?.(lastStatus);
+	};
+	/** 返回当前进度字段，避免空进度污染状态载荷。 */
+	const progressFields = () => ({
+		progress: lastProgress.value,
+		progressMessage: lastProgress.message
+	});
+	/** 处理 LSP $/progress 通知并映射为编辑器状态。 */
+	const applyProgress = (params) => {
+		const report = params?.value;
+		if (report?.kind === "begin") {
+			lastProgress = {
+				value: 0,
+				message: typeof report.message === "string" ? report.message : "正在解析工作区"
+			};
+			if (phase === "ready") phase = "indexing";
+		} else if (report?.kind === "end") {
+			lastProgress = {
+				value: 100,
+				message: typeof report.message === "string" ? report.message : "解析完成"
+			};
+			if (phase === "indexing") phase = "ready";
+		} else if (typeof report?.percentage === "number") {
+			lastProgress = {
+				value: Math.max(0, Math.min(100, report.percentage)),
+				message: typeof report.message === "string" ? report.message : lastProgress.message
+			};
+			if (phase === "ready") phase = "indexing";
+		} else if (typeof report?.message === "string") lastProgress = {
+			...lastProgress,
+			message: report.message
+		};
+		lastStatus = {
+			...lastStatus,
+			phase,
+			...progressFields()
+		};
+		server.onStateChange?.(lastStatus);
+	};
+	const ensureClient = () => {
+		if (!client) throw new Error("LSP 服务器未启动");
+		return client;
+	};
+	const server = {
+		languageId,
+		root,
+		get phase() {
+			return phase;
+		},
+		get capabilities() {
+			return capabilities;
+		},
+		status() {
+			return lastStatus;
+		},
+		onStateChange: null,
+		async start() {
+			if (disposed) return false;
+			if (phase === "starting") return readyWait;
+			if (phase === "ready" || phase === "indexing") return true;
+			readyWait = new Promise((resolve) => {
+				resolveReady = resolve;
+			});
+			lastProgress = {};
+			setPhase("starting");
+			try {
+				transport = spawnServer({
+					argv: spec.argv,
+					cwd: spec.cwd ?? root
+				}, (message) => {}, (line) => log("stderr: " + line));
+				client = createLspClient(transport, {
+					onReady: (caps) => {
+						capabilities = caps;
+						for (const doc of docs.values()) client?.notify("textDocument/didOpen", { textDocument: {
+							uri: doc.uri,
+							languageId,
+							version: doc.version,
+							text: doc.text
+						} });
+						setPhase("ready");
+						resolveReady?.(true);
+						resolveReady = null;
+						log("ready: definition=" + caps.definition + " references=" + caps.references + " symbols=" + caps.documentSymbol);
+					},
+					onProgress: (params) => applyProgress(params),
+					onExit: (code, signal) => {
+						if (disposed) return;
+						resolveReady?.(false);
+						resolveReady = null;
+						log("server exited (" + String(code) + "/" + String(signal) + ")");
+						client = null;
+						transport = null;
+						setPhase("idle", "服务器已退出（" + String(code) + "/" + String(signal) + "），等待重启");
+					},
+					onLog: (line) => log("lsp: " + line)
+				});
+				capabilities = await client.initialize(rootUri, [rootUri]);
+				return true;
+			} catch (error) {
+				log("start failed: " + String(error));
+				setPhase("unavailable", "启动失败：" + String(error));
+				resolveReady?.(false);
+				resolveReady = null;
+				try {
+					await server.dispose();
+				} catch {}
+				return false;
+			}
+		},
+		sync(path, text, version) {
+			const existing = docs.get(path);
+			const uri = existing?.uri ?? pathToFileUri(root + "/" + path.split("/").join("/"));
+			if (existing) {
+				existing.version = version;
+				existing.text = text;
+				if (phase === "ready" || phase === "indexing") client?.notify("textDocument/didChange", {
+					textDocument: {
+						uri,
+						version
+					},
+					contentChanges: [{ text }]
+				});
+				return;
+			}
+			docs.set(path, {
+				path,
+				uri,
+				version,
+				text
+			});
+			if (phase === "ready" || phase === "indexing") client?.notify("textDocument/didOpen", { textDocument: {
+				uri,
+				languageId,
+				version,
+				text
+			} });
+		},
+		close(path) {
+			const doc = docs.get(path);
+			if (!doc) return;
+			docs.delete(path);
+			if (phase === "ready" || phase === "indexing") client?.notify("textDocument/didClose", { textDocument: { uri: doc.uri } });
+		},
+		async definition(path, line, character) {
+			const doc = docs.get(path);
+			if (!doc || !await readyWait) return [];
+			return normalizeLocations(await ensureClient().request("textDocument/definition", {
+				textDocument: { uri: doc.uri },
+				position: {
+					line,
+					character
+				}
+			}));
+		},
+		async references(path, line, character, includeDeclaration) {
+			const doc = docs.get(path);
+			if (!doc || !await readyWait) return [];
+			return normalizeLocations(await ensureClient().request("textDocument/references", {
+				textDocument: { uri: doc.uri },
+				position: {
+					line,
+					character
+				},
+				context: { includeDeclaration }
+			}));
+		},
+		async documentSymbol(path) {
+			const doc = docs.get(path);
+			if (!doc || !await readyWait) return [];
+			const result = await ensureClient().request("textDocument/documentSymbol", { textDocument: { uri: doc.uri } });
+			if (!Array.isArray(result)) return [];
+			return result.map(normalizeSymbol).filter((s) => s !== null);
+		},
+		async workspaceSymbol(query) {
+			if (!await readyWait) return [];
+			const result = await ensureClient().request("workspace/symbol", { query });
+			if (!Array.isArray(result)) return [];
+			return result.map(normalizeSymbol).filter((s) => s !== null);
+		},
+		async hover(path, line, character) {
+			const doc = docs.get(path);
+			if (!doc || !await readyWait) return null;
+			const result = await ensureClient().request("textDocument/hover", {
+				textDocument: { uri: doc.uri },
+				position: {
+					line,
+					character
+				}
+			});
+			if (!result || !result.contents) return null;
+			return { contents: stringifyHoverContents(result.contents) };
+		},
+		async dispose() {
+			disposed = true;
+			resolveReady?.(false);
+			resolveReady = null;
+			if (client) {
+				await client.shutdown().catch(() => {});
+				client = null;
+			}
+			if (transport) {
+				transport.dispose();
+				transport = null;
+			}
+			setPhase("stopped");
+		}
+	};
+	return server;
+}
+/** 归一化 definition/references 结果（Location | Location[] | LocationLink[]）。 */
+function normalizeLocations(result) {
+	if (!Array.isArray(result)) return [];
+	const out = [];
+	for (const item of result) {
+		if (!item || typeof item !== "object") continue;
+		const obj = item;
+		const uri = typeof obj.targetUri === "string" ? obj.targetUri : typeof obj.uri === "string" ? obj.uri : "";
+		const range = obj.targetRange ?? obj.range;
+		if (!uri || !range || !range.start || !range.end) continue;
+		out.push({
+			uri,
+			range: {
+				start: {
+					line: toInt(range.start.line),
+					character: toInt(range.start.character)
+				},
+				end: {
+					line: toInt(range.end.line),
+					character: toInt(range.end.character)
+				}
+			}
+		});
+	}
+	return out;
+}
+/** 归一化 documentSymbol/workspaceSymbol 结果（DocumentSymbol | SymbolInformation）。 */
+function normalizeSymbol(item) {
+	if (!item || typeof item !== "object") return null;
+	const obj = item;
+	if (typeof obj.name !== "string") return null;
+	const selection = obj.selectionRange ?? (obj.location && obj.location.range);
+	const range = obj.range ?? selection;
+	if (!range || typeof range !== "object") return null;
+	const r = range;
+	if (!r.start || !r.end) return null;
+	const symbol = {
+		name: obj.name,
+		kind: toInt(obj.kind),
+		range: {
+			start: {
+				line: toInt(r.start.line),
+				character: toInt(r.start.character)
+			},
+			end: {
+				line: toInt(r.end.line),
+				character: toInt(r.end.character)
+			}
+		},
+		selectionRange: selection ? {
+			start: {
+				line: toInt(selection.start?.line ?? toInt(r.start.line)),
+				character: toInt(selection.start?.character ?? toInt(r.start.character))
+			},
+			end: {
+				line: toInt(selection.end?.line ?? toInt(r.end.line)),
+				character: toInt(selection.end?.character ?? toInt(r.end.character))
+			}
+		} : {
+			start: {
+				line: toInt(r.start.line),
+				character: toInt(r.start.character)
+			},
+			end: {
+				line: toInt(r.end.line),
+				character: toInt(r.end.character)
+			}
+		}
+	};
+	if (typeof obj.detail === "string" && obj.detail) symbol.detail = obj.detail;
+	if (typeof obj.containerName === "string" && obj.containerName) symbol.containerName = obj.containerName;
+	if (Array.isArray(obj.children)) {
+		const kids = obj.children.map(normalizeSymbol).filter((s) => s !== null);
+		if (kids.length) symbol.children = kids;
+	}
+	return symbol;
+}
+/** hover contents → 文本行（MarkupContent | MarkedString | MarkedString[]）。 */
+function stringifyHoverContents(contents) {
+	if (typeof contents === "string") return [contents];
+	if (Array.isArray(contents)) return contents.map(stringifyHoverContents).flat().filter(Boolean);
+	if (contents && typeof contents === "object") {
+		const value = contents.value;
+		if (typeof value === "string") return [value];
+	}
+	return [];
+}
+function toInt(value) {
+	const n = Number(value);
+	return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+}
+//#endregion
+//#region src/lsp/manager.ts
+/**
+* dsh-vscode-mode host — LSP 服务器管理器。
+* 实例注册表（key=root|languageId，refcount 共享），崩溃退避重启，session/disposed 清理。
+* 作者 ddj 2026-08-27
+*/
+/**
+* 创建 LSP 管理器。
+* @author ddj 2026年08月27号
+* @param logger 诊断日志
+* @returns 管理器
+*/
+function createLspManager(logger) {
+	const entries = /* @__PURE__ */ new Map();
+	const keyOf = (root, languageId) => root + "|" + languageId;
+	const log = (line) => logger?.("[lsp-manager] " + line);
+	/** 同步摘除注册表项并后台回收（refs 归零/工作区清理用；statusAll 立即可见归零）。 */
+	const dropEntry = (entry) => {
+		if (entry.restartTimer) {
+			clearTimeout(entry.restartTimer);
+			entry.restartTimer = null;
+		}
+		entries.delete(entry.key);
+		entry.server.dispose().catch(() => {});
+	};
+	const manager = {
+		acquire(root, languageId, resolveSpec) {
+			const key = keyOf(root, languageId);
+			let entry = entries.get(key);
+			if (!entry) {
+				const spec = resolveSpec(languageId);
+				const server = createLspServer(spec, root, languageId, log);
+				server.onStateChange = (status) => manager.onStatusChange?.(status);
+				entry = {
+					key,
+					server,
+					refs: 0,
+					failures: 0,
+					restartTimer: null
+				};
+				entries.set(key, entry);
+				if (spec.ready) server.start().then((ok) => {
+					if (!ok && entries.has(key)) entry.failures++;
+				});
+			}
+			entry.refs++;
+			return entry.server;
+		},
+		release(root, languageId) {
+			const entry = entries.get(keyOf(root, languageId));
+			if (!entry) return;
+			entry.refs = Math.max(0, entry.refs - 1);
+			if (entry.refs === 0) dropEntry(entry);
+		},
+		releaseRoot(root) {
+			for (const entry of [...entries.values()]) if (entry.server.root === root) dropEntry(entry);
+		},
+		statusAll() {
+			return [...entries.values()].map((entry) => entry.server.status());
+		},
+		peek(root, languageId) {
+			return entries.get(keyOf(root, languageId))?.server;
+		},
+		async disposeAll() {
+			const list = [...entries.values()];
+			entries.clear();
+			for (const entry of list) {
+				if (entry.restartTimer) clearTimeout(entry.restartTimer);
+				await entry.server.dispose();
+			}
+		},
+		onStatusChange: null
+	};
+	return manager;
+}
+//#endregion
+//#region src/lsp/zip.ts
+/**
+* dsh-vscode-mode host — 纯 Node ZIP 解压（零依赖，跨平台）。
+* 供 extmgr 解包 VSIX 使用；只实现 VSIX 需要的子集：
+* 读取 EOCD + 中央目录，支持 stored(0)/deflate(8)，忽略 zip64（VSIX < 4GB）。
+* 作者 ddj 2026-08-27
+*/
+const EOCD_SIG = 101010256;
+const CDIR_SIG = 33639248;
+const LHDR_SIG = 67324752;
+/**
+* 解析 ZIP 缓冲区 → 条目列表（不解压内容，仅元数据）。
+* @author ddj 2026年08月27号
+* @param buf zip 字节
+* @returns 条目元数据
+*/
+function zipEntries(buf) {
+	const eocd = findEocd(buf);
+	if (eocd < 0) throw new Error("不是有效的 ZIP 文件（找不到 EOCD）");
+	const total = buf.readUInt16LE(eocd + 10);
+	let offset = buf.readUInt32LE(eocd + 16);
+	const out = [];
+	for (let i = 0; i < total; i++) {
+		if (buf.readUInt32LE(offset) !== CDIR_SIG) throw new Error("ZIP 中央目录损坏");
+		const method = buf.readUInt16LE(offset + 10);
+		const compressed = buf.readUInt32LE(offset + 20);
+		const uncompressed = buf.readUInt32LE(offset + 24);
+		const nameLen = buf.readUInt16LE(offset + 28);
+		const extraLen = buf.readUInt16LE(offset + 30);
+		const commentLen = buf.readUInt16LE(offset + 32);
+		const localOffset = buf.readUInt32LE(offset + 42);
+		const name = buf.subarray(offset + 46, offset + 46 + nameLen).toString("utf8");
+		out.push({
+			name,
+			method,
+			compressed,
+			uncompressed,
+			localOffset
+		});
+		offset += 46 + nameLen + extraLen + commentLen;
+	}
+	return out;
+}
+/**
+* 解压 ZIP → 条目列表（目录条目含尾部 /）。
+* @author ddj 2026年08月27号
+* @param buf zip 字节
+* @returns 条目（含内容）
+*/
+function unzip(buf) {
+	const metas = zipEntries(buf);
+	const out = [];
+	for (const meta of metas) {
+		const lh = meta.localOffset;
+		if (buf.readUInt32LE(lh) !== LHDR_SIG) throw new Error("ZIP 本地头损坏：" + meta.name);
+		const nameLen = buf.readUInt16LE(lh + 26);
+		const extraLen = buf.readUInt16LE(lh + 28);
+		const dataStart = lh + 30 + nameLen + extraLen;
+		const isDir = /\/$/.test(meta.name);
+		let data = Buffer.alloc(0);
+		if (!isDir && meta.compressed > 0) {
+			const raw = buf.subarray(dataStart, dataStart + meta.compressed);
+			data = meta.method === 8 ? Buffer.from(inflateRawSync(raw)) : meta.method === 0 ? Buffer.from(raw) : Buffer.alloc(0);
+		}
+		out.push({
+			path: meta.name,
+			data,
+			isDirectory: isDir
+		});
+	}
+	return out;
+}
+/** 定位 EOCD（从尾部向前扫，容忍尾部注释）。 */
+function findEocd(buf) {
+	const maxScan = Math.min(buf.length, 65557);
+	for (let i = buf.length - 22; i >= buf.length - maxScan; i--) {
+		if (i < 0) break;
+		if (buf.readUInt32LE(i) === EOCD_SIG) return i;
+	}
+	return -1;
+}
+//#endregion
+//#region src/lsp/extmgr.ts
+/**
+* dsh-vscode-mode host — VSIX 扩展管理器（extmgr）。
+* 管理 DSH 专属扩展目录（~/.dsh/dsh-vscode-mode/extensions/），支持：
+* 本地 .vsix 安装、Open VSX 市场搜索/下载安装、卸载、更新检测与安装。
+* 已装扩展作为 LSP provider 的"扩展源"（kind=extension），见 providers.ts。
+* 作者 ddj 2026-08-27
+*/
+const OPEN_VSX = "https://open-vsx.org";
+const META_FILE = "package.json";
+/** 当前平台（与 VSCode platform 命名对齐：win32-x64/darwin-arm64/linux-x64）。 */
+const PLATFORM = (() => {
+	if (process.platform === "win32") return process.arch === "arm64" ? "win32-arm64" : "win32-x64";
+	if (process.platform === "darwin") return process.arch === "arm64" ? "darwin-arm64" : "darwin-x64";
+	return process.arch === "arm64" ? "linux-arm64" : "linux-x64";
+})();
+/** DSH 专属扩展目录。 */
+function extensionsRoot(home = dshHome()) {
+	return join(home, PLUGIN_ID, "extensions");
+}
+/** 从 VSIX 字节里读 extension/package.json 清单。 */
+function vsixManifest(vsix) {
+	for (const entry of unzip(vsix)) if (entry.path === "extension/package.json" || entry.path === "extension\\package.json") return JSON.parse(entry.data.toString("utf8"));
+	throw new Error("VSIX 缺少 extension/package.json");
+}
+/**
+* 解包 VSIX 到目录（仅取 extension/ 子树，剥前缀；返回清单）。
+* @author ddj 2026年08月27号
+* @param vsix vsix 字节
+* @param dest 目标目录（已存在则先清空）
+* @returns 清单对象
+*/
+function unpackVsix(vsix, dest) {
+	rmSync(dest, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync(dest, { recursive: true });
+	let manifest = null;
+	for (const entry of unzip(vsix)) {
+		const rel = entry.path.replace(/^extension[\\/]/, "");
+		if (!rel || entry.path.startsWith("..")) continue;
+		const safe = rel.split(/[\\/]/).filter((part) => part && part !== ".." && part !== ".").join("/");
+		if (!safe) continue;
+		const target = join(dest, ...safe.split("/"));
+		if (entry.isDirectory) {
+			mkdirSync(target, { recursive: true });
+			continue;
+		}
+		mkdirSync(dirname(target), { recursive: true });
+		writeFileSync(target, entry.data);
+		if (rel === "package.json") manifest = JSON.parse(entry.data.toString("utf8"));
+	}
+	if (!manifest) throw new Error("VSIX 解包后缺少 package.json");
+	return manifest;
+}
+/** 扩展信息（清单 + 目录）。 */
+function extInfoOf(manifest, dir) {
+	const namespace = String(manifest.publisher ?? "unknown");
+	const name = String(manifest.name ?? "unknown");
+	const version = String(manifest.version ?? "0.0.0");
+	return {
+		id: namespace + "." + name,
+		namespace,
+		name,
+		version,
+		displayName: typeof manifest.displayName === "string" ? manifest.displayName : void 0,
+		description: typeof manifest.description === "string" ? manifest.description : void 0,
+		dirName: basename(dir),
+		dir
+	};
+}
+/** 安装本地 .vsix 文件（已存在同 id 则升级替换）。 */
+async function installVsixFile(vsixPath, home = dshHome()) {
+	return installVsixBuffer(readFileSync(vsixPath), home);
+}
+/** 安装 VSIX 字节（解包进 extensionsRoot；同名旧版本先清）。 */
+function installVsixBuffer(vsix, home = dshHome()) {
+	const info = extInfoOf(vsixManifest(vsix), "");
+	const target = join(extensionsRoot(home), info.id + "-" + info.version);
+	return extInfoOf(unpackVsix(vsix, target), target);
+}
+/** 扫描已装扩展目录。 */
+function listInstalled(home = dshHome()) {
+	const root = extensionsRoot(home);
+	if (!existsSync(root)) return [];
+	const out = [];
+	for (const dir of readdirSync(root)) {
+		const full = join(root, dir);
+		const meta = join(full, META_FILE);
+		if (!existsSync(meta)) continue;
+		try {
+			const manifest = JSON.parse(readFileSync(meta, "utf8"));
+			out.push(extInfoOf(manifest, full));
+		} catch (error) {}
+	}
+	return out;
+}
+/** 卸载扩展（按 id）。 */
+function uninstall(id, home = dshHome()) {
+	const target = listInstalled(home).find((e) => e.id === id)?.dir;
+	if (!target) return false;
+	rmSync(target, {
+		recursive: true,
+		force: true
+	});
+	return true;
+}
+/** Open VSX 单扩展元数据（latest + 下载 URL）。 */
+async function marketGet(namespace, name, version) {
+	const path = version ? namespace + "/" + name + "/" + version : namespace + "/" + name;
+	const res = await fetch(OPEN_VSX + "/api/" + path, { headers: { accept: "application/json" } });
+	if (!res.ok) return null;
+	return await res.json();
+}
+/** Open VSX 搜索。 */
+async function marketSearch(query, size = 12) {
+	const url = OPEN_VSX + "/api/-/search?query=" + encodeURIComponent(query) + "&size=" + size;
+	const res = await fetch(url, { headers: { accept: "application/json" } });
+	if (!res.ok) throw new Error("市场搜索失败：HTTP " + res.status);
+	return ((await res.json()).extensions ?? []).map((item) => ({
+		namespace: String(item.namespace ?? ""),
+		name: String(item.name ?? ""),
+		id: String(item.namespace ?? "") + "." + String(item.name ?? ""),
+		version: String(item.version ?? ""),
+		displayName: typeof item.displayName === "string" ? item.displayName : void 0,
+		description: typeof item.description === "string" ? item.description : void 0,
+		download: typeof item.files?.download === "string" ? item.files.download : void 0
+	}));
+}
+/** 平台匹配的 VSIX 下载 URL（探测平台变体，失败回退 API 默认）。 */
+async function resolveDownload(namespace, name, version) {
+	const candidate = OPEN_VSX + "/api/" + namespace + "/" + name + "/" + PLATFORM + "/" + version + "/file/" + namespace + "." + name + "-" + version + "@" + PLATFORM + ".vsix";
+	try {
+		if ((await fetch(candidate, { method: "HEAD" })).ok) return candidate;
+	} catch (error) {}
+	const download = ((await marketGet(namespace, name, version))?.files)?.download;
+	if (typeof download === "string") return download;
+	throw new Error("市场未提供 " + namespace + "." + name + "@" + version + " 的下载地址");
+}
+/** 从 Open VSX 安装/更新扩展。 */
+async function installFromMarket(namespace, name, version) {
+	const meta = await marketGet(namespace, name, version);
+	if (!meta) throw new Error("市场找不到 " + namespace + "." + name + (version ? "@" + version : ""));
+	const url = await resolveDownload(namespace, name, version ?? String(meta.version ?? ""));
+	const res = await fetch(url);
+	if (!res.ok) throw new Error("下载失败：HTTP " + res.status);
+	return installVsixBuffer(Buffer.from(await res.arrayBuffer()));
+}
+/** 更新已装扩展（对比市场最新版；返回 null 表示已最新）。 */
+async function updateExtension(id) {
+	const installed = listInstalled().find((e) => e.id === id);
+	if (!installed) throw new Error("扩展未安装：" + id);
+	const meta = await marketGet(installed.namespace, installed.name);
+	const latest = String(meta?.version ?? "");
+	if (!latest || latest === installed.version) return null;
+	return installFromMarket(installed.namespace, installed.name, latest);
+}
+//#endregion
+//#region src/lsp/providers.ts
+/**
+* dsh-vscode-mode host — 语言服务器 provider 解析。
+* 优先级：手动配置 > extmgr 扩展源(Phase 2 挂载) > 自动发现(~/.vscode/extensions、
+* ~/.dsh/dsh-vscode-mode/extensions、PATH)。产物 LspProviderSpec：{ ready, argv, cwd, reason }，
+* 供 manager 启动服务器。
+* 作者 ddj 2026-08-27
+*/
+/** 平台目录名（LuaLS/OmniSharp 的 server/bin/<平台>）。 */
+function platformServerDir(platform = process.platform) {
+	if (platform === "win32") return "Windows";
+	if (platform === "darwin") return "macOS";
+	return "Linux";
+}
+/** exe 后缀（Windows 为 .exe）。 */
+function exeSuffix(platform = process.platform) {
+	return platform === "win32" ? ".exe" : "";
+}
+/** 列出目录下匹配前缀的子目录（如 ~/.vscode/extensions/sumneko.lua-*）。 */
+function listMatchingDirs(dir, prefix) {
+	if (!existsSync(dir)) return [];
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch (error) {
+		return [];
+	}
+	return entries.filter((e) => e.isDirectory() && e.name.startsWith(prefix)).map((e) => join(dir, e.name));
+}
+/** VSCode 扩展目录（~/.vscode/extensions、~/.vscode-server/extensions + extmgr 目录；无则空数组）。 */
+function vscodeExtensionsDirs(home = dshHome()) {
+	const userHome = homedir();
+	return [
+		join(userHome, ".vscode", "extensions"),
+		join(userHome, ".vscode-server", "extensions"),
+		extensionsRoot(home)
+	].filter((dir) => existsSync(dir));
+}
+/** 扩展源 provider 注册表：languageId → 启动参数。 */
+const extProviders = /* @__PURE__ */ new Map();
+/** 取扩展源 provider spec（未注册返回 null）。 */
+function extensionProviderFor(languageId) {
+	const p = extProviders.get(languageId);
+	if (!p || !p.argv.length) return null;
+	return {
+		languageId,
+		kind: "extension",
+		argv: p.argv,
+		cwd: p.cwd,
+		ready: true
+	};
+}
+/** PATH 中查找可执行文件（不含扩展名校验，交由 spawn 报错）。 */
+function findInPath(name) {
+	const pathEnv = process.env.PATH ?? "";
+	const exts = process.platform === "win32" ? [
+		"",
+		".exe",
+		".cmd",
+		".bat"
+	] : [""];
+	for (const dir of pathEnv.split(sep === "\\" ? ";" : ":")) {
+		if (!dir) continue;
+		for (const ext of exts) {
+			const candidate = join(dir, name + ext);
+			if (existsSync(candidate)) return candidate;
+		}
+	}
+	return null;
+}
+/** 查找 dotnet（PATH + 常见安装路径）。 */
+function findDotnet() {
+	const inPath = findInPath("dotnet");
+	if (inPath) return inPath;
+	for (const c of ["C:/Program Files/dotnet/dotnet.exe", "C:/Program Files (x86)/dotnet/dotnet.exe"]) if (existsSync(c)) return c;
+	return null;
+}
+/** LuaLS 自动发现候选（VSCode 扩展目录 + extmgr 目录下 sumneko.lua-* 的 server/bin 可执行）。 */
+function candidateLuaServers(home = dshHome()) {
+	const plat = platformServerDir();
+	const suffix = exeSuffix();
+	const out = [];
+	for (const dir of vscodeExtensionsDirs(home)) for (const extDir of listMatchingDirs(dir, "sumneko.lua-")) {
+		const binDir = join(extDir, "server", "bin");
+		const binName = "lua-language-server" + suffix;
+		const bin = existsSync(join(binDir, binName)) ? join(binDir, binName) : join(binDir, plat, binName);
+		if (existsSync(bin) && !out.includes(bin)) out.push(bin);
+	}
+	return out;
+}
+/** C# 自动发现候选：Roslyn dll（需 dotnet）或 OmniSharp 可执行。 */
+function candidateCSharpServers(home = dshHome()) {
+	const out = {};
+	for (const dir of vscodeExtensionsDirs(home)) for (const extDir of listMatchingDirs(dir, "ms-dotnettools.csharp-")) {
+		const roslyn = join(extDir, ".roslyn", "Microsoft.CodeAnalysis.LanguageServer.dll");
+		if (!out.roslynDll && existsSync(roslyn)) out.roslynDll = roslyn;
+		const omni = join(extDir, ".omnisharp", "OmniSharp" + exeSuffix());
+		if (!out.omnisharpExe && existsSync(omni)) out.omnisharpExe = omni;
+	}
+	const dotnet = findDotnet();
+	if (dotnet) out.dotnet = dotnet;
+	return out;
+}
+/**
+* 手动配置归一化：path 指向可执行文件/目录，command 为可执行名（PATH 解析）。
+* 未配置时返回空 reason（由各 resolve 兜底输出语言相关安装指引文案）。
+* @author ddj 2026年08月27号
+*/
+function manualSpec(manual) {
+	if (!manual) return {
+		argv: [],
+		ready: false
+	};
+	const pathValue = typeof manual.path === "string" && manual.path.trim() ? manual.path.trim() : "";
+	const commandValue = typeof manual.command === "string" && manual.command.trim() ? manual.command.trim() : "";
+	if (!pathValue && !commandValue) return {
+		argv: [],
+		ready: false
+	};
+	if (pathValue) {
+		if (!existsSync(pathValue)) return {
+			argv: [],
+			ready: false,
+			reason: "路径不存在：" + pathValue
+		};
+		return {
+			argv: [pathValue],
+			ready: true
+		};
+	}
+	const found = findInPath(commandValue);
+	if (!found) return {
+		argv: [],
+		ready: false,
+		reason: "PATH 中找不到命令：" + commandValue
+	};
+	return {
+		argv: [found],
+		ready: true
+	};
+}
+/**
+* 解析 Lua provider（优先级：手动 > 扩展源 > 自动发现）。
+* @author ddj 2026年08月27号
+* @param manual 手动配置
+* @param home DSH home（缺省真实；测试可注入临时目录）
+* @returns provider 规格
+*/
+function resolveLuaProvider(manual, home = dshHome()) {
+	const base = { languageId: "lua" };
+	const manualResolved = manualSpec(manual);
+	if (manualResolved.ready) return {
+		...base,
+		kind: "manual",
+		argv: manualResolved.argv,
+		cwd: manualResolved.cwd,
+		ready: true
+	};
+	const ext = extensionProviderFor("lua");
+	if (ext) return ext;
+	const candidates = candidateLuaServers(home);
+	if (candidates.length) return {
+		...base,
+		kind: "discover",
+		argv: [candidates[0]],
+		cwd: void 0,
+		ready: true
+	};
+	const inPath = findInPath("lua-language-server" + exeSuffix());
+	if (inPath) return {
+		...base,
+		kind: "discover",
+		argv: [inPath],
+		ready: true
+	};
+	return {
+		...base,
+		kind: "none",
+		argv: [],
+		ready: false,
+		reason: manualResolved.reason ?? "未发现 lua-language-server（可安装 LuaLS 或手动指定路径）"
+	};
+}
+/**
+* 解析 C# provider（优先级：手动 > 扩展源 > 自动发现；需 dotnet + Roslyn dll；或 OmniSharp）。
+* @author ddj 2026年08月27号
+* @param manual 手动配置
+* @param home DSH home（缺省真实；测试可注入临时目录）
+* @returns provider 规格
+*/
+function resolveCSharpProvider(manual, home = dshHome()) {
+	const base = { languageId: "csharp" };
+	const manualResolved = manualSpec(manual);
+	if (manualResolved.ready) return {
+		...base,
+		kind: "manual",
+		argv: manualResolved.argv,
+		cwd: manualResolved.cwd,
+		ready: true
+	};
+	const ext = extensionProviderFor("csharp");
+	if (ext) return ext;
+	const discovered = candidateCSharpServers(home);
+	if (discovered.roslynDll && discovered.dotnet) return {
+		...base,
+		kind: "discover",
+		argv: [
+			discovered.dotnet,
+			discovered.roslynDll,
+			"--stdio"
+		],
+		ready: true
+	};
+	if (discovered.omnisharpExe) return {
+		...base,
+		kind: "discover",
+		argv: [discovered.omnisharpExe, "--stdio"],
+		ready: true
+	};
+	const reasons = [];
+	if (!discovered.dotnet) reasons.push("未找到 dotnet");
+	if (!discovered.roslynDll && !discovered.omnisharpExe) reasons.push("未发现 ms-dotnettools.csharp 扩展");
+	return {
+		...base,
+		kind: "none",
+		argv: [],
+		ready: false,
+		reason: reasons.join("；") + "（可手动指定 Roslyn/OmniSharp 入口）"
+	};
+}
+const PROVIDER_RESOLVERS = {
+	lua: resolveLuaProvider,
+	csharp: resolveCSharpProvider
+};
+//#endregion
+//#region src/lsp/config.ts
+const LSP_SETTINGS_NS = "dsh-vscode-mode.languageServers";
+const LSP_LANGUAGES = ["lua", "csharp"];
+function sanitizeLang(raw) {
+	if (!raw || typeof raw !== "object") return void 0;
+	const obj = raw;
+	const out = {};
+	if (typeof obj.enabled === "boolean") out.enabled = obj.enabled;
+	if (typeof obj.command === "string") out.command = obj.command;
+	if (typeof obj.path === "string") out.path = obj.path;
+	return out;
+}
+/** 从插件组合配置读取。 */
+function configFromPlugin(config) {
+	const raw = config?.languageServers;
+	if (!raw || typeof raw !== "object") return {};
+	const out = {};
+	for (const lang of LSP_LANGUAGES) {
+		const v = sanitizeLang(raw[lang]);
+		if (v) out[lang] = v;
+	}
+	return out;
+}
+/** 从 settings 描述符读取（无 settings 服务/无该 section → {}）。 */
+function configFromSettings(ctx) {
+	try {
+		const value = (ctx.get("settings")?.describe?.({ redactSecrets: true })?.find((item) => item.ns === LSP_SETTINGS_NS))?.value;
+		if (!value || typeof value !== "object") return {};
+		const out = {};
+		for (const lang of LSP_LANGUAGES) {
+			const v = sanitizeLang(value[lang]);
+			if (v) out[lang] = v;
+		}
+		return out;
+	} catch (error) {
+		return {};
+	}
+}
+/** 合并配置：settings 覆盖插件配置。 */
+function mergeConfig(a, b) {
+	const out = { ...a };
+	for (const lang of LSP_LANGUAGES) {
+		const av = a[lang];
+		const bv = b[lang];
+		if (bv) out[lang] = {
+			...av,
+			...bv
+		};
+		else if (av) out[lang] = av;
+	}
+	return out;
+}
+/**
+* 解析某语言的 provider spec（合并配置后）。
+* @author ddj 2026年08月27号
+* @param ctx DSH 上下文
+* @param pluginConfig 插件组合配置
+* @param languageId 语言 id
+* @returns provider 规格
+*/
+function resolveProviderSpec(ctx, pluginConfig, languageId) {
+	const resolver = PROVIDER_RESOLVERS[languageId];
+	if (!resolver) return {
+		languageId,
+		kind: "none",
+		argv: [],
+		ready: false,
+		reason: "不支持的语言：" + languageId
+	};
+	const lang = mergeConfig(configFromPlugin(pluginConfig), configFromSettings(ctx))[languageId];
+	if (lang && lang.enabled === false) return {
+		languageId,
+		kind: "none",
+		argv: [],
+		ready: false,
+		reason: "已在设置中禁用"
+	};
+	return resolver({
+		command: lang?.command,
+		path: lang?.path
+	});
+}
+/** 语言 → 扩展名（供客户端判断是否触发 LSP）。 */
+function langOfPath(path) {
+	const base = String(path || "").split(/[\\/]/).pop() || "";
+	const dot = base.lastIndexOf(".");
+	if (dot <= 0) return null;
+	const ext = base.slice(dot + 1).toLowerCase();
+	for (const [lang, exts] of Object.entries({
+		lua: ["lua"],
+		csharp: ["cs", "csx"]
+	})) if (exts.includes(ext)) return lang;
+	return null;
+}
+//#endregion
+//#region src/lsp/rpc.ts
+/**
+* 打开文档跟踪：openDocs(docKey→sessionId) + rootLangRefs 计数 + sessionAcquired 归属。
+* 保证 manager 的 acquire/release 一一配对（多会话共享同一 root|lang 也平衡）。
+*/
+function createDocTracker() {
+	const openDocs = /* @__PURE__ */ new Map();
+	const rootLangRefs = /* @__PURE__ */ new Map();
+	const sessionDocs = /* @__PURE__ */ new Map();
+	const keyOf = (root, lang, path) => root + "|" + lang + "|" + path;
+	const rootLangOf = (docKey) => docKey.slice(0, docKey.lastIndexOf("|"));
+	const rememberDoc = (sessionId, docKey) => {
+		const docs = sessionDocs.get(sessionId) ?? /* @__PURE__ */ new Set();
+		docs.add(docKey);
+		sessionDocs.set(sessionId, docs);
+	};
+	const forgetDoc = (sessionId, docKey) => {
+		const docs = sessionDocs.get(sessionId);
+		docs?.delete(docKey);
+		if (docs?.size === 0) sessionDocs.delete(sessionId);
+	};
+	const releaseRef = (rl) => {
+		const next = (rootLangRefs.get(rl) ?? 1) - 1;
+		if (next <= 0) {
+			rootLangRefs.delete(rl);
+			return true;
+		}
+		rootLangRefs.set(rl, next);
+		return false;
+	};
+	return {
+		/** 记录文档打开；同一文档可由多个会话打开，但每个会话只计一次。 */
+		open(root, lang, path, sessionId) {
+			const docKey = keyOf(root, lang, path);
+			const owners = openDocs.get(docKey) ?? /* @__PURE__ */ new Set();
+			if (owners.has(sessionId)) return false;
+			owners.add(sessionId);
+			openDocs.set(docKey, owners);
+			rememberDoc(sessionId, docKey);
+			const rl = root + "|" + lang;
+			const count = rootLangRefs.get(rl) ?? 0;
+			rootLangRefs.set(rl, count + 1);
+			return count === 0;
+		},
+		/** 记录文档关闭；返回 true 表示 root|lang 已无文档（应 release）。 */
+		close(root, lang, path, sessionId) {
+			const docKey = keyOf(root, lang, path);
+			const owners = openDocs.get(docKey);
+			if (!owners?.has(sessionId)) return false;
+			owners.delete(sessionId);
+			if (owners.size === 0) openDocs.delete(docKey);
+			forgetDoc(sessionId, docKey);
+			return releaseRef(root + "|" + lang);
+		},
+		/** 关闭某会话全部文档；返回全局引用归零、需要 release 的 root|lang。 */
+		closeSession(sessionId) {
+			const docs = sessionDocs.get(sessionId);
+			if (!docs) return [];
+			const toRelease = /* @__PURE__ */ new Set();
+			for (const docKey of docs) {
+				const owners = openDocs.get(docKey);
+				owners?.delete(sessionId);
+				if (owners?.size === 0) openDocs.delete(docKey);
+				if (releaseRef(rootLangOf(docKey))) toRelease.add(rootLangOf(docKey));
+			}
+			sessionDocs.delete(sessionId);
+			return [...toRelease];
+		}
+	};
+}
+/**
+* 构造 edrv.lsp.* handlers（一次性创建，tracker 状态跨请求保留）。
+* @author ddj 2026年08月27号
+* @param deps 依赖（ctx/pluginConfig/manager）
+* @returns { handlers, disposeSession } handlers 为局部 map，disposeSession 供 session/disposed 清理
+*/
+function createLspRpc(deps) {
+	const { ctx, pluginConfig, manager } = deps;
+	const tracker = createDocTracker();
+	/** 解析会话与工作区根（失败 → null + error）。 */
+	const rootOf = async (sessionId) => {
+		const session = sessionOf(ctx, sessionId);
+		if (!session) return { err: "会话不存在" };
+		if (!cwdOf(session)) return { err: "会话无工作区" };
+		try {
+			return {
+				root: await searchRoot(ctx, session),
+				sessionId: typeof session.id === "string" && session.id ? session.id : sessionId ?? ""
+			};
+		} catch (error) {
+			return { err: String(error) };
+		}
+	};
+	const acquireServer = (root, lang) => manager.acquire(root, lang, (languageId) => resolveProviderSpec(ctx, pluginConfig, languageId));
+	const serverOf = (root, lang) => manager.peek(root, lang);
+	const rootLocations = (locations, root) => locations.map((location) => ({
+		...location,
+		root
+	}));
+	const disposeSession = (sessionId) => {
+		for (const rl of tracker.closeSession(sessionId)) {
+			const sep = rl.lastIndexOf("|");
+			manager.release(rl.slice(0, sep), rl.slice(sep + 1));
+		}
+	};
+	return {
+		handlers: {
+			"edrv.lsp.status": async (args) => {
+				if (!args.sessionId) return {
+					ok: true,
+					servers: manager.statusAll()
+				};
+				const sc = await rootOf(args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				return {
+					ok: true,
+					servers: manager.statusAll().filter((status) => status.root === sc.root)
+				};
+			},
+			"edrv.lsp.configGet": async () => {
+				const settings = configFromSettings(ctx);
+				const plugin = configFromPlugin(pluginConfig);
+				const merged = { ...plugin };
+				for (const lang of Object.keys(settings)) merged[lang] = {
+					...plugin[lang],
+					...settings[lang]
+				};
+				return {
+					ok: true,
+					config: merged
+				};
+			},
+			"edrv.lsp.configUpdate": async (args) => {
+				const lang = args.languageId;
+				if (!lang || !resolveProviderSpec(ctx, pluginConfig, lang).languageId) return {
+					ok: false,
+					error: "不支持的语言：" + lang
+				};
+				const current = configFromSettings(ctx);
+				const target = {
+					...current,
+					[lang]: { ...current[lang] ?? {} }
+				}[lang];
+				if (args.enabled !== void 0) target.enabled = args.enabled;
+				if (args.command !== void 0) target.command = args.command || void 0;
+				if (args.path !== void 0) target.path = args.path || void 0;
+				try {
+					const settings = ctx.get("settings");
+					if (!settings?.update) return {
+						ok: false,
+						error: "设置服务不可用"
+					};
+					await settings.update(LSP_SETTINGS_NS, { [lang]: target });
+					const stored = (settings.describe?.({ redactSecrets: true })?.find((item) => item.ns === LSP_SETTINGS_NS))?.value;
+					return {
+						ok: true,
+						config: {
+							...configFromPlugin(pluginConfig),
+							...stored
+						}
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "配置保存失败：" + String(error)
+					};
+				}
+			},
+			"edrv.lsp.sync": async (args) => {
+				const lang = langOfPath(args.path);
+				if (!lang) return { ok: true };
+				const sc = await rootOf(args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const server = tracker.open(sc.root, lang, args.path, sc.sessionId) ? acquireServer(sc.root, lang) : serverOf(sc.root, lang);
+				if (!server) return {
+					ok: false,
+					error: "语言服务器未注册"
+				};
+				server.sync(args.path, args.text, args.version);
+				return { ok: true };
+			},
+			"edrv.lsp.close": async (args) => {
+				const lang = langOfPath(args.path);
+				if (!lang) return { ok: true };
+				const sc = await rootOf(args.sessionId);
+				if ("err" in sc) return { ok: true };
+				if (tracker.close(sc.root, lang, args.path, sc.sessionId)) manager.release(sc.root, lang);
+				return { ok: true };
+			},
+			"edrv.lsp.definition": async (args) => {
+				const lang = langOfPath(args.path);
+				if (!lang) return {
+					ok: true,
+					locations: []
+				};
+				const sc = await rootOf(args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				try {
+					const server = serverOf(sc.root, lang);
+					if (!server) return {
+						ok: true,
+						locations: []
+					};
+					const locations = await server.definition(args.path, args.position.line, args.position.character);
+					const rooted = rootLocations(locations, sc.root);
+					const truncated = rooted.length > 500;
+					return {
+						ok: true,
+						locations: truncated ? rooted.slice(0, 500) : rooted,
+						truncated: truncated || void 0
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "LSP 定义查询失败：" + String(error)
+					};
+				}
+			},
+			"edrv.lsp.references": async (args) => {
+				const lang = langOfPath(args.path);
+				if (!lang) return {
+					ok: true,
+					locations: []
+				};
+				const sc = await rootOf(args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				try {
+					const server = serverOf(sc.root, lang);
+					if (!server) return {
+						ok: true,
+						locations: []
+					};
+					const locations = await server.references(args.path, args.position.line, args.position.character, args.includeDeclaration !== false);
+					const rooted = rootLocations(locations, sc.root);
+					const truncated = rooted.length > 500;
+					return {
+						ok: true,
+						locations: truncated ? rooted.slice(0, 500) : rooted,
+						truncated: truncated || void 0
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "LSP 引用查询失败：" + String(error)
+					};
+				}
+			},
+			"edrv.lsp.documentSymbol": async (args) => {
+				const lang = langOfPath(args.path);
+				if (!lang) return {
+					ok: true,
+					symbols: []
+				};
+				const sc = await rootOf(args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				try {
+					const server = serverOf(sc.root, lang);
+					if (!server) return {
+						ok: true,
+						symbols: []
+					};
+					return {
+						ok: true,
+						symbols: await server.documentSymbol(args.path)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "LSP 大纲查询失败：" + String(error)
+					};
+				}
+			},
+			"edrv.lsp.workspaceSymbol": async (args) => {
+				const sc = await rootOf(args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const out = { symbols: [] };
+				for (const lang of ["lua", "csharp"]) {
+					const existing = serverOf(sc.root, lang);
+					if (!existing) continue;
+					try {
+						const symbols = await existing.workspaceSymbol(args.query);
+						if (symbols.length) out.symbols.push(...symbols);
+					} catch (error) {}
+				}
+				const truncated = out.symbols.length > 500;
+				return {
+					ok: true,
+					symbols: out.symbols.slice(0, 500),
+					truncated: truncated || void 0
+				};
+			},
+			"edrv.lsp.hover": async (args) => {
+				const lang = langOfPath(args.path);
+				if (!lang) return {
+					ok: true,
+					hover: void 0
+				};
+				const sc = await rootOf(args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				try {
+					const server = serverOf(sc.root, lang);
+					if (!server) return {
+						ok: true,
+						hover: void 0
+					};
+					return {
+						ok: true,
+						hover: await server.hover(args.path, args.position.line, args.position.character) ?? void 0
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "LSP hover 查询失败：" + String(error)
+					};
+				}
+			},
+			"edrv.lsp.ext.list": async () => ({
+				ok: true,
+				extensions: listInstalled()
+			}),
+			"edrv.lsp.ext.market": async (args) => {
+				try {
+					return {
+						ok: true,
+						extensions: await marketSearch(args.query, args.size ?? 12)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "市场搜索失败：" + String(error)
+					};
+				}
+			},
+			"edrv.lsp.ext.install": async (args) => {
+				try {
+					let info;
+					if (args.vsixPath) info = await installVsixFile(args.vsixPath);
+					else if (args.namespace && args.name) info = await installFromMarket(args.namespace, args.name, args.version);
+					else return {
+						ok: false,
+						error: "缺少安装源（vsixPath 或 namespace+name）"
+					};
+					return {
+						ok: true,
+						extension: info
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "安装失败：" + String(error)
+					};
+				}
+			},
+			"edrv.lsp.ext.uninstall": async (args) => {
+				return uninstall(args.id) ? { ok: true } : {
+					ok: false,
+					error: "扩展未安装：" + args.id
+				};
+			},
+			"edrv.lsp.ext.update": async (args) => {
+				try {
+					const updated = await updateExtension(args.id);
+					if (!updated) {
+						const current = listInstalled().find((e) => e.id === args.id);
+						return current ? {
+							ok: true,
+							extension: current,
+							updated: false
+						} : {
+							ok: false,
+							error: "扩展未安装：" + args.id
+						};
+					}
+					return {
+						ok: true,
+						extension: updated,
+						updated: true
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "更新失败：" + String(error)
+					};
+				}
+			},
+			"edrv.lsp.ext.updates": async () => {
+				try {
+					const updates = [];
+					for (const ext of listInstalled()) {
+						const meta = await marketGet(ext.namespace, ext.name);
+						const latest = String(meta?.version ?? "");
+						if (latest && latest !== ext.version) updates.push({
+							id: ext.id,
+							current: ext.version,
+							latest,
+							displayName: ext.displayName
+						});
+					}
+					return {
+						ok: true,
+						updates
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "检查更新失败：" + String(error)
+					};
+				}
+			}
+		},
+		disposeSession
+	};
+}
+//#endregion
+//#region src/lsp/settings.ts
+/**
+* 安装 LSP 设置 section。
+* @author ddj 2026年08月27号
+* @param ctx DSH 上下文
+* @param entry 初始配置
+* @returns 是否成功安装
+*/
+async function installLspSettingsSection(ctx, entry) {
+	const deps = await loadSettingsDeps();
+	if (!deps) return false;
+	try {
+		const z = deps.z;
+		const langShape = {};
+		for (const lang of LSP_LANGUAGES) langShape[lang] = z.object({
+			enabled: z.boolean(),
+			command: z.string(),
+			path: z.string()
+		}).default({});
+		const schema = z.object(langShape).default({});
+		deps.installSettingsSection(ctx, LSP_SETTINGS_NS, schema, entry, {
+			setSource: () => {},
+			onChange: () => {}
+		});
+		return true;
+	} catch (error) {
+		console.error("[dsh-vscode-mode] LSP 设置 section 安装失败：" + String(error));
+		return false;
+	}
+}
+//#endregion
+//#region src/index.ts
+/**
+* @dsh-external 生态 → dsh-vscode-mode：DSH 上的类 VSCode 编码体验（Host 半入口）。
+* 职责：装配 capture（tools/result 捕获 edit/write 差异）、RPC 分发（edrv.* / mcp.* / vscode.* / compat）、
+*       webServer 路由（/edrv/rpc、/edrv/assets/*、/edrv/vendor/*）、工作区旁车持久化、
+*       兼容层装配（依赖守卫 + 重复装配自诊断 + 启动日志兼容性报告）。
+* 结构：shared/（双面契约） + model/store/capture/workspace/revert/registry/rpc/routes/compat（host 模块）。
+* 作者 ddj 2026-08-20
+*/
+const name = "dsh-vscode-mode";
+const inject = [
+	"sessions",
+	"fs",
+	"webServer",
+	"loader",
+	"tools",
+	"workspaceRegistry",
+	"agents"
+];
+/**
+* 装配插件：挂事件监听、注册路由、安装兼容层。
+* @author ddj 2026年08月20号
+* @param ctx DSH 上下文（sessions/fs/webServer 由 inject 提供；sandboxPolicy/subprocess 惰性获取）
+* @param config 插件配置（可选 imageDir 覆盖图标目录）
+*/
+function apply(ctx, config) {
+	const registry = /* @__PURE__ */ new Map();
+	const searcher = newSearcher(ctx);
+	const contentSearcher = newContentSearcher(ctx);
+	/** LSP 服务器管理器（语言智能：跳转/引用/大纲）。 */
+	const lspManager = createLspManager((line) => ctx.logger?.debug?.("[" + name + "] " + line));
+	/** 兼容性警告收集（route 护栏等写入，启动日志一并输出）。 */
+	const warnings = [];
+	setupOpenSettings(ctx, config, () => {});
+	installLspSettingsSection(ctx, {});
+	/** LSP RPC 与会话清理（一次性创建，tracker 状态跨请求保留）。 */
+	const lspRpc = createLspRpc({
+		ctx,
+		pluginConfig: config,
+		manager: lspManager
+	});
+	const lspHandlers = lspRpc.handlers;
+	ctx.on("tools/result", (exec, result) => {
+		captureToolResult(ctx, registry, exec, result);
+	});
+	ctx.on("session/disposed", (session) => {
+		const cwd = cwdOf(session);
+		if (cwd) {
+			registry.delete(cwd);
+			dropFileIndex(cwd);
+			searcher.dispose(cwd);
+			contentSearcher.dispose(cwd);
+			disposeIndex(cwd);
+		}
+		const sid = session?.id;
+		if (typeof sid === "string") lspRpc.disposeSession(sid);
+	});
+	registerRoutes(ctx, config, (method, args) => handleRpc(ctx, registry, method, args, searcher, contentSearcher, lspHandlers), (warning) => warnings.push(warning));
+	installIsolation(ctx);
+	sweepTreeCache();
+	logCompatSummary(ctx, warnings);
+	ctx.effect(() => () => {
+		lspManager.disposeAll().catch(() => {});
+		disposeAllServers();
+	});
+	ctx.logger?.info?.("[" + name + "] 编辑差异审查已装配（/edrv/rpc 路由就绪，项目 MCP 隔离已启用，语言服务器 LSP 已接入）");
 }
 /**
 * 异步输出兼容性报告摘要（含重复装配/路由冲突自诊断）。