dsh-vscode-mode 0.21.4 → 0.23.0

package/lib/index.js

@@ -43,7 +43,7 @@ const RESOURCE_TOOLS = /* @__PURE__ */ new Set([
 * @param path Workspace or agent cwd.
 * @returns Comparable path with a stable root representation.
 */
-function normalizePath(path) {
+function normalizePath$1(path) {
 	const raw = String(path ?? "").replace(/\\/g, "/");
 	const windows = /^[a-z]:/i.test(raw) || raw.startsWith("//");
 	const value = (windows ? win32.normalize(raw) : posix.normalize(raw)).replace(/\\/g, "/").replace(/\/+$/, "") || "/";
@@ -58,12 +58,12 @@ function normalizePath(path) {
 */
 function matchWorkspace(cwd, paths) {
 	if (!cwd) return void 0;
-	const target = normalizePath(cwd);
+	const target = normalizePath$1(cwd);
 	const matches = paths.filter((path) => {
-		const root = normalizePath(path);
+		const root = normalizePath$1(path);
 		return target === root || target.startsWith(root === "/" ? root : root + "/");
 	});
-	matches.sort((a, b) => normalizePath(b).length - normalizePath(a).length);
+	matches.sort((a, b) => normalizePath$1(b).length - normalizePath$1(a).length);
 	return matches[0];
 }
 const isProjectEntry = isProjectEntryId;
@@ -684,6 +684,15 @@ function debugLogFile(cwd, home = dshHome()) {
 function archiveDbFile(cwd, home = dshHome()) {
 	return join(home, PLUGIN_ID, "data", "archive", hashOf(cwd) + ".sqlite");
 }
+/**
+* 快捷菜单配置文本（用户数据，不受缓存清理预算约束，跨工作区共享一份）。
+* @author ddj 2026年10月30号
+* @param home DSH home（测试可注入）
+* @returns 快捷菜单配置绝对路径
+*/
+function quickMenuFile(home = dshHome()) {
+	return join(home, PLUGIN_ID, "data", "quick-menu.json");
+}
 /** 插件包 assets 目录（import.meta.url 派生；config.imageDir 可覆盖，见 imageDirOf）。 */
 function assetsDirOf(moduleUrl) {
 	return join(dirname(fileURLToPath(moduleUrl)), "..", "assets");
@@ -2488,6 +2497,26 @@ async function resolveTargetIn(ctx, cwd, path) {
 	return ctx.get("fs").resolve(path, cwd ? { cwd } : {});
 }
 /**
+* 把解析结果还原成宿主路径字符串。
+* 官方 provider 的 resolve 返回不透明 FsTarget，而多数调用点按字符串使用；
+* 直接把对象当路径传下去会落进 SQL 绑定或 path.resolve，报出与真实原因无关的错误。
+* @author ddj 2026年10月30号
+* @param ctx DSH 上下文
+* @param target resolve 的返回值：宿主路径字符串或 FsTarget
+* @returns 宿主路径字符串；无法还原时返回空串
+*/
+function targetPathOf(ctx, target) {
+	if (typeof target === "string") return target;
+	const fs = ctx.get("fs");
+	if (typeof fs?.processPath !== "function") return "";
+	try {
+		const resolved = fs.processPath(target);
+		return typeof resolved === "string" && resolved !== "[object Object]" ? resolved : "";
+	} catch {
+		return "";
+	}
+}
+/**
 * 严格读取旧 sidecar：仅确认确实不存在时才允许从空记录迁移。
 * @author ddj 2026年09月30号
 * @param ctx DSH 上下文
@@ -5041,7 +5070,7 @@ function checkTarget(dir, target) {
 * @param path 安装入口或备份入口
 * @throws 删除失败
 */
-function removeEntry(path) {
+function removeEntry$1(path) {
 	const info = lstatSync(path, { throwIfNoEntry: false });
 	if (!info) return;
 	if (info.isSymbolicLink()) unlinkSync(path);
@@ -5098,7 +5127,7 @@ function backupProfile(dir) {
 function restoreProfile(saved) {
 	const failures = [];
 	try {
-		removeEntry(saved.link);
+		removeEntry$1(saved.link);
 		if (saved.hadLink) renameSync(saved.savedLink, saved.link);
 	} catch (error) {
 		failures.push(String(error));
@@ -5140,7 +5169,7 @@ async function switchProfile(ctx, dir, enabled, target) {
 		throw error;
 	}
 	try {
-		removeEntry(saved.savedLink);
+		removeEntry$1(saved.savedLink);
 		rmSync(saved.dir, {
 			recursive: true,
 			force: true
@@ -5398,7 +5427,7 @@ const SKILL_PREFIXES = ["dsh-vscodemode-"];
 /** 技能发现来源标签（skill-explorer 归入 "System bundled" 组）。 */
 const SKILL_SOURCE = "bundled";
 /** 目录式技能的文件名。 */
-const SKILL_FILE = "SKILL.md";
+const SKILL_FILE$1 = "SKILL.md";
 /** DSH 技能名语法（与 @deepseek-ai/dsh-skill 的 SKILL_NAME 一致：下划线非法）。 */
 const SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 /** 不受支持的遗留字段 → 规范字段（官方同样拒绝，避免写错键位却静默无效果）。 */
@@ -5576,7 +5605,7 @@ function hasGroupPrefix(name) {
 * @returns 候选文件绝对路径；不构成技能时返回 undefined
 */
 function skillFileOf(dir, entry) {
-	if (entry.isDirectory()) return join(dir, entry.name, SKILL_FILE);
+	if (entry.isDirectory()) return join(dir, entry.name, SKILL_FILE$1);
 	if (entry.isFile() && entry.name.endsWith(".md")) return join(dir, entry.name);
 }
 /**
@@ -7340,10 +7369,19 @@ async function captureToolResult(ctx, registry, exec, result) {
 }
 //#endregion
 //#region src/shared/lineEndings.ts
+/** Shared logical-line comparison; never rewrites stored patch or file bytes. @author ddj 2026年10月28号 */
+/** @public @author ddj 2026年10月28号 @param text Decoded text. @returns Text without one leading Unicode BOM. */
+function stripBom(text) {
+	return text.replace(/^\uFEFF/, "");
+}
 /** @public @author ddj 2026年10月28号 @param line Physical line. @returns Line without one terminal CRLF, CR or LF; other whitespace stays intact. */
 function logicalLine(line) {
 	return line.replace(/(?:\r\n|\r|\n)$/, "");
 }
+/** @public @author ddj 2026年10月28号 @param text Decoded file text. @returns Logical lines excluding BOM, retaining the final empty line after a terminator. */
+function logicalLines(text) {
+	return stripBom(text).split(/\r\n|\r|\n/);
+}
 //#endregion
 //#region src/shared/reviewRegions.ts
 /** @public @author ddj 2026年10月27号 @param diff Immutable official patch. @returns Contiguous change runs with stable source-coordinate identities. */
@@ -7551,7 +7589,7 @@ function captureState(cwd, gap, state) {
     DO UPDATE SET state=excluded.state,error=excluded.error WHERE review_capture.state<>'complete'`).run(gap.sessionId, gap.turn, gap.seq, state, gap.error);
 }
 /** @private @author ddj 2026年10月26号 @param row File and state. @returns Wire-safe summary without hunks. */
-function itemOf(row) {
+function itemOf$1(row) {
 	const summary = JSON.parse(String(row.summary));
 	const kind = row.kind ?? JSON.parse(String(row.diff)).kind;
 	return {
@@ -7595,7 +7633,7 @@ function reviewPage(cwd, cursor = 0, history = false, path) {
 			})),
 			coveredPaths: covered.map((row) => String(row.identity))
 		},
-		items: rows.slice(0, 50).map(itemOf),
+		items: rows.slice(0, 50).map(itemOf$1),
 		pending: Number(count.n),
 		nextCursor: rows.length > 50 ? offset + 50 : null,
 		gaps: [...gaps.map((row) => ({
@@ -7613,6 +7651,7 @@ function reviewPage(cwd, cursor = 0, history = false, path) {
 }
 /** @public @author ddj 2026年10月26号 @param cwd Migrated workspace. @param path Legacy write target. @returns Whether any official version owns the file, including decided history. */
 function hasOfficial(cwd, path) {
+	if (typeof path !== "string") return false;
 	const db = dbFor(cwd);
 	if (!db.prepare("SELECT 1 FROM sqlite_master WHERE name='review_files' AND type='table'").get()) return false;
 	if (/^[A-Za-z]:[\\/]/.test(path)) return !!db.prepare("SELECT 1 FROM review_files WHERE lower(replace(identity,char(92),'/'))=? LIMIT 1").get(path.replace(/\\/g, "/").toLowerCase());
@@ -7630,7 +7669,7 @@ function reviewDetail(cwd, id) {
 	const pending = row.current === 1 && row.decision === "pending";
 	const undo = pending && !!evidence && diff.kind === "text" && diff.before && diff.after && !diff.coarse;
 	return {
-		item: itemOf(row),
+		item: itemOf$1(row),
 		diff,
 		capturedAt: String(row.captured_at),
 		blocks,
@@ -8095,221 +8134,2317 @@ async function readRaw(fs, target, signal) {
 	}
 }
 //#endregion
-//#region src/search/query.ts
+//#region src/pending/capture.ts
 /**
-* 规范化用户搜索文本。
-* @author ddj 2026年08月24号
-* @param raw 原始搜索文本
-* @returns 用于比较和缓存的 query
+* 待审差异采集：环绕一次文件写入读取真实前后内容，只有内容确实变化才落库。
+* @author ddj 2026年10月29号
 */
-function prepareQuery(raw) {
-	const value = String(raw ?? "").trim();
-	return {
-		raw: value,
-		text: value.replaceAll("\\", "/").toLocaleLowerCase("en-US")
+/** 可被采信为待审来源的写文件工具。 */
+const WRITE_TOOLS = [
+	"edit",
+	"write",
+	"str_replace_editor"
+];
+/** 单文件文本上限：超过即标注 oversized，不静默截断。 */
+const MAX_TEXT = 1048576;
+/**
+* @author ddj 2026年10月30号
+* @description: 安装写文件采集；读写失败只影响待审来源，绝不影响用户工具本身。
+* @param ctx Host 生命周期
+* @param sink 已确认写入的接收方
+* @returns 可释放的采集器
+*/
+function installPending(ctx, sink) {
+	const state = {
+		busy: /* @__PURE__ */ new Set(),
+		stopped: false
 	};
+	ctx.on("tools/execute", (exec, next) => aroundTool(ctx, state, sink, exec, next));
+	return { dispose() {
+		state.stopped = true;
+		state.busy.clear();
+	} };
 }
 /**
-* 归一化路径分隔符并移除无意义前缀。
-* @author ddj 2026年08月24号
-* @param value 原始路径
-* @returns 比较用路径
+* @author ddj 2026年10月30号
+* @description: 判定本次调用是否值得采集；不值得时返回 null，调用方直接透传原始分发。
+* @param ctx Host 生命周期
+* @param state 采集状态
+* @param exec 工具分发上下文
+* @returns 采集计划或 null
 */
-function pathText(value) {
-	return value.replaceAll("\\", "/").replace(/^\.\//, "");
+async function planOf(ctx, state, exec) {
+	const session = exec.agent?.session;
+	const requested = exec.arguments?.file_path ?? exec.arguments?.path;
+	if (state.stopped || !session?.id || typeof requested !== "string") return null;
+	if (!WRITE_TOOLS.includes(String(exec.name))) return null;
+	const cwd = cwdOf(session);
+	if (!cwd) return null;
+	const fs = ctx.get("fs");
+	const target = await resolveTarget(ctx, session, requested);
+	const identity = fs.processPath(target);
+	if (typeof identity !== "string" || !identity || state.busy.has(identity)) return null;
+	const before = await readText(fs, target);
+	if (before !== null && before.length > MAX_TEXT) return null;
+	return {
+		cwd: String(cwd),
+		sessionId: String(session.id),
+		path: requested,
+		identity,
+		before,
+		session
+	};
 }
 /**
-* 生成不区分大小写的路径 key。
-* @author ddj 2026年08月24号
-* @param value 原始路径
-* @returns 去重 key
+* @author ddj 2026年10月30号
+* @description: 写工具执行前后各读一次，内容变化才上报；任何采集异常都不改变工具结果。
+* @param ctx Host 生命周期
+* @param state 采集状态
+* @param sink 已确认写入的接收方
+* @param exec 工具分发上下文
+* @param next 原始分发
+* @returns 原始工具结果
 */
-function pathKey(value) {
-	return pathText(value).toLocaleLowerCase("en-US");
+async function aroundTool(ctx, state, sink, exec, next) {
+	let plan = null;
+	try {
+		plan = await planOf(ctx, state, exec);
+	} catch (error) {
+		log.debug("待审采集跳过：" + String(error));
+	}
+	if (!plan) return next();
+	state.busy.add(plan.identity);
+	try {
+		return await next();
+	} finally {
+		state.busy.delete(plan.identity);
+		try {
+			reportWrite(ctx, sink, plan);
+		} catch (error) {
+			log.debug("待审上报失败：" + String(error));
+		}
+	}
 }
 /**
-* @public
-* @author ddj 2026年10月14号
-* @description 按顺序匹配不连续字符；每个位置最多消费一次。
-* @param value 已归一化候选文本
-* @param text 已归一化查询文本
-* @returns 是否完整匹配所有查询字符
+* @author ddj 2026年10月29号
+* @description: 写后读回并比较，内容一致视为无净变化不产生条目。
+* @param ctx Host 生命周期
+* @param sink 已确认写入的接收方
+* @param plan 采集计划
+* @returns 无；读回失败只记日志
 */
-function subsequence(value, text) {
-	let offset = 0;
-	for (const char of text) {
-		const index = value.indexOf(char, offset);
-		if (index < 0) return false;
-		offset = index + char.length;
-	}
-	return true;
+function reportWrite(ctx, sink, plan) {
+	const fs = ctx.get("fs");
+	resolveTarget(ctx, plan.session, plan.path).then(async (target) => {
+		const after = await readText(fs, target);
+		if (after !== null && after.length > MAX_TEXT) return;
+		if (plan.before === after) return;
+		sink({
+			cwd: plan.cwd,
+			sessionId: plan.sessionId,
+			path: plan.path,
+			identity: plan.identity,
+			before: plan.before,
+			after,
+			now: Date.now()
+		});
+	}).catch((error) => log.debug("待审读回失败：" + String(error)));
 }
 /**
-* @public
-* @author ddj 2026年10月14号
-* @description 连续匹配相对路径，或对无目录查询模糊匹配文件名。
-* @param value 文件路径（调用方移除工作区根前缀）
-* @param query 已规范化 query
-* @returns 是否命中；空查询不命中
+* @author ddj 2026年10月29号
+* @description: 读取全文；缺失或不可读按"无内容"处理，交由上层决定语义。
+* @param fs 文件系统
+* @param target 目标
+* @returns 文本或 null
 */
-function pathMatch(value, query) {
-	if (!query.text) return false;
-	const path = pathText(value).toLocaleLowerCase("en-US");
-	if (path.includes(query.text)) return true;
-	if (query.text.includes("/")) return false;
-	return subsequence(path.slice(path.lastIndexOf("/") + 1), query.text);
+async function readText(fs, target) {
+	try {
+		return String(await fs.readText(target));
+	} catch (error) {
+		const code = error.code;
+		if (code === "ENOENT" || code === "FS_NOT_FOUND" || code === "FS_TOO_LARGE") return null;
+		throw error;
+	}
 }
 //#endregion
-//#region src/search/ripgrep.ts
-/**
-* dsh-vscode-mode host — ripgrep 文件发现 provider。
-* 通过独立 argv 调用打包 rg，避免先构建巨型全量文件数组。
-* 作者 ddj 2026年08月24号
+//#region src/pending/vcs.ts
+/**
+* 版本库导入：把工作副本相对基线的改动读成待审条目，来源对齐 dsh-diff-approval 的 vcs 内核（MIT）。
+* 只读命令，不修改工作副本；基线读取失败一律上报，不猜"文件不存在"。
+* @author ddj 2026年10月30号
+*/
+/** 命令超时：与上游一致，避免大仓 status 卡死。 */
+const COMMAND_TIMEOUT = 6e4;
+/** stdout 预算：够放一个常见源文件，超出交给上游判断为超大。 */
+const STDOUT_BUDGET = 8388608;
+/** 只有这些 git 报错才算"该版本不存在"，其余一律抛出。 */
+const ABSENT_AT_REVISION = /does not exist in|exists on disk, but not in|not a valid object name|invalid object name|unknown revision|bad revision/i;
+/** 只有这些 P4 报错才算"该版本不存在"，其余一律抛出。 */
+const P4_ABSENT_AT_REVISION = /no such file|not opened|does not exist|no file\(s\) to print|invalid file|no revisions/i;
+/** git 相对路径用正斜杠。 */
+const GIT_SEPARATOR = "/";
+/**
+* @author ddj 2026年10月30号
+* @description: 向上查找版本库根目录，同目录 git 优先于 svn，最后才是 Perforce 配置。
+* @param cwd 工作区
+* @returns 探测结果，未找到时 undefined
 */
-const STDOUT_CAP$1 = 4 << 20;
-const STDERR_CAP$2 = 65536;
-const GRACE_MS$1 = 2e4;
+async function detectVcsRoot(cwd) {
+	let current = resolve(cwd);
+	for (;;) {
+		if (await exists(join(current, ".git"))) return {
+			kind: "git",
+			root: current
+		};
+		if (await exists(join(current, ".svn"))) return {
+			kind: "svn",
+			root: current
+		};
+		if (await isP4Root(current)) return {
+			kind: "p4",
+			root: current
+		};
+		const parent = dirname(current);
+		if (parent === current) return void 0;
+		current = parent;
+	}
+}
 /**
-* 默认排除目录（文件/内容搜索共用，导出供 provider 复用）。
-* 语义为**大小写敏感**的路径段匹配：`build` 只排除小写构建产物目录，
-* 不得用 `--glob-case-insensitive` 之类的全局开关，「Module/Build」这类
-* 源码目录（如 IslandSplash 的 Module/Build/Logic）必须保持可搜索。
+* @author ddj 2026年10月30号
+* @description: 判断目录是否是 Perforce 工作区根（P4CONFIG 文件所在目录）。
+* @param dir 目录
+* @returns 是否 P4 根
 */
-const EXCLUDES = [
-	"node_modules",
-	".git",
-	".tmp",
-	".cache",
-	"dist",
-	"build",
-	"vendor",
-	"coverage",
-	"__pycache__",
-	".pnpm-store",
-	".npm-cache",
-	".codegraph",
-	".workbuddy"
-];
+async function isP4Root(dir) {
+	return await exists(join(dir, ".p4config")) || await exists(join(dir, ".p4config.txt"));
+}
 /**
-* 默认排除文件（glob 模式，文件/内容搜索共用）。
-* 插件自身 sidecar（内容搜索会命中其历史编辑文本，且单行巨型 JSON 会撑爆输出上限）；
-* *.map 源映射（纯构建产物，内容搜索无意义且常为单行巨文件）。
+* @author ddj 2026年10月30号
+* @description: 读出当前工作副本相对基线的改动，只返回给定范围（含未跟踪按选项）。
+* @param shell shell 能力
+* @param cwd 工作区
+* @param options 导入选项
+* @returns 改动列表
 */
-const FILE_EXCLUDES = [
-	"**/.dsh-edit-review.json",
-	"**/.dsh-edit-review-archive.json",
-	"**/.dsh-edit-review-debug.log",
-	"**/*.map"
-];
+async function importVcsChanges(shell, cwd, options = {}) {
+	const detected = await detectVcsRoot(cwd);
+	if (!detected) return [];
+	const changes = await readChanges(shell, detected, cwd, options);
+	const only = options.path ? resolve(cwd, options.path) : void 0;
+	return changes.filter((change) => !only || samePath(change.path, only));
+}
 /**
-* 将查询文本转成大小写不敏感的 rg 正选 glob。
-* 逐字符把有大小写的字母展开成 `[aA]` 字符类，**不用**大小写不敏感开关：
-* ① 全局 `--glob-case-insensitive` 会把 `-g/--glob` 全部当成 `--iglob`，
-*    连带让 `!**\/build/**` 大小写不敏感，从而排除 `Module/Build/` 这类源码目录
-*    （Ctrl+P 搜 BuildLogic 恒「无匹配文件」）；
-* ② 把查询词改用 `--iglob` 也不行——rg 的正选 glob 会覆盖全部黑名单 glob，
-*    node_modules/.git 等排除项集体失效。
-* 字符类方案同时满足「查询不区分大小写」且「排除项保持大小写敏感」。
-* @author ddj 2026年08月24号 / 2026年09月20号
-* @param query 已规范化查询文本
-* @returns 安全 glob
+* @author ddj 2026年10月30号
+* @description: 按探测到的种类取改动，新增种类只在这里分流。
+* @param shell shell 能力
+* @param detected 版本库种类与根目录
+* @param cwd 工作区
+* @param options 导入选项
+* @returns 改动列表
 */
-function queryGlob(query) {
-	return "**/*" + Array.from(pathText(query), globChar).join("") + "*";
+async function readChanges(shell, detected, cwd, options) {
+	if (detected.kind === "git") return gitChanges(shell, cwd, detected.root, options);
+	if (detected.kind === "svn") return svnChanges(shell, cwd, detected.root, options);
+	return p4Changes(shell, cwd, detected.root, options);
 }
 /**
-* @private
-* @author ddj 2026年10月14号
-* @description 将字面字符转为安全且大小写不敏感的 glob 片段。
-* @param char 单个 Unicode 字符
-* @returns 转义字符或大小写字符类
-*/
-function globChar(char) {
-	const lower = char.toLowerCase();
-	const upper = char.toUpperCase();
-	if (lower !== upper && lower.length === 1 && upper.length === 1) return "[" + lower + upper + "]";
-	return /[\*?\[\]{}!]/.test(char) ? "\\" + char : char;
+* @author ddj 2026年10月30号
+* @description: git 改动：status -z 解析状态，基线取 HEAD 版本，未跟踪可按选项导入为新建。
+* @param shell shell 能力
+* @param cwd 工作区
+* @param root 仓库根
+* @param options 导入选项
+* @returns 改动列表
+*/
+async function gitChanges(shell, cwd, root, options) {
+	const status = await runCommand(shell, "git -c status.renames=false status --porcelain=v1 -z --untracked-files=all", root);
+	if (!status.ok) throw new Error("git status 失败：" + status.stderr.slice(0, 200));
+	const changes = [];
+	for (const entry of parseGitStatus(status.stdout)) {
+		if (entry.status === "??" && !options.includeUntracked) continue;
+		const absolute = join(root, ...entry.path.split(GIT_SEPARATOR));
+		if (!insideRoot(root, absolute)) continue;
+		const current = await readTextOf(absolute);
+		if (entry.status === "??" || entry.status === "A ") {
+			changes.push({
+				path: absolute,
+				earlierVersion: "none",
+				oldText: "",
+				newText: current
+			});
+			continue;
+		}
+		const baseline = await gitBaseline(shell, root, entry.path);
+		changes.push({
+			path: absolute,
+			earlierVersion: baseline === null ? "none" : "file",
+			oldText: baseline ?? "",
+			newText: current
+		});
+	}
+	return changes;
 }
 /**
-* @public
-* @author ddj 2026年10月14号
-* @description 构造仅匹配文件名的有序子序列 glob，不让星号跨目录。
-* @param query 无目录的字面查询文本
-* @returns 模糊 glob；空查询或带目录时返回 null
+* @author ddj 2026年10月30号
+* @description: svn 改动：status --xml 解析状态，基线取 BASE 版本。
+* @param shell shell 能力
+* @param cwd 工作区
+* @param root 工作副本根
+* @param options 导入选项
+* @returns 改动列表
+*/
+async function svnChanges(shell, cwd, root, options) {
+	const status = await runCommand(shell, "svn status --xml", root);
+	if (!status.ok) throw new Error("svn status 失败：" + status.stderr.slice(0, 200));
+	const changes = [];
+	for (const entry of parseSvnStatus(status.stdout)) {
+		if (entry.status === "unversioned" && !options.includeUntracked) continue;
+		const absolute = resolve(root, entry.path);
+		if (!insideRoot(root, absolute)) continue;
+		const current = await readTextOf(absolute);
+		if (entry.status === "added" || entry.status === "unversioned" || entry.status === "replaced") {
+			changes.push({
+				path: absolute,
+				earlierVersion: "none",
+				oldText: "",
+				newText: current
+			});
+			continue;
+		}
+		const baseline = await svnBaseline(shell, root, entry.path);
+		changes.push({
+			path: absolute,
+			earlierVersion: "file",
+			oldText: baseline,
+			newText: current
+		});
+	}
+	return changes;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 取 HEAD 版本内容；仅"该版本确实没有此文件"时返回 null，其余失败抛出。
+* @param shell shell 能力
+* @param root 仓库根
+* @param relative 仓库相对路径（正斜杠）
+* @returns 基线内容或 null
 */
-function fuzzyGlob(query) {
-	const value = pathText(query);
-	if (!value || value.includes("/")) return null;
-	return "**/*" + Array.from(value, globChar).join("*") + "*";
+async function gitBaseline(shell, root, relative) {
+	const size = await runCommand(shell, `git cat-file -s HEAD:${quote(relative)}`, root);
+	const budget = size.ok ? Number(size.stdout.trim()) + 1024 : STDOUT_BUDGET;
+	const shown = await runCommand(shell, `git show HEAD:${quote(relative)}`, root, Math.min(budget, STDOUT_BUDGET));
+	if (shown.ok) return shown.stdout;
+	if (ABSENT_AT_REVISION.test(shown.stderr)) return null;
+	throw new Error("读取 git 基线失败：" + shown.stderr.slice(0, 200));
 }
 /**
-* 返回当前平台的 rg 可执行文件路径，不让可选依赖影响模块加载。
-* @author ddj 2026年08月24号
-* @returns rg 路径或 null
+* @author ddj 2026年10月30号
+* @description: 取 svn BASE 版本内容；失败一律抛出（svn 没有可靠的"不存在"判据）。
+* @param shell shell 能力
+* @param root 工作副本根
+* @param relative 相对路径
+* @returns 基线内容
 */
-function ripgrepPath() {
-	try {
-		const ripgrep = createRequire(import.meta.url)("@vscode/ripgrep");
-		if (typeof ripgrep.rgPath !== "string" || !existsSync(ripgrep.rgPath)) return null;
-		return join(ripgrep.rgPath);
-	} catch (error) {
-		return null;
+async function svnBaseline(shell, root, relative) {
+	const shown = await runCommand(shell, `svn cat -r BASE ${quote(relative)}`, root);
+	if (!shown.ok) throw new Error("读取 svn 基线失败：" + shown.stderr.slice(0, 200));
+	return shown.stdout;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: Perforce 改动：opened（含 status 的未跟踪项）解析 depot 路径，再折成本地路径。
+* @param shell shell 能力
+* @param cwd 工作区
+* @param root P4 工作区根
+* @param options 导入选项
+* @returns 改动列表
+*/
+async function p4Changes(shell, cwd, root, options) {
+	const depotPaths = /* @__PURE__ */ new Set();
+	const opened = await runCommand(shell, "p4 opened", root);
+	if (!opened.ok) throw new Error("p4 opened 失败：" + opened.stderr.slice(0, 200));
+	for (const path of parseP4Opened(opened.stdout)) depotPaths.add(path);
+	if (options.includeUntracked) {
+		const status = await runCommand(shell, "p4 status", root);
+		if (!status.ok) throw new Error("p4 status 失败：" + status.stderr.slice(0, 200));
+		for (const path of parseP4Status(status.stdout)) depotPaths.add(path);
+	}
+	const changes = [];
+	for (const depot of depotPaths) {
+		const absolute = await p4LocalPath(shell, root, depot);
+		if (!absolute || !insideRoot(root, absolute)) continue;
+		const current = await readTextOf(absolute);
+		const baseline = await p4Baseline(shell, root, depot);
+		changes.push({
+			path: absolute,
+			earlierVersion: baseline === null ? "none" : "file",
+			oldText: baseline ?? "",
+			newText: current
+		});
 	}
+	return changes;
 }
 /**
-* 解析会话搜索根目录，并转换到 subprocess 执行世界。
-* @author ddj 2026年08月24号
-* @param ctx DSH 上下文
-* @param session 当前会话
-* @returns subprocess 可访问的根目录
+* @author ddj 2026年10月30号
+* @description: 解析 `p4 opened` 输出，只取 depot 路径（`//depot/x#3 - edit ...`）。
+* @param text 输出
+* @returns depot 路径列表
 */
-async function searchRoot(ctx, session) {
-	const fs = ctx.get("fs");
-	if (!fs) throw new Error("缺少 fs");
-	const policy = policyOf(ctx, session);
-	const cwd = cwdOfSession(ctx, session);
-	const rootTarget = await fs.resolve(policy?.workspaceRoot ?? ".", cwd ? { cwd } : {});
-	return fs.processPath(rootTarget);
+function parseP4Opened(text) {
+	const paths = [];
+	for (const line of text.split(/\r?\n/)) {
+		const match = /^(\/\/[^#\s]+)#\d+/.exec(line.trim());
+		if (match) paths.push(match[1]);
+	}
+	return paths;
 }
 /**
-* 读取收集输出并解析为路径候选。
-* @author ddj 2026年08月24号
-* @param handle subprocess handle
-* @param maxResults 候选上限
-* @returns 路径与完整性状态
+* @author ddj 2026年10月30号
+* @description: 解析 `p4 status` 输出；每行以本地路径或 depot 路径开头，取路径本身。
+* @param text 输出
+* @returns depot 或本地路径列表
 */
-function parseOutput(handle, maxResults) {
-	const reader = handle.collected?.stdout;
-	if (!reader) return {
-		files: [],
-		truncated: false,
-		complete: false
-	};
-	const output = reader.readFrom(0);
-	const values = output.text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-	const unique = [...new Set(values)];
-	const truncated = Boolean(output.lossy) || unique.length > maxResults;
-	return {
-		files: unique.slice(0, maxResults).map(pathText),
-		truncated,
-		complete: !truncated
-	};
+function parseP4Status(text) {
+	const paths = [];
+	for (const line of text.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("-")) continue;
+		const head = trimmed.split(/\s+-\s+/)[0]?.trim();
+		if (!head) continue;
+		paths.push(head);
+	}
+	return paths;
 }
 /**
-* 读取已收集的 stderr（无收集器 → 空文本）。
-* @author ddj 2026年08月27号
-* @param handle subprocess handle
-* @returns stderr 文本
+* @author ddj 2026年10月30号
+* @description: `p4 where` 把小写 depot 路径折成本地绝对路径。
+* @param shell shell 能力
+* @param root P4 工作区根
+* @param depot depot 路径
+* @returns 本地路径，失败时 undefined
 */
-function readStderr(handle) {
-	const reader = handle.collected?.stderr;
-	return reader ? reader.readFrom(0) : { text: "" };
+async function p4LocalPath(shell, root, depot) {
+	if (depot.startsWith("//")) {
+		const where = await runCommand(shell, `p4 where ${quote(depot)}`, root);
+		if (!where.ok) return void 0;
+		const tokens = where.stdout.trim().split(/\s+/);
+		return tokens[tokens.length - 1] ?? void 0;
+	}
+	return resolve(root, depot);
 }
 /**
-* 取 stderr 首条非空行（去 \r，截断 300 字符防撑爆 UI）。
-* @author ddj 2026年08月27号
-* @param text stderr 全文
-* @returns 首条诊断行（无则空串）
+* @author ddj 2026年10月30号
+* @description: 取 `#have` 版本内容；只有明确"没有该版本"时返回 null，其余失败抛出。
+* @param shell shell 能力
+* @param root P4 工作区根
+* @param depot depot 路径
+* @returns 基线内容或 null
+*/
+async function p4Baseline(shell, root, depot) {
+	if (!depot.startsWith("//")) return null;
+	const printed = await runCommand(shell, `p4 print -q ${quote(depot + "#have")}`, root);
+	if (printed.ok) return printed.stdout;
+	if (P4_ABSENT_AT_REVISION.test(printed.stderr)) return null;
+	throw new Error("读取 p4 基线失败：" + printed.stderr.slice(0, 200));
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 解析 git status -z 输出；重命名/复制记录按目标路径处理。
+* @param text -z 输出
+* @returns 状态与仓库相对路径
+*/
+function parseGitStatus(text) {
+	const parts = text.split("\0").filter((part) => part.length > 2);
+	const entries = [];
+	for (let index = 0; index < parts.length; index++) {
+		const part = parts[index];
+		const status = part.slice(0, 2);
+		const path = part.slice(3);
+		if (status.includes("R") || status.includes("C")) index++;
+		entries.push({
+			status,
+			path
+		});
+	}
+	return entries;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 解析 svn status --xml 输出。
+* @param xml xml 文本
+* @returns 条目状态与相对路径
+*/
+function parseSvnStatus(xml) {
+	const entries = [];
+	for (const match of xml.matchAll(/<entry\s+path="([^"]+)"([\s\S]*?)<\/entry>/g)) {
+		const status = /<wc-status[^>]*\sitem="([^"]+)"/.exec(match[2] ?? "")?.[1];
+		if (status) entries.push({
+			status,
+			path: decodeXml(match[1])
+		});
+	}
+	return entries;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 执行一条只读命令并收集输出；超时/取消/非零退出都回 ok=false，不抛出。
+* @param shell shell 能力
+* @param command 命令
+* @param workdir 工作目录
+* @param stdoutMaxBytes stdout 预算
+* @returns 输出与状态
+*/
+async function runCommand(shell, command, workdir, stdoutMaxBytes = STDOUT_BUDGET) {
+	try {
+		const spec = shell.resolve({
+			command,
+			workdir,
+			timeoutMs: COMMAND_TIMEOUT,
+			stdoutMaxBytes
+		});
+		const result = await (await shell.execute(spec)).result();
+		return {
+			ok: result.exitCode === 0 && !result.timedOut && !result.aborted,
+			stdout: result.stdout.text,
+			stderr: result.stderr.text
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			stdout: "",
+			stderr: String(error)
+		};
+	}
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 读单元格文本，不存在时返回 null。
+* @param path 文件路径
+* @returns 内容或 null
+*/
+async function readTextOf(path) {
+	try {
+		if (!(await stat(path)).isFile()) return null;
+		return await readFile(path, "utf8");
+	} catch {
+		return null;
+	}
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 判断路径是否存在。
+* @param path 路径
+* @returns 是否存在
+*/
+async function exists(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 判断目标是否位于仓库根之内（Windows 下按大小写不敏感比较）。
+* @param root 仓库根
+* @param target 目标绝对路径
+* @returns 是否在根内
+*/
+function insideRoot(root, target) {
+	const normalize = (value) => process.platform === "win32" ? value.toLowerCase() : value;
+	const rootKey = normalize(resolve(root)).replace(/[\\/]+$/, "") + sep;
+	return normalize(resolve(target)).startsWith(rootKey);
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 比较两个路径是否同一文件（Windows 下大小写不敏感）。
+* @param left 路径
+* @param right 路径
+* @returns 是否相同
+*/
+function samePath(left, right) {
+	const normalize = (value) => process.platform === "win32" ? value.toLowerCase() : value;
+	return normalize(resolve(left)) === normalize(resolve(right));
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 为 shell 命令参数加引号，避免空格与特殊字符改变命令含义。
+* @param value 参数
+* @returns 加引号后的参数
+*/
+function quote(value) {
+	return "\"" + value.replace(/"/g, "\\\"") + "\"";
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 还原 xml 实体（svn status 会转义非 ASCII 与空格）。
+* @param value 属性值
+* @returns 解码后的路径
+*/
+function decodeXml(value) {
+	return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+//#endregion
+//#region src/pending/hunks.ts
+/** 每个 hunk 的上下文行数。 */
+const CONTEXT = 3;
+/** LCS 单元格上限：超过后退化为整段替换，避免大文件卡死。 */
+const CELL_LIMIT = 1e6;
+/**
+* @author ddj 2026年10月29号
+* @description: 构造可直接交给官方渲染器的差异；两侧完全相同时返回空 hunk 列表。
+* @param path 相对路径
+* @param display 展示名
+* @param oldText 基线全文
+* @param newText 当前全文
+* @returns 文本差异
+*/
+function textDiff(path, display, oldText, newText) {
+	const hunks = buildHunks(logicalLines(oldText), logicalLines(newText));
+	return {
+		kind: "text",
+		path,
+		display,
+		before: true,
+		after: true,
+		hunks,
+		coarse: hunks.length > 0 && isCoarse(oldText, newText)
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 块级 Keep：把该块的新内容写进基线，返回推进后的基线。
+* @param oldText 当前基线
+* @param block 目标块
+* @returns 新基线；块在当前基线中无法唯一定位时返回 null
+*/
+function keepBlock(oldText, block) {
+	return spliceBlock(oldText, block.oldLines, block.newLines, block);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 块级 Revert：把该块在最新内容里换回基线内容，返回换回后的内容。
+* @param newText 当前内容
+* @param block 目标块
+* @returns 新内容；块无法唯一定位时返回 null
+*/
+function revertBlock(newText, block) {
+	return spliceBlock(newText, block.newLines, block.oldLines, block);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 按"上下文 + 目标行"唯一定位后做一次整块替换，定位不唯一就不动。
+* @param content 目标全文
+* @param from 要被替换的块内行
+* @param to 替换成的块内行
+* @param block 来源块，提供上下文；缺上下文时退化为只看块内行
+* @returns 新全文或 null
+*/
+function spliceBlock(content, from, to, block) {
+	if (from.length === 0 && to.length === 0) return null;
+	const lines = logicalLines(content);
+	const withContext = locateSpan(lines, [
+		...block.contextBefore,
+		...from,
+		...block.contextAfter
+	]);
+	if (withContext !== null) return spliceAt(lines, withContext + block.contextBefore.length, from.length, to);
+	const bare = locateSpan(lines, from);
+	return bare === null ? null : spliceAt(lines, bare, from.length, to);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 在指定偏移处把连续若干行换成另一组行。
+* @param lines 目标行集合
+* @param start 起始偏移
+* @param count 被替换行数
+* @param to 替换成的行
+* @returns 新全文
+*/
+function spliceAt(lines, start, count, to) {
+	return [
+		...lines.slice(0, start),
+		...to,
+		...lines.slice(start + count)
+	].join("\n");
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 唯一定位一段行；出现多处命中即视为不可定位。
+* @param lines 目标行集合
+* @param pattern 待定位行
+* @returns 唯一偏移或 null
+*/
+function locateSpan(lines, pattern) {
+	if (pattern.length === 0) return null;
+	let at = -1;
+	for (let offset = 0; offset + pattern.length <= lines.length; offset++) {
+		if (!pattern.every((text, index) => lines[offset + index] === text)) continue;
+		if (at >= 0) return null;
+		at = offset;
+	}
+	return at >= 0 ? at : null;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 生成带上下文的标准 hunk 列表。
+* @param oldLines 基线行
+* @param newLines 当前行
+* @returns hunk 列表
+*/
+function buildHunks(oldLines, newLines) {
+	const ops = diffLines(oldLines, newLines);
+	const hunks = [];
+	let index = 0;
+	let oldLine = 0;
+	let newLine = 0;
+	while (index < ops.length) {
+		if (ops[index].kind === " ") {
+			oldLine++;
+			newLine++;
+			index++;
+			continue;
+		}
+		const head = ops.slice(Math.max(0, index - CONTEXT), index);
+		const collected = [];
+		let probe = index;
+		while (probe < ops.length) {
+			const op = ops[probe];
+			if (op.kind !== " ") {
+				collected.push(op);
+				probe++;
+				continue;
+			}
+			if (ops.slice(probe, probe + 6 + 1).some((item) => item.kind !== " ")) {
+				collected.push(op);
+				probe++;
+				continue;
+			}
+			break;
+		}
+		const tail = ops.slice(probe, probe + CONTEXT);
+		const oldStartLine = oldLine - head.length + 1;
+		const newStartLine = newLine - head.length + 1;
+		hunks.push(makeHunk([
+			...head,
+			...collected,
+			...tail
+		], oldStartLine, newStartLine));
+		for (const op of collected) {
+			if (op.kind !== "+") oldLine++;
+			if (op.kind !== "-") newLine++;
+		}
+		oldLine += head.length + tail.length;
+		newLine += head.length + tail.length;
+		index = probe + tail.length;
+	}
+	return hunks;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 由一段操作装配 hunk。
+* @param ops 该 hunk 的操作
+* @param oldStart 基线起始行
+* @param newStart 当前起始行
+* @returns hunk
+*/
+function makeHunk(ops, oldStart, newStart) {
+	return {
+		oldStart,
+		oldLines: ops.filter((op) => op.kind !== "+").length,
+		newStart,
+		newLines: ops.filter((op) => op.kind !== "-").length,
+		lines: ops.map((op) => op.kind + op.text)
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 行级差异：先剪公共前后缀，剩余部分在限额内做 LCS，超限按整段替换。
+* @param oldLines 基线行
+* @param newLines 当前行
+* @returns 顺序完整的操作列表
+*/
+function diffLines(oldLines, newLines) {
+	let head = 0;
+	while (head < oldLines.length && head < newLines.length && oldLines[head] === newLines[head]) head++;
+	let tail = 0;
+	while (tail < oldLines.length - head && tail < newLines.length - head && oldLines[oldLines.length - 1 - tail] === newLines[newLines.length - 1 - tail]) tail++;
+	const left = oldLines.slice(head, oldLines.length - tail);
+	const right = newLines.slice(head, newLines.length - tail);
+	const middle = left.length * right.length > CELL_LIMIT ? coarseOps(left, right) : lcsOps(left, right);
+	return [
+		...oldLines.slice(0, head).map((text) => ({
+			kind: " ",
+			text
+		})),
+		...middle,
+		...oldLines.slice(oldLines.length - tail).map((text) => ({
+			kind: " ",
+			text
+		}))
+	];
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 超限时的退化口径：整段删除再整段新增，绝不谎报逐行对应。
+* @param left 基线剩余行
+* @param right 当前剩余行
+* @returns 操作列表
+*/
+function coarseOps(left, right) {
+	return [...left.map((text) => ({
+		kind: "-",
+		text
+	})), ...right.map((text) => ({
+		kind: "+",
+		text
+	}))];
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 限额内的 LCS 行差异。
+* @param left 基线剩余行
+* @param right 当前剩余行
+* @returns 操作列表
+*/
+function lcsOps(left, right) {
+	const rows = left.length + 1;
+	const cols = right.length + 1;
+	const table = new Uint32Array(rows * cols);
+	for (let i = left.length - 1; i >= 0; i--) for (let j = right.length - 1; j >= 0; j--) table[i * cols + j] = left[i] === right[j] ? table[(i + 1) * cols + j + 1] + 1 : Math.max(table[(i + 1) * cols + j], table[i * cols + j + 1]);
+	const ops = [];
+	let i = 0;
+	let j = 0;
+	while (i < left.length && j < right.length) {
+		if (left[i] === right[j]) {
+			ops.push({
+				kind: " ",
+				text: left[i]
+			});
+			i++;
+			j++;
+			continue;
+		}
+		if (table[(i + 1) * cols + j] >= table[i * cols + j + 1]) {
+			ops.push({
+				kind: "-",
+				text: left[i]
+			});
+			i++;
+		} else {
+			ops.push({
+				kind: "+",
+				text: right[j]
+			});
+			j++;
+		}
+	}
+	while (i < left.length) ops.push({
+		kind: "-",
+		text: left[i++]
+	});
+	while (j < right.length) ops.push({
+		kind: "+",
+		text: right[j++]
+	});
+	return ops;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 判断这次差异是否触发了大文件退化口径。
+* @param oldText 基线全文
+* @param newText 当前全文
+* @returns 是否粗粒度
+*/
+function isCoarse(oldText, newText) {
+	return logicalLines(oldText).length * logicalLines(newText).length > CELL_LIMIT;
+}
+//#endregion
+//#region src/pending/kernel.ts
+/**
+* @author ddj 2026年10月29号
+* @description: 严格比较两侧文本：不做 BOM/行尾归一化，归一化只允许用于展示。
+* @param left 一侧全文
+* @param right 另一侧全文
+* @returns 两者是否逐码元相等
+*/
+function sameEntryText(left, right) {
+	return left === right;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 净零判定：基线等于当前内容即为已解决，但条目仍留在列表等待移除。
+* @param entry 待审条目
+* @returns 是否已无净差异
+*/
+function isSettled(entry) {
+	return sameEntryText(entry.oldText, entry.newText);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 合并同一身份的两条条目：基线取较早来源，最新内容取较晚来源，会话取并集。
+* @param earlier 较早记录
+* @param later 较晚记录
+* @returns 合并后的新条目
+*/
+function mergeEntries(earlier, later) {
+	const merged = {
+		...later,
+		updatedAt: later.updatedAt,
+		sessionIds: unionSessions(earlier, later)
+	};
+	if (later.lineage === void 0 && earlier.lineage !== void 0) merged.lineage = earlier.lineage;
+	if (earlier.earlierVersion === "none" && later.earlierVersion === "none") {
+		merged.earlierVersion = "none";
+		merged.oldText = earlier.oldText;
+		return merged;
+	}
+	merged.earlierVersion = "file";
+	merged.oldText = earlier.earlierVersion === "none" ? earlier.newText : earlier.oldText;
+	return merged;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 由新建入参构造条目，并把首个会话写进会话集合。
+* @param input 新建入参
+* @returns 新条目
+*/
+function entryFromNew(input) {
+	const entry = {
+		id: input.id,
+		path: input.path,
+		earlierVersion: input.earlierVersion,
+		oldText: input.oldText,
+		newText: input.newText,
+		updatedAt: input.updatedAt,
+		sessionId: input.sessionId,
+		sessionIds: [input.sessionId]
+	};
+	if (input.lineage !== void 0) entry.lineage = input.lineage;
+	return entry;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 应用一次决定带来的局部推进：块级 Keep 推进基线，块级 Revert 推进当前内容。
+* @param entry 待审条目
+* @param patch 要推进的一侧
+* @param now 本次更新时间
+* @returns 新条目；基线被推进时"创建"身份结束
+*/
+function applyUpdate(entry, patch, now) {
+	const next = {
+		...entry,
+		updatedAt: now
+	};
+	if (patch.oldText !== void 0) {
+		next.oldText = patch.oldText;
+		next.earlierVersion = "file";
+	}
+	if (patch.newText !== void 0) next.newText = patch.newText;
+	delete next.unseen;
+	return next;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 合并两条条目的会话集合并去重，且保证首会话在列。
+* @param earlier 较早记录
+* @param later 较晚记录
+* @returns 去重后的会话集合
+*/
+function unionSessions(earlier, later) {
+	const merged = [];
+	for (const sessionId of [
+		earlier.sessionId,
+		...earlier.sessionIds,
+		later.sessionId,
+		...later.sessionIds
+	]) if (sessionId && !merged.includes(sessionId)) merged.push(sessionId);
+	return merged;
+}
+//#endregion
+//#region src/pending/decide.ts
+/**
+* @author ddj 2026年10月29号
+* @description: 执行一次 Keep/Revert；失败时返回原状态，调用方不得落库。
+* @param input 判定输入
+* @returns 判定结果
+*/
+async function decide(input) {
+	const failed = (reason) => ({
+		ok: false,
+		reason,
+		entry: input.entry,
+		flags: input.flags,
+		blocks: input.blocks,
+		wrote: false
+	});
+	if (input.request.revision !== input.flags.revision) return failed("revision-mismatch");
+	if (input.flags.oversized) return failed("oversized");
+	if (input.entry.oldText === input.entry.newText) return failed("settled");
+	const targets = pickBlocks(reviewBlocks(textDiff(input.entry.path, input.entry.path, input.entry.oldText, input.entry.newText)), input);
+	if (targets === null) return failed("unknown-block");
+	if (input.request.scope !== "file" && input.request.scope !== "all" && targets.length === 0) return failed("no-block");
+	const isKeep = input.request.decision === "accepted";
+	const whole = input.request.scope === "file" || input.request.scope === "all";
+	return isKeep ? keep(input, targets, whole) : revert(input, targets, whole);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: Keep：只把目标块或整文件的新内容并入基线，绝不写目标文件。
+* @param input 判定输入
+* @param targets 目标块（整文件时为空）
+* @param whole 是否整文件
+* @returns 判定结果
+*/
+function keep(input, targets, whole) {
+	if (whole) return {
+		ok: true,
+		reason: "",
+		entry: applyUpdate(input.entry, { oldText: input.entry.newText }, input.now),
+		wrote: false,
+		flags: {
+			...input.flags,
+			revision: input.flags.revision + 1
+		},
+		blocks: markAll(input.blocks, targets, "accepted")
+	};
+	let oldText = input.entry.oldText;
+	for (const block of targets) {
+		const next = keepBlock(oldText, block);
+		if (next === null) return {
+			ok: false,
+			reason: "ambiguous-block",
+			entry: input.entry,
+			flags: input.flags,
+			blocks: input.blocks,
+			wrote: false
+		};
+		oldText = next;
+	}
+	return {
+		ok: true,
+		reason: "",
+		entry: applyUpdate(input.entry, { oldText }, input.now),
+		wrote: false,
+		flags: {
+			...input.flags,
+			revision: input.flags.revision + 1
+		},
+		blocks: markAll(input.blocks, targets, "accepted")
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: Revert：合成回退内容后交给 writer 写盘并读回，写失败则状态不变。
+* @param input 判定输入
+* @param targets 目标块（整文件时为空）
+* @param whole 是否整文件
+* @returns 判定结果
+*/
+async function revert(input, targets, whole) {
+	const failed = (reason) => ({
+		ok: false,
+		reason,
+		entry: input.entry,
+		flags: input.flags,
+		blocks: input.blocks,
+		wrote: false
+	});
+	const next = whole ? wholeRevert(input.entry) : blockRevert(input.entry, targets);
+	if (next === void 0) return failed("ambiguous-block");
+	const written = await input.write(next);
+	if (!written.ok) return failed(written.reason);
+	return {
+		ok: true,
+		reason: "",
+		entry: applyUpdate(input.entry, { newText: written.content ?? "" }, input.now),
+		wrote: true,
+		flags: {
+			...input.flags,
+			revision: input.flags.revision + 1,
+			missing: written.content === null
+		},
+		blocks: markAll(input.blocks, targets, "rejected")
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 整文件回退目标：基线为"文件不存在"时删除，否则写回基线全文。
+* @param entry 待审条目
+* @returns 目标内容，null 表示删除
+*/
+function wholeRevert(entry) {
+	return entry.earlierVersion === "none" ? null : entry.oldText;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 块级回退：在最新内容里依次换回目标块，任一不可定位即整体放弃。
+* @param entry 待审条目
+* @param targets 目标块
+* @returns 新内容或 undefined
+*/
+function blockRevert(entry, targets) {
+	let newText = entry.newText;
+	for (const block of targets) {
+		const next = revertBlock(newText, block);
+		if (next === null) return void 0;
+		newText = next;
+	}
+	return newText;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 按请求粒度挑出目标块；块不存在时返回 null 以区分"没有块"。
+* @param blocks 当前差异块
+* @param input 判定输入
+* @returns 目标块，未知块 ID 时为 null
+*/
+function pickBlocks(blocks, input) {
+	const scope = input.request.scope;
+	if (scope === "file" || scope === "all") return [];
+	if (scope === "block") {
+		const block = blocks.find((item) => item.id === input.request.blockId);
+		return block ? [block] : null;
+	}
+	const start = input.request.startLine ?? 0;
+	const end = input.request.endLine ?? start;
+	return blocks.filter((block) => block.newStart <= end && block.newStart + Math.max(block.newLines.length, 1) >= start);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 把目标块标记为已决定；整文件时把全部块一起标记。
+* @param states 已存块决定
+* @param targets 目标块
+* @param decision 决定
+* @returns 新的块决定列表
+*/
+function markAll(states, targets, decision) {
+	const next = states.slice();
+	for (const block of targets) {
+		const at = next.findIndex((state) => state.id === block.id);
+		if (at >= 0) next[at] = {
+			id: block.id,
+			decision
+		};
+		else next.push({
+			id: block.id,
+			decision
+		});
+	}
+	return next;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 能力口径：Keep 恒可；Revert 受超大/缺失/已解决限制，拒绝原因要能展示。
+* @param entry 待审条目
+* @param flags 持久标记
+* @returns 能力与原因
+*/
+function capabilityOf(entry, flags) {
+	if (isSettled(entry)) return {
+		keep: false,
+		revert: false,
+		reason: "settled"
+	};
+	if (flags.oversized) return {
+		keep: false,
+		revert: false,
+		reason: "oversized"
+	};
+	if (entry.earlierVersion === "none" && entry.newText.length === 0) return {
+		keep: true,
+		revert: false,
+		reason: "empty-create"
+	};
+	return {
+		keep: true,
+		revert: true,
+		reason: ""
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 供详情接口复用的差异构造。
+* @param entry 待审条目
+* @returns 官方差异
+*/
+function diffOf(entry) {
+	return textDiff(entry.path, entry.path, entry.oldText, entry.newText);
+}
+//#endregion
+//#region src/pending/persist.ts
+/** 待审库版本号，写进 metadata 便于日后迁移。v3 给评论表加了引文与上下文列。 */
+const SCHEMA_VERSION = "3";
+/**
+* @author ddj 2026年10月29号
+* @description: 打开工作区库并确保待审表存在；DDL 与版本标记在同一事务里提交。
+* @param cwd 已迁移工作区
+* @returns 可读写的连接
+* @throws 未完成活跃库迁移时拒绝
+*/
+function pendingDb(cwd) {
+	if (!activeReady(cwd)) throw new Error("待审投影要求先完成活跃库迁移");
+	const db = dbFor(cwd);
+	if (db.prepare("SELECT value FROM metadata WHERE name='pending_schema'").get()?.value === SCHEMA_VERSION) return db;
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		db.exec(DDL);
+		migrateHistory(db);
+		db.prepare("INSERT INTO metadata(name,value) VALUES('pending_schema',?) ON CONFLICT(name) DO UPDATE SET value=excluded.value").run(SCHEMA_VERSION);
+		db.exec("COMMIT");
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+	return db;
+}
+/** 待审表结构：条目、块决定、幂等操作、撤销栈。 */
+const DDL = `
+CREATE TABLE IF NOT EXISTS pending_entries (
+  id TEXT PRIMARY KEY, path TEXT NOT NULL, earlier TEXT NOT NULL,
+  old_text TEXT NOT NULL, new_text TEXT NOT NULL, updated_at INTEGER NOT NULL,
+  unseen INTEGER NOT NULL DEFAULT 0, missing INTEGER NOT NULL DEFAULT 0,
+  diverged INTEGER NOT NULL DEFAULT 0, oversized INTEGER NOT NULL DEFAULT 0,
+  revision INTEGER NOT NULL DEFAULT 0, session_id TEXT NOT NULL,
+  session_ids TEXT NOT NULL, lineage TEXT);
+CREATE TABLE IF NOT EXISTS pending_blocks (
+  entry_id TEXT NOT NULL, block_id TEXT NOT NULL, decision TEXT NOT NULL,
+  PRIMARY KEY(entry_id,block_id));
+CREATE TABLE IF NOT EXISTS pending_ops (
+  operation_id TEXT PRIMARY KEY, request TEXT NOT NULL, state TEXT NOT NULL,
+  result TEXT, undo TEXT);
+CREATE TABLE IF NOT EXISTS pending_history (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, kind TEXT NOT NULL, entry_id TEXT,
+  snapshot TEXT NOT NULL, created_at INTEGER NOT NULL,
+  state TEXT NOT NULL DEFAULT 'applied');
+`;
+/**
+* @author ddj 2026年10月29号
+* @description: v1 历史表补 state 列（rebuild 成本高于一次 ALTER）。
+* @param db 已打开的工作区库
+* @returns 无
+*/
+function migrateHistory(db) {
+	if (db.prepare("PRAGMA table_info(pending_history)").all().some((column) => column.name === "state")) return;
+	db.exec("ALTER TABLE pending_history ADD COLUMN state TEXT NOT NULL DEFAULT 'applied'");
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 读出全部待审条目，按更新时间升序。
+* @param cwd 工作区
+* @returns 条目与标记
+*/
+function loadEntries(cwd) {
+	return pendingDb(cwd).prepare("SELECT * FROM pending_entries ORDER BY updated_at ASC").all().map((row) => ({
+		entry: entryOfRow(row),
+		flags: flagsOfRow(row)
+	}));
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 写入或更新一条条目（含标记），单条原子完成。
+* @param cwd 工作区
+* @param stored 条目与标记
+* @returns 无
+*/
+function saveEntry(cwd, stored) {
+	const { entry, flags } = stored;
+	pendingDb(cwd).prepare(`INSERT INTO pending_entries
+    (id,path,earlier,old_text,new_text,updated_at,unseen,missing,diverged,oversized,revision,session_id,session_ids,lineage)
+    VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+    ON CONFLICT(id) DO UPDATE SET path=excluded.path,earlier=excluded.earlier,old_text=excluded.old_text,
+      new_text=excluded.new_text,updated_at=excluded.updated_at,unseen=excluded.unseen,missing=excluded.missing,
+      diverged=excluded.diverged,oversized=excluded.oversized,revision=excluded.revision,
+      session_id=excluded.session_id,session_ids=excluded.session_ids,lineage=excluded.lineage`).run(entry.id, entry.path, entry.earlierVersion, entry.oldText, entry.newText, entry.updatedAt, entry.unseen === true ? 1 : 0, flags.missing ? 1 : 0, flags.diverged ? 1 : 0, flags.oversized ? 1 : 0, flags.revision, entry.sessionId, JSON.stringify(entry.sessionIds), entry.lineage ? JSON.stringify(entry.lineage) : null);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 删除条目及其块决定，用于"已解决条目移除"。
+* @param cwd 工作区
+* @param id 条目身份
+* @returns 无
+*/
+function dropEntry(cwd, id) {
+	const db = pendingDb(cwd);
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		db.prepare("DELETE FROM pending_entries WHERE id=?").run(id);
+		db.prepare("DELETE FROM pending_blocks WHERE entry_id=?").run(id);
+		db.exec("COMMIT");
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 覆盖某条目的块决定集合。
+* @param cwd 工作区
+* @param entryId 条目身份
+* @param blocks 块决定
+* @returns 无
+*/
+function saveBlocks(cwd, entryId, blocks) {
+	const db = pendingDb(cwd);
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		db.prepare("DELETE FROM pending_blocks WHERE entry_id=?").run(entryId);
+		const insert = db.prepare("INSERT INTO pending_blocks VALUES(?,?,?)");
+		for (const block of blocks) insert.run(entryId, block.id, block.decision);
+		db.exec("COMMIT");
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 读取幂等操作记录；同 operationId 的重复请求必须复用结果。
+* @param cwd 工作区
+* @param operationId 操作身份
+* @returns 请求原文、状态与结果
+*/
+function readOp(cwd, operationId) {
+	const row = pendingDb(cwd).prepare("SELECT request,state,result FROM pending_ops WHERE operation_id=?").get(operationId);
+	return row ? {
+		request: String(row.request),
+		state: String(row.state),
+		result: row.result === null ? null : String(row.result)
+	} : void 0;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 记录一次操作的阶段与撤销快照。
+* @param cwd 工作区
+* @param operationId 操作身份
+* @param request 请求原文
+* @param state prepared / committed
+* @param payload 结果与撤销快照
+* @returns 无
+*/
+function writeOp(cwd, operationId, request, state, payload = {}) {
+	pendingDb(cwd).prepare(`INSERT INTO pending_ops VALUES(?,?,?,?,?)
+    ON CONFLICT(operation_id) DO UPDATE SET state=excluded.state,
+      result=COALESCE(excluded.result,pending_ops.result), undo=COALESCE(excluded.undo,pending_ops.undo)`).run(operationId, request, state, payload.result ?? null, payload.undo ?? null);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 追加一条撤销栈记录，并截断重做分支（新决定之后旧的"已撤销"记录不能再重做）。
+* @param cwd 工作区
+* @param kind 操作种类
+* @param entryId 涉及的条目
+* @param snapshot 可重放快照
+* @param now 时间
+* @returns 无
+*/
+function pushHistory(cwd, kind, entryId, snapshot, now) {
+	const db = pendingDb(cwd);
+	db.prepare("DELETE FROM pending_history WHERE state='undone'").run();
+	db.prepare("INSERT INTO pending_history(kind,entry_id,snapshot,created_at,state) VALUES(?,?,?,?,'applied')").run(kind, entryId, snapshot, now);
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 取最近一条仍生效的历史记录，撤销就作用在它上面。
+* @param cwd 工作区
+* @returns 记录或 undefined
+*/
+function latestApplied(cwd) {
+	const row = pendingDb(cwd).prepare("SELECT id,kind,entry_id,snapshot FROM pending_history WHERE state='applied' ORDER BY id DESC LIMIT 1").get();
+	return row ? rowOfHistory(row) : void 0;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 取最早一条被撤销的记录，重做按"撤销的逆序"重新生效。
+* @param cwd 工作区
+* @returns 记录或 undefined
+*/
+function earliestUndone(cwd) {
+	const row = pendingDb(cwd).prepare("SELECT id,kind,entry_id,snapshot FROM pending_history WHERE state='undone' ORDER BY id ASC LIMIT 1").get();
+	return row ? rowOfHistory(row) : void 0;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 翻转一条历史记录的生效状态。
+* @param cwd 工作区
+* @param id 记录主键
+* @param state applied / undone
+* @returns 无
+*/
+function setHistoryState(cwd, id, state) {
+	pendingDb(cwd).prepare("UPDATE pending_history SET state=? WHERE id=?").run(state, id);
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 把数据库行还原成历史记录。
+* @param row 数据库行
+* @returns 记录
+*/
+function rowOfHistory(row) {
+	return {
+		id: Number(row.id),
+		kind: String(row.kind),
+		entryId: String(row.entry_id),
+		snapshot: String(row.snapshot)
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 由数据库行还原条目。
+* @param row 数据库行
+* @returns 条目
+*/
+function entryOfRow(row) {
+	const lineage = row.lineage === null ? void 0 : JSON.parse(String(row.lineage));
+	const entry = {
+		id: String(row.id),
+		path: String(row.path),
+		earlierVersion: String(row.earlier) === "none" ? "none" : "file",
+		oldText: String(row.old_text),
+		newText: String(row.new_text),
+		updatedAt: Number(row.updated_at),
+		sessionId: String(row.session_id),
+		sessionIds: JSON.parse(String(row.session_ids))
+	};
+	if (Number(row.unseen) === 1) entry.unseen = true;
+	if (lineage !== void 0) entry.lineage = lineage;
+	return entry;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 由数据库行还原标记。
+* @param row 数据库行
+* @returns 标记
+*/
+function flagsOfRow(row) {
+	return {
+		missing: Number(row.missing) === 1,
+		diverged: Number(row.diverged) === 1,
+		oversized: Number(row.oversized) === 1,
+		revision: Number(row.revision)
+	};
+}
+//#endregion
+//#region src/pending/store.ts
+/**
+* @author ddj 2026年10月29号
+* @description: 统计一次差异的增删行数；非文本差异统一记 0/0。
+* @param entry 待审条目
+* @returns 增删行数
+*/
+function countsOf(entry) {
+	const diff = diffOf(entry);
+	if (diff.kind !== "text") return {
+		added: 0,
+		deleted: 0
+	};
+	let added = 0;
+	let deleted = 0;
+	for (const hunk of diff.hunks) for (const line of hunk.lines) if (line.startsWith("+")) added++;
+	else if (line.startsWith("-")) deleted++;
+	return {
+		added,
+		deleted
+	};
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 由当前累计条目现场推导块身份；块是差异的纯函数，落库的只是决定状态。
+* @param entry 累计条目
+* @returns 块状态列表（决定一律 pending，判定推进后由下一次推导自然收窄）
+*/
+function blockStatesOf(entry) {
+	const diff = diffOf(entry);
+	if (diff.kind !== "text") return [];
+	return reviewBlocks(diff).map((block) => ({
+		id: block.id,
+		decision: "pending"
+	}));
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 把一次已确认写入折进累计条目：同一身份只保留一条，基线留最早、内容取最新。
+* @param stored 已有条目（可为空）
+* @param write 采集到的写入
+* @returns 折叠后的条目与标记
+*/
+function foldWrite(stored, write) {
+	const fresh = entryFromNew({
+		id: write.identity,
+		path: write.path,
+		sessionId: write.sessionId,
+		earlierVersion: write.before === null ? "none" : "file",
+		oldText: write.before ?? "",
+		newText: write.after ?? "",
+		updatedAt: write.now
+	});
+	if (!stored) return {
+		entry: fresh,
+		flags: {
+			missing: write.after === null,
+			diverged: false,
+			oversized: false,
+			revision: 0
+		}
+	};
+	const merged = mergeEntries(stored.entry, fresh);
+	merged.path = write.path;
+	return {
+		entry: merged,
+		flags: {
+			missing: write.after === null,
+			diverged: false,
+			oversized: stored.flags.oversized,
+			revision: stored.flags.revision + 1
+		}
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 条目转列表投影，已解决条目仍保留但不可再决定。
+* @param stored 条目与标记
+* @returns 列表项
+*/
+function itemOf(stored) {
+	const { entry, flags } = stored;
+	const counts = countsOf(entry);
+	const item = {
+		id: entry.id,
+		path: entry.path,
+		earlierVersion: entry.earlierVersion,
+		added: counts.added,
+		deleted: counts.deleted,
+		settled: isSettled(entry),
+		unseen: entry.unseen === true,
+		missing: flags.missing,
+		diverged: flags.diverged,
+		oversized: flags.oversized,
+		revision: flags.revision,
+		updatedAt: entry.updatedAt,
+		sessionId: entry.sessionId,
+		sessionIds: entry.sessionIds
+	};
+	if (entry.lineage !== void 0) item.lineage = entry.lineage;
+	return item;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 读一页待审条目，按更新时间升序；会话过滤走血缘集合。
+* @param cwd 工作区
+* @param sessionId 当前会话
+* @returns 列表
+*/
+function loadPage(cwd, sessionId) {
+	const all = loadEntries(cwd);
+	const visible = sessionId ? all.filter((stored) => stored.entry.sessionIds.includes(sessionId)) : all;
+	const items = visible.map(itemOf);
+	const gaps = [];
+	for (const stored of visible) if (stored.flags.oversized) gaps.push(`${stored.entry.path}: 文本超出上限，仅保留标记`);
+	return {
+		items,
+		pending: items.filter((item) => !item.settled).length,
+		nextCursor: null,
+		gaps
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 读单条详情，包含可交给现有面板渲染的差异与块决定。
+* @param cwd 工作区
+* @param id 条目身份
+* @returns 详情，条目不存在时 null
+*/
+function loadDetail(cwd, id) {
+	const stored = loadEntries(cwd).find((item) => item.entry.id === id);
+	if (!stored) return null;
+	const diff = diffOf(stored.entry);
+	return {
+		item: itemOf(stored),
+		diff,
+		blocks: blockStatesOf(stored.entry),
+		capability: capabilityOf(stored.entry, stored.flags)
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 采集入口：折叠写入并落库。
+* @param write 已确认写入
+* @returns 无
+*/
+function recordWrite(write) {
+	const stored = loadEntries(write.cwd).find((item) => item.entry.id === write.identity);
+	if (stored && stored.entry.oldText === stored.entry.newText && stored.entry.newText === (write.after ?? "")) return;
+	saveEntry(write.cwd, foldWrite(stored, write));
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 外部改动吸收：当前内容与条目最新内容不同时采纳并标分歧，基线不动。
+* @param stored 条目
+* @param content 磁盘当前内容
+* @param now 时间
+* @returns 新条目与标记
+*/
+function absorbed(stored, content, now) {
+	return {
+		entry: {
+			...stored.entry,
+			newText: content,
+			updatedAt: now,
+			unseen: true
+		},
+		flags: {
+			...stored.flags,
+			diverged: true,
+			missing: false,
+			revision: stored.flags.revision + 1
+		}
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 读回磁盘并把可读的外部改动吸收进条目；缺失只标标记不删条目。
+* @param stored 条目
+* @param content 磁盘当前内容，null 表示缺失或不可读
+* @param now 时间
+* @returns 需要落库的新状态，无需改动时为 null
+*/
+function refreshed(stored, content, now) {
+	if (content === null) {
+		if (stored.flags.missing) return null;
+		return {
+			entry: stored.entry,
+			flags: {
+				...stored.flags,
+				missing: true,
+				revision: stored.flags.revision + 1
+			}
+		};
+	}
+	if (content === stored.entry.newText) {
+		if (!stored.flags.missing) return null;
+		return {
+			entry: stored.entry,
+			flags: {
+				...stored.flags,
+				missing: false,
+				revision: stored.flags.revision + 1
+			}
+		};
+	}
+	return absorbed(stored, content, now);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 构造带版本守卫与读回校验的写盘函数；内容已被外部改动时直接拒绝。
+* @param fs 文件系统
+* @param cwd 工作区
+* @param identity 目标身份
+* @param expected 写前应当具备的内容
+* @param signal 取消信号
+* @param policy 沙箱策略
+* @param allowCreate 文件已被删除时是否允许按快照重建（仅撤销/重做路径使用）
+* @returns 写盘函数
+*/
+function writerFor(fs, cwd, identity, expected, signal, policy, allowCreate = false) {
+	return async (content) => {
+		let target;
+		try {
+			target = await fs.resolve(identity, {
+				cwd,
+				signal
+			});
+		} catch {
+			return {
+				ok: false,
+				reason: "resolve-failed"
+			};
+		}
+		const current = await readText(fs, target).catch(() => void 0);
+		if (current === void 0) return {
+			ok: false,
+			reason: "read-failed"
+		};
+		if (!(allowCreate && current === null) && current !== expected) return {
+			ok: false,
+			reason: "diverged"
+		};
+		const currentStat = await fs.stat(target, signal).catch(() => void 0);
+		try {
+			await fs.writeText(target, content ?? "", currentStat ? {
+				kind: "replaceIfVersion",
+				version: currentStat.version
+			} : void 0, signal, policy);
+			const readBack = await readText(fs, target);
+			if ((content ?? "") !== (readBack ?? "")) return {
+				ok: false,
+				reason: "read-back-mismatch"
+			};
+			if (content === null && readBack !== null) return {
+				ok: false,
+				reason: "delete-failed"
+			};
+			return {
+				ok: true,
+				content
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				reason: reasonOf(error)
+			};
+		}
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 执行一次 Keep/Revert 并把结果落库；失败只返回原因，不写任何状态。
+* @param fs 文件系统
+* @param cwd 工作区
+* @param request 判定请求
+* @param signal 取消信号
+* @returns 判定结果
+*/
+async function applyDecide(fs, cwd, request, signal, policy) {
+	const stored = loadEntries(cwd).find((item) => item.entry.id === request.id);
+	if (!stored) return {
+		ok: false,
+		reason: "unknown-item"
+	};
+	const beforeBlocks = blockStatesOf(stored.entry);
+	const outcome = await decide({
+		request,
+		entry: stored.entry,
+		flags: stored.flags,
+		blocks: beforeBlocks,
+		now: Date.now(),
+		write: (content) => {
+			if (content === null) return deleteTarget(fs, cwd, stored.entry.id, signal);
+			return writerFor(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy)(content);
+		}
+	});
+	if (!outcome.ok) return {
+		ok: false,
+		reason: outcome.reason
+	};
+	saveEntry(cwd, {
+		entry: outcome.entry,
+		flags: outcome.flags
+	});
+	saveBlocks(cwd, request.id, outcome.blocks);
+	pushHistory(cwd, "decide", request.id, JSON.stringify({
+		before: {
+			entry: stored.entry,
+			flags: stored.flags,
+			blocks: beforeBlocks
+		},
+		after: {
+			entry: outcome.entry,
+			flags: outcome.flags,
+			blocks: outcome.blocks
+		},
+		wrote: outcome.wrote
+	}), Date.now());
+	return outcome;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 版本库导入：把工作副本相对基线的改动折进待审条目，已存在条目按折叠规则并入。
+* @param shell shell 能力
+* @param cwd 工作区
+* @param sessionId 触发导入的会话
+* @param options 导入选项
+* @returns 导入条数与探测到的改动数
+*/
+async function importFromVcs(shell, cwd, sessionId, options = {}) {
+	const changes = await importVcsChanges(shell, cwd, options);
+	const now = Date.now();
+	for (const change of changes) recordWrite({
+		cwd,
+		sessionId,
+		path: change.path,
+		identity: change.path,
+		before: change.earlierVersion === "none" ? null : change.oldText,
+		after: change.newText,
+		now
+	});
+	return {
+		imported: changes.length,
+		changes: changes.length
+	};
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 撤销或重做最近一次判定。先按 operationId 判幂等，再据栈顶记录判定方向是否合法，
+* 只有写盘过的判定才反向写盘，写盘失败时条目状态保持原样。
+* @param fs 文件系统
+* @param cwd 工作区
+* @param move 撤销/重做请求
+* @param signal 取消信号
+* @returns 结果条目与是否写盘
+*/
+async function undoDecide(fs, cwd, move, signal, policy) {
+	const replay = readOp(cwd, move.operationId);
+	if (replay && replay.state === "committed" && replay.result) return JSON.parse(replay.result);
+	const record = move.direction === "undo" ? latestApplied(cwd) : earliestUndone(cwd);
+	if (!record) return {
+		ok: false,
+		reason: move.direction === "undo" ? "no-undo" : "no-redo"
+	};
+	const snapshot = parseSnapshot(record.snapshot);
+	if (!snapshot) return {
+		ok: false,
+		reason: "bad-history"
+	};
+	const stored = loadEntries(cwd).find((item) => item.entry.id === record.entryId);
+	if (!stored) return {
+		ok: false,
+		reason: "unknown-item"
+	};
+	const target = move.direction === "undo" ? snapshot.before : snapshot.after;
+	writeOp(cwd, move.operationId, JSON.stringify(move), "prepared");
+	let wrote = false;
+	if (snapshot.wrote) {
+		const result = await writeBack(fs, cwd, stored, target, signal, policy);
+		if (!result.ok) return {
+			ok: false,
+			reason: result.reason
+		};
+		wrote = true;
+	}
+	saveEntry(cwd, {
+		entry: target.entry,
+		flags: target.flags
+	});
+	saveBlocks(cwd, record.entryId, target.blocks);
+	setHistoryState(cwd, record.id, move.direction === "undo" ? "undone" : "applied");
+	const outcome = {
+		ok: true,
+		item: itemOf({
+			entry: target.entry,
+			flags: target.flags
+		}),
+		wrote
+	};
+	writeOp(cwd, move.operationId, JSON.stringify(move), "committed", { result: JSON.stringify(outcome) });
+	return outcome;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 把文件内容恢复到目标快照：目标为缺失则删除，否则按版本守卫写回并读回校验。
+* @param fs 文件系统
+* @param cwd 工作区
+* @param stored 当前条目
+* @param target 目标快照
+* @param signal 取消信号
+* @returns 写盘结果
+*/
+async function writeBack(fs, cwd, stored, target, signal, policy) {
+	if (target.flags.missing) return deleteTarget(fs, cwd, stored.entry.id, signal);
+	return writerFor(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy, true)(target.entry.newText);
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 解析历史快照；损坏时返回 null，不猜测内容。
+* @param text 快照文本
+* @returns 快照或 null
+*/
+function parseSnapshot(text) {
+	try {
+		const parsed = JSON.parse(text);
+		if (!parsed?.before?.entry || !parsed?.after?.entry) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+/**
+* @author ddj 2026年10月29号
+* @description: Revert 的删除分支：FileSystem 抽象没有删除能力，只有确认仍在工作区内才用宿主 unlink。
+* @param fs 文件系统
+* @param cwd 工作区
+* @param identity 目标身份
+* @param signal 取消信号
+* @returns 删除结果
+*/
+async function deleteTarget(fs, cwd, identity, signal) {
+	let target;
+	try {
+		target = await fs.resolve(identity, {
+			cwd,
+			signal
+		});
+	} catch {
+		return {
+			ok: false,
+			reason: "resolve-failed"
+		};
+	}
+	if (!await fs.stat(target, signal).catch(() => void 0)) return {
+		ok: true,
+		content: null
+	};
+	const absolute = String(fs.processPath(target));
+	if (!insideWorkspace(cwd, absolute)) return {
+		ok: false,
+		reason: "outside-workspace"
+	};
+	try {
+		await unlink(absolute);
+	} catch (error) {
+		return {
+			ok: false,
+			reason: reasonOf(error)
+		};
+	}
+	return await fs.stat(target, signal).catch(() => void 0) ? {
+		ok: false,
+		reason: "delete-failed"
+	} : {
+		ok: true,
+		content: null
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 判断宿主路径是否位于工作区内，Windows 下按大小写不敏感比较。
+* @param cwd 工作区
+* @param absolute 目标绝对路径
+* @returns 是否在工作区内
+*/
+function insideWorkspace(cwd, absolute) {
+	const root = resolve(cwd);
+	const candidate = resolve(absolute);
+	const normalize = (value) => process.platform === "win32" ? value.toLowerCase() : value;
+	const rootKey = normalize(root).endsWith(sep) ? normalize(root) : normalize(root) + sep;
+	return normalize(candidate).startsWith(rootKey);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 从列表移除已解决条目；未解决条目拒绝移除，避免表里看不到却被删掉。
+* @param cwd 工作区
+* @param id 条目身份
+* @param revision 并发校验版本
+* @returns 是否移除
+*/
+function removeEntry(cwd, id, revision) {
+	const stored = loadEntries(cwd).find((item) => item.entry.id === id);
+	if (!stored || stored.flags.revision !== revision || !isSettled(stored.entry)) return false;
+	dropEntry(cwd, id);
+	return true;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 取错误码用于拒绝原因，没有则回落到消息文本。
+* @param error 抛出的错误
+* @returns 原因字符串
+*/
+function reasonOf(error) {
+	const code = error.code;
+	return typeof code === "string" ? code : String(error);
+}
+//#endregion
+//#region src/shared/pathKey.ts
+/**
+* 路径比较口径：Host 与客户端共用同一套「远端 / 盘符 / 相对路径」判定，只在平台折叠上分工。
+* @author ddj 2026年10月30号
+*/
+/** 远端仓库身份：`scheme://...` 区分大小写，绝不能折叠。 */
+const REMOTE = /^[a-z]+:\/\//i;
+/** 盘符绝对路径：大小写不敏感与宿主平台无关，两边都必须折叠。 */
+const DRIVE = /^[a-z]:\//i;
+/**
+* @author ddj 2026年10月30号
+* @description: 统一分隔符为 `/`，其余字符原样保留。
+* @param path 原始路径
+* @returns 反斜杠已归一化的路径
+*/
+function unifiedPath(path) {
+	return path.replace(/\\/g, "/");
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 生成路径比较键。盘符路径恒折叠大小写；其余路径是否折叠由调用方按运行平台决定
+* （Host 在 Windows 上折叠，客户端不在宿主进程里，取 false）。
+* @param path 原始路径
+* @param foldCase 非盘符路径是否折叠大小写
+* @returns 比较键
+*/
+function pathKeyFor(path, foldCase) {
+	const unified = unifiedPath(path);
+	if (REMOTE.test(unified)) return unified;
+	if (DRIVE.test(unified)) return unified.toLowerCase();
+	return foldCase ? unified.toLowerCase() : unified;
+}
+//#endregion
+//#region src/shared/pendingReview.ts
+/** 待审条目在面板列表里的 id 前缀；客户端与 Host 共用这一份口径。 */
+const PENDING_PREFIX = "pending:";
+//#endregion
+//#region src/pendingCompat.ts
+/** 进程内"已被待审接管"的路径集合；旧写入口守卫只读它，绝不碰数据库。 */
+const coveredPaths = /* @__PURE__ */ new Set();
+/**
+* @author ddj 2026年10月29号
+* @description: 由条目 id 派生稳定序号，保证轮询期间面板锚点不跳。
+* @param id 待审条目身份
+* @returns 正整数序号
+*/
+function stableSeq(id) {
+	let hash = 2166136261;
+	for (let index = 0; index < id.length; index++) {
+		hash ^= id.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return Math.abs(hash) % 2147483647 + 1;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: Host 侧的路径比较口径：远端身份保留大小写，其余按运行平台折叠。
+* @param path 路径
+* @returns 比较键
+*/
+function pathKey$1(path) {
+	return pathKeyFor(path, process.platform === "win32");
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 判断两个路径是否指同一文件：比较键相同，或一方是另一方的工作区相对写法。
+* 面板传下来的路径可能是相对路径，而条目里存的是绝对路径。
+* @param left 路径
+* @param right 路径
+* @returns 是否同一文件
+*/
+function pendingSamePath(left, right) {
+	const a = pathKey$1(left);
+	const b = pathKey$1(right);
+	if (!a || !b) return false;
+	return a === b || a.endsWith("/" + b) || b.endsWith("/" + a);
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 列表里的条目 id 带待审前缀用于区分通道，内核按原始身份存取，这里统一还原。
+* @param id 请求里的条目 id
+* @returns 待审内核使用的原始 id
+*/
+function pendingRawId(id) {
+	return id.startsWith("pending:") ? id.slice(8) : id;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 列表显示用的短路径：工作区内显示相对路径，区外保留原文。
+* @param cwd 工作区
+* @param path 条目路径
+* @returns 显示用路径
+*/
+function pendingDisplay(cwd, path) {
+	const root = cwd.replace(/[\\/]+$/, "");
+	const unified = path.replace(/\\/g, "/");
+	const base = root.replace(/\\/g, "/");
+	if (base && (unified === base || unified.toLowerCase().startsWith(base.toLowerCase() + "/"))) return unified.slice(base.length + 1);
+	return path;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 待审条目转面板列表项。
+* @param item 待审条目
+* @param cwd 工作区，用于显示相对路径；缺省显示原始路径
+* @returns 面板列表项
+*/
+function pendingItemOf(item, cwd) {
+	return {
+		id: PENDING_PREFIX + item.id,
+		sessionId: item.sessionId,
+		turn: 0,
+		seq: stableSeq(item.id),
+		path: item.path,
+		currentPath: item.path,
+		display: cwd ? pendingDisplay(cwd, item.path) : item.path,
+		added: item.added,
+		deleted: item.deleted,
+		kind: item.oversized ? "oversized" : "text",
+		decision: item.settled ? "accepted" : "pending",
+		revision: item.revision,
+		current: true
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 待审详情转面板详情；Revert 映射到面板的 Undo 能力位。
+* @param detail 待审详情
+* @param capturedAt 采集时间文案
+* @returns 面板详情
+*/
+function pendingDetailOf(detail, capturedAt, cwd) {
+	return {
+		item: pendingItemOf(detail.item, cwd),
+		diff: detail.diff,
+		capturedAt,
+		blocks: detail.blocks,
+		capability: {
+			keep: detail.capability.keep,
+			undo: detail.capability.revert,
+			reason: detail.capability.reason
+		}
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 记住/忘记"该路径由待审投影接管"。进程内集合，绝不在旧写入口上查库（避免撞上写事务锁）。
+* @param cwd 工作区
+* @param path 路径
+* @param covered 是否接管
+* @returns 无
+*/
+function trackPendingCover(cwd, path, covered) {
+	const key = `${pathKey$1(cwd)}|${pathKey$1(path)}`;
+	if (covered) coveredPaths.add(key);
+	else coveredPaths.delete(key);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 判断某路径是否已由待审投影接管；仅读进程内集合，不产生任何 IO。
+* @param cwd 工作区
+* @param path 请求路径
+* @returns 是否已被接管
+*/
+function pendingCovers(cwd, path) {
+	return coveredPaths.has(`${pathKey$1(cwd)}|${pathKey$1(path)}`);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 合并官方页与待审页：待审覆盖的路径从官方结果中剔除，其余原样保留。
+* @param official 官方页
+* @param pending 待审页
+* @param cwd 工作区，用于把待审行显示成相对路径
+* @returns 合并后的页
+*/
+function mergedPage(official, pending, cwd) {
+	const covered = new Set(pending.items.map((item) => pathKey$1(item.path)));
+	const kept = official.items.filter((item) => !covered.has(pathKey$1(item.currentPath)) && !covered.has(pathKey$1(item.path)));
+	return {
+		items: [...pending.items.map((item) => pendingItemOf(item, cwd)), ...kept],
+		pending: pending.pending + kept.filter((item) => item.decision === "pending").length,
+		nextCursor: official.nextCursor,
+		gaps: official.gaps,
+		...official.overview ? { overview: official.overview } : {}
+	};
+}
+//#endregion
+//#region src/search/query.ts
+/**
+* 规范化用户搜索文本。
+* @author ddj 2026年08月24号
+* @param raw 原始搜索文本
+* @returns 用于比较和缓存的 query
+*/
+function prepareQuery(raw) {
+	const value = String(raw ?? "").trim();
+	return {
+		raw: value,
+		text: value.replaceAll("\\", "/").toLocaleLowerCase("en-US")
+	};
+}
+/**
+* 归一化路径分隔符并移除无意义前缀。
+* @author ddj 2026年08月24号
+* @param value 原始路径
+* @returns 比较用路径
+*/
+function pathText(value) {
+	return value.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+/**
+* 生成不区分大小写的路径 key。
+* @author ddj 2026年08月24号
+* @param value 原始路径
+* @returns 去重 key
+*/
+function pathKey(value) {
+	return pathText(value).toLocaleLowerCase("en-US");
+}
+/**
+* @public
+* @author ddj 2026年10月14号
+* @description 按顺序匹配不连续字符；每个位置最多消费一次。
+* @param value 已归一化候选文本
+* @param text 已归一化查询文本
+* @returns 是否完整匹配所有查询字符
+*/
+function subsequence(value, text) {
+	let offset = 0;
+	for (const char of text) {
+		const index = value.indexOf(char, offset);
+		if (index < 0) return false;
+		offset = index + char.length;
+	}
+	return true;
+}
+/**
+* @public
+* @author ddj 2026年10月14号
+* @description 连续匹配相对路径，或对无目录查询模糊匹配文件名。
+* @param value 文件路径（调用方移除工作区根前缀）
+* @param query 已规范化 query
+* @returns 是否命中；空查询不命中
+*/
+function pathMatch(value, query) {
+	if (!query.text) return false;
+	const path = pathText(value).toLocaleLowerCase("en-US");
+	if (path.includes(query.text)) return true;
+	if (query.text.includes("/")) return false;
+	return subsequence(path.slice(path.lastIndexOf("/") + 1), query.text);
+}
+//#endregion
+//#region src/search/ripgrep.ts
+/**
+* dsh-vscode-mode host — ripgrep 文件发现 provider。
+* 通过独立 argv 调用打包 rg，避免先构建巨型全量文件数组。
+* 作者 ddj 2026年08月24号
+*/
+const STDOUT_CAP$1 = 4 << 20;
+const STDERR_CAP$2 = 65536;
+const GRACE_MS$1 = 2e4;
+/**
+* 默认排除目录（文件/内容搜索共用，导出供 provider 复用）。
+* 语义为**大小写敏感**的路径段匹配：`build` 只排除小写构建产物目录，
+* 不得用 `--glob-case-insensitive` 之类的全局开关，「Module/Build」这类
+* 源码目录（如 IslandSplash 的 Module/Build/Logic）必须保持可搜索。
+*/
+const EXCLUDES = [
+	"node_modules",
+	".git",
+	".tmp",
+	".cache",
+	"dist",
+	"build",
+	"vendor",
+	"coverage",
+	"__pycache__",
+	".pnpm-store",
+	".npm-cache",
+	".codegraph",
+	".workbuddy"
+];
+/**
+* 默认排除文件（glob 模式，文件/内容搜索共用）。
+* 插件自身 sidecar（内容搜索会命中其历史编辑文本，且单行巨型 JSON 会撑爆输出上限）；
+* *.map 源映射（纯构建产物，内容搜索无意义且常为单行巨文件）。
+*/
+const FILE_EXCLUDES = [
+	"**/.dsh-edit-review.json",
+	"**/.dsh-edit-review-archive.json",
+	"**/.dsh-edit-review-debug.log",
+	"**/*.map"
+];
+/**
+* 将查询文本转成大小写不敏感的 rg 正选 glob。
+* 逐字符把有大小写的字母展开成 `[aA]` 字符类，**不用**大小写不敏感开关：
+* ① 全局 `--glob-case-insensitive` 会把 `-g/--glob` 全部当成 `--iglob`，
+*    连带让 `!**\/build/**` 大小写不敏感，从而排除 `Module/Build/` 这类源码目录
+*    （Ctrl+P 搜 BuildLogic 恒「无匹配文件」）；
+* ② 把查询词改用 `--iglob` 也不行——rg 的正选 glob 会覆盖全部黑名单 glob，
+*    node_modules/.git 等排除项集体失效。
+* 字符类方案同时满足「查询不区分大小写」且「排除项保持大小写敏感」。
+* @author ddj 2026年08月24号 / 2026年09月20号
+* @param query 已规范化查询文本
+* @returns 安全 glob
+*/
+function queryGlob(query) {
+	return "**/*" + Array.from(pathText(query), globChar).join("") + "*";
+}
+/**
+* @private
+* @author ddj 2026年10月14号
+* @description 将字面字符转为安全且大小写不敏感的 glob 片段。
+* @param char 单个 Unicode 字符
+* @returns 转义字符或大小写字符类
+*/
+function globChar(char) {
+	const lower = char.toLowerCase();
+	const upper = char.toUpperCase();
+	if (lower !== upper && lower.length === 1 && upper.length === 1) return "[" + lower + upper + "]";
+	return /[\*?\[\]{}!]/.test(char) ? "\\" + char : char;
+}
+/**
+* @public
+* @author ddj 2026年10月14号
+* @description 构造仅匹配文件名的有序子序列 glob，不让星号跨目录。
+* @param query 无目录的字面查询文本
+* @returns 模糊 glob；空查询或带目录时返回 null
+*/
+function fuzzyGlob(query) {
+	const value = pathText(query);
+	if (!value || value.includes("/")) return null;
+	return "**/*" + Array.from(value, globChar).join("*") + "*";
+}
+/**
+* 返回当前平台的 rg 可执行文件路径，不让可选依赖影响模块加载。
+* @author ddj 2026年08月24号
+* @returns rg 路径或 null
+*/
+function ripgrepPath() {
+	try {
+		const ripgrep = createRequire(import.meta.url)("@vscode/ripgrep");
+		if (typeof ripgrep.rgPath !== "string" || !existsSync(ripgrep.rgPath)) return null;
+		return join(ripgrep.rgPath);
+	} catch (error) {
+		return null;
+	}
+}
+/**
+* 解析会话搜索根目录，并转换到 subprocess 执行世界。
+* @author ddj 2026年08月24号
+* @param ctx DSH 上下文
+* @param session 当前会话
+* @returns subprocess 可访问的根目录
+*/
+async function searchRoot(ctx, session) {
+	const fs = ctx.get("fs");
+	if (!fs) throw new Error("缺少 fs");
+	const policy = policyOf(ctx, session);
+	const cwd = cwdOfSession(ctx, session);
+	const rootTarget = await fs.resolve(policy?.workspaceRoot ?? ".", cwd ? { cwd } : {});
+	return fs.processPath(rootTarget);
+}
+/**
+* 读取收集输出并解析为路径候选。
+* @author ddj 2026年08月24号
+* @param handle subprocess handle
+* @param maxResults 候选上限
+* @returns 路径与完整性状态
+*/
+function parseOutput(handle, maxResults) {
+	const reader = handle.collected?.stdout;
+	if (!reader) return {
+		files: [],
+		truncated: false,
+		complete: false
+	};
+	const output = reader.readFrom(0);
+	const values = output.text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	const unique = [...new Set(values)];
+	const truncated = Boolean(output.lossy) || unique.length > maxResults;
+	return {
+		files: unique.slice(0, maxResults).map(pathText),
+		truncated,
+		complete: !truncated
+	};
+}
+/**
+* 读取已收集的 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/)) {
@@ -10132,6 +12267,131 @@ function installRulesSection(ctx, dirs = userRuleDirs()) {
 	return true;
 }
 //#endregion
+//#region src/skillCatalog.ts
+/**
+* dsh-vscode-mode host — 技能候选枚举（全局技能 + 当前工作区技能）。
+*
+* 为什么要另起一条通道：本插件原有的 `skills.ts` 只管「随包分发的技能组」
+* （<包根>/skills，按 SKILL_PREFIXES 前缀白名单过滤）；而快捷菜单「绑定技能」需要的是
+* 用户能自由增删的两类技能目录，与 DSH 文件系统 skill provider 的两个根一致：
+* - 全局技能：`$DSH_HOME/skills`（provider rank 400 / user-dsh）
+* - 工作区技能：`<projectRoot>/.dsh/skills`（provider rank 100 / project-dsh）
+* 只读、不写盘、不缓存：每次打开配置弹窗重扫一遍（目录数量级很小）。
+*
+* 作者 ddj 2026年10月30号
+*/
+/** 单个根目录最多枚举的技能数（防失控目录拖垮弹窗）。 */
+const SKILL_CATALOG_CAP = 200;
+/** 向上找项目根的层数上限（防异常路径下的长链遍历）。 */
+const ROOT_DEPTH_CAP = 8;
+/** 目录式技能的清单文件名。 */
+const SKILL_FILE = "SKILL.md";
+/**
+* 从 cwd 向上找项目根（含 .git 的最近祖先；找不到回落 cwd）。
+* @author ddj 2026年10月30号
+* @param cwd 起始目录
+* @returns 项目根绝对路径；cwd 缺失时 undefined
+*/
+function projectRootOf(cwd) {
+	if (cwd === void 0 || cwd === "") return void 0;
+	let current = cwd;
+	for (let depth = 0; depth < ROOT_DEPTH_CAP; depth += 1) {
+		const parent = join(current, "..");
+		if (entryExists(join(current, ".git"))) return current;
+		if (parent === current) break;
+		current = parent;
+	}
+	return cwd;
+}
+/**
+* 探测路径是否存在（同步存在性判断，避免为一次 up-walk 引入异步瀑布）。
+* @author ddj 2026年10月30号
+* @param path 绝对路径
+* @returns 存在为 true
+*/
+function entryExists(path) {
+	try {
+		statSync(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 技能根目录（全局 + 当前工作区）。
+* @author ddj 2026年10月30号
+* @param cwd 当前工作区
+* @returns 两个根的绝对路径
+*/
+function skillRootsOf(cwd) {
+	const projectRoot = projectRootOf(cwd);
+	const project = projectRoot === void 0 ? "" : join(projectRoot, ".dsh", "skills");
+	return {
+		user: join(dshHome(), "skills"),
+		project,
+		projectRoot
+	};
+}
+/**
+* 扫描单个技能根（深度 1：<root>/<名>/SKILL.md 或 <root>/<名>.md）。
+* 目录缺失/读失败/frontmatter 非法 → 跳过该条（不抛、不返回半成品）。
+* @author ddj 2026年10月30号
+* @param dir 技能根目录
+* @param source 来源标记
+* @returns 通过校验的技能（按名字排序，受 SKILL_CATALOG_CAP 约束）
+*/
+async function listRootSkills(dir, source) {
+	if (dir === "") return [];
+	const ordered = [...await readdir(dir, { withFileTypes: true }).catch(() => [])].sort((left, right) => left.name.localeCompare(right.name)).slice(0, SKILL_CATALOG_CAP);
+	const found = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of ordered) {
+		const info = await readSkillInfo(entry.name.endsWith(".md") ? join(dir, entry.name) : join(dir, entry.name, SKILL_FILE), source).catch(() => void 0);
+		if (info === void 0 || seen.has(info.name)) continue;
+		seen.add(info.name);
+		found.push(info);
+	}
+	return found.sort((left, right) => left.name.localeCompare(right.name));
+}
+/**
+* 读取并解析单个技能文件。
+* @author ddj 2026年10月30号
+* @param file 技能文件绝对路径
+* @param source 来源标记
+* @returns 技能元信息；文件缺失/不可读/frontmatter 非法时 undefined
+*/
+async function readSkillInfo(file, source) {
+	const text = await readFile(file, "utf8").catch(() => void 0);
+	if (text === void 0) return void 0;
+	const parsed = parseSkillMd(text);
+	if (!isParsedSkill(parsed)) return void 0;
+	return {
+		name: parsed.name,
+		description: parsed.description,
+		path: file,
+		source
+	};
+}
+/**
+* 枚举技能候选（全局 + 当前工作区；只读，永不抛）。
+* @author ddj 2026年10月30号
+* @param cwd 当前工作区（缺失时只枚举全局根）
+* @returns 技能候选快照
+*/
+async function listSkillCatalog(cwd) {
+	const roots = skillRootsOf(cwd);
+	const user = await listRootSkills(roots.user, "user");
+	const project = await listRootSkills(roots.project, "project");
+	return roots.projectRoot === void 0 ? {
+		user,
+		project
+	} : {
+		user,
+		project,
+		projectRoot: roots.projectRoot
+	};
+}
+//#endregion
 //#region src/snippets.ts
 /**
 * dsh-vscode-mode host — 代码片段管理（VS Code 兼容 .code-snippets 文件）。
@@ -10464,29 +12724,610 @@ async function snippetsRemove(ctx, ref) {
 	await rm(join(dir, ref.file), { force: true });
 }
 /**
-* 补全 provider 载荷：全局片段 + 指定工作区项目片段的全部条目。
-* 项目条目排在全局之后（同 key 时后出现的项目条目在 client 侧优先）。
-* @author ddj 2026年09月10号
-* @param ctx DSH 上下文
-* @param workspacePath 当前会话工作区（可选；未注册则仅全局片段）
-* @returns snippets.entries 载荷
-*/
-async function snippetsEntries(ctx, workspacePath) {
-	const loaded = [];
-	const load = async (dir, scope) => {
-		for (const info of await listSnippetsDir(dir, scope)) {
-			const parsed = parseSnippetsJson(await readFile(info.absPath, "utf8").catch(() => ""));
-			if (parsed.error) continue;
-			loaded.push({
-				info,
-				parsed
-			});
+* 补全 provider 载荷：全局片段 + 指定工作区项目片段的全部条目。
+* 项目条目排在全局之后（同 key 时后出现的项目条目在 client 侧优先）。
+* @author ddj 2026年09月10号
+* @param ctx DSH 上下文
+* @param workspacePath 当前会话工作区（可选；未注册则仅全局片段）
+* @returns snippets.entries 载荷
+*/
+async function snippetsEntries(ctx, workspacePath) {
+	const loaded = [];
+	const load = async (dir, scope) => {
+		for (const info of await listSnippetsDir(dir, scope)) {
+			const parsed = parseSnippetsJson(await readFile(info.absPath, "utf8").catch(() => ""));
+			if (parsed.error) continue;
+			loaded.push({
+				info,
+				parsed
+			});
+		}
+	};
+	await load(userSnippetsDir(), "user");
+	const registered = workspaceList(ctx).some((item) => item.path === workspacePath);
+	if (workspacePath && registered) await load(projectSnippetsDir(workspacePath), "project");
+	return { entries: flattenSnippetEntries(loaded) };
+}
+/** 提示词长度上限。 */
+const QUICK_MENU_PROMPT_CAP = 8192;
+/** 技能名合法形态。 */
+const QUICK_MENU_SKILL_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** 未命名项兜底名。 */
+const FALLBACK_NAME = "未命名";
+/**
+* 数值夹取（NaN/非有限回落到 fallback）。
+* @author ddj 2026年10月30号
+* @param value 原始值
+* @param min 下限
+* @param max 上限
+* @param fallback 非法值兜底
+* @returns 夹取后的数值
+*/
+function clampNumber(value, min, max, fallback) {
+	const number = typeof value === "number" && Number.isFinite(value) ? value : fallback;
+	if (number < min) return min;
+	if (number > max) return max;
+	return number;
+}
+/**
+* 取对象形态（非对象/数组返回 null）。
+* @author ddj 2026年10月30号
+* @param value 原始值
+* @returns 普通对象或 null
+*/
+function asRecord$1(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	return value;
+}
+/**
+* 取字符串（非字符串回落空串）。
+* @author ddj 2026年10月30号
+* @param value 原始值
+* @returns 字符串
+*/
+function asString$1(value) {
+	return typeof value === "string" ? value : "";
+}
+/**
+* 文本截断（超长补省略号）。
+* @author ddj 2026年10月30号
+* @param text 原文
+* @param cap 上限字符数
+* @returns 截断后文本
+*/
+function cutText(text, cap) {
+	if (text.length <= cap) return text;
+	return text.slice(0, Math.max(0, cap - 1)) + "…";
+}
+/**
+* 归一化工作区路径（统一分隔符、去尾分隔符、win32 转小写），用于比较而非展示。
+* @author ddj 2026年10月30号
+* @param path 原始路径
+* @returns 归一化路径
+*/
+function normalizePath(path) {
+	const unified = path.trim().replace(/\//g, "\\").replace(/\\+$/, "");
+	if (unified === "") return "";
+	return unified.toLowerCase();
+}
+/**
+* 默认文档（首次打开菜单时的初始状态）。
+* @author ddj 2026年10月30号
+* @returns 默认文档
+*/
+function defaultDoc() {
+	return {
+		version: 1,
+		revision: 0,
+		updatedAt: "",
+		enabled: true,
+		clickAction: "send",
+		maxDepth: 3,
+		launcher: {
+			x: null,
+			y: null
+		},
+		items: []
+	};
+}
+/**
+* 归一化限定工作区列表（去空、去重、归一化；空结果回落到 null=全部）。
+* @author ddj 2026年10月30号
+* @param raw 原始值
+* @returns 限定列表或 null
+*/
+function normalizeWorkspaces(raw) {
+	if (!Array.isArray(raw)) return null;
+	const out = [];
+	for (const entry of raw) {
+		if (typeof entry !== "string") continue;
+		const normalized = normalizePath(entry);
+		if (normalized === "") continue;
+		if (out.includes(normalized)) continue;
+		out.push(normalized);
+	}
+	return out.length > 0 ? out : null;
+}
+/**
+* 绑定规则的稳定键（校验、去重、内联正文映射共用）。
+* @author ddj 2026年10月30号
+* @param binding 规则绑定
+* @returns 键
+*/
+function bindingKey(binding) {
+	const workspace = normalizePath(binding.workspacePath ?? "");
+	return binding.scope + "|" + workspace + "|" + binding.file;
+}
+/**
+* 归一化单条规则绑定（scope/file 必填，项目规则必须带工作区）。
+* @author ddj 2026年10月30号
+* @param raw 原始值
+* @returns 绑定或 null
+*/
+function normalizeRule(raw) {
+	const record = asRecord$1(raw);
+	if (!record) return null;
+	const file = asString$1(record.file).trim();
+	if (file === "") return null;
+	const scope = record.scope === "project" ? "project" : "user";
+	const binding = {
+		scope,
+		file
+	};
+	if (scope === "project") {
+		const workspacePath = asString$1(record.workspacePath).trim();
+		if (workspacePath === "") return null;
+		binding.workspacePath = workspacePath;
+	}
+	if (record.origin === "current" || record.origin === "legacy") binding.origin = record.origin;
+	return binding;
+}
+/**
+* 归一化规则绑定列表（去重 + 上限）。
+* @author ddj 2026年10月30号
+* @param raw 原始值
+* @returns 绑定列表
+*/
+function normalizeRules(raw) {
+	if (!Array.isArray(raw)) return [];
+	const out = [];
+	for (const entry of raw) {
+		const binding = normalizeRule(entry);
+		if (!binding) continue;
+		if (out.some((existing) => bindingKey(existing) === bindingKey(binding))) continue;
+		out.push(binding);
+	}
+	return out.slice(0, 24);
+}
+/**
+* 归一化技能名列表（只保留 kebab-case，去重 + 上限）。
+* @author ddj 2026年10月30号
+* @param raw 原始值
+* @returns 技能名列表
+*/
+function normalizeSkills(raw) {
+	if (!Array.isArray(raw)) return [];
+	const out = [];
+	for (const entry of raw) {
+		if (typeof entry !== "string") continue;
+		const name = entry.trim();
+		if (name === "" || !QUICK_MENU_SKILL_RE.test(name)) continue;
+		if (out.includes(name)) continue;
+		out.push(name);
+	}
+	return out.slice(0, 24);
+}
+/**
+* 归一化单个菜单项（非法类型/缺 id 返回 null）。
+* @author ddj 2026年10月30号
+* @param raw 原始值
+* @returns 菜单项或 null
+*/
+function normalizeItem(raw) {
+	const record = asRecord$1(raw);
+	if (!record) return null;
+	const type = record.type === "group" ? "group" : "button";
+	const id = asString$1(record.id).trim();
+	if (id === "") return null;
+	const name = cutText(asString$1(record.name).trim() || FALLBACK_NAME, 40);
+	const order = clampNumber(record.order, 0, 999, 100);
+	const rawParent = record.parentId;
+	const base = {
+		id,
+		type,
+		name,
+		order,
+		parentId: typeof rawParent === "string" && rawParent.trim() !== "" ? rawParent.trim() : null,
+		workspaces: normalizeWorkspaces(record.workspaces)
+	};
+	if (type === "group") return {
+		...base,
+		type: "group"
+	};
+	const button = {
+		...base,
+		type: "button",
+		prompt: cutText(asString$1(record.prompt), QUICK_MENU_PROMPT_CAP),
+		skills: normalizeSkills(record.skills),
+		rules: normalizeRules(record.rules),
+		ruleMode: record.ruleMode === "inline" ? "inline" : "reference"
+	};
+	if (record.clickAction === "send" || record.clickAction === "fill") button.clickAction = record.clickAction;
+	return button;
+}
+/**
+* 判断从起点上溯的父链是否会回到目标项（环检测；超深链也按非法处理）。
+* @author ddj 2026年10月30号
+* @param byId id → 项
+* @param startId 起点父 id
+* @param targetId 目标项 id
+* @returns 是否成环
+*/
+function chainHas(byId, startId, targetId) {
+	let current = startId;
+	let guard = 0;
+	while (current !== null) {
+		if (current === targetId) return true;
+		if (guard > 7) return true;
+		const parent = byId.get(current);
+		if (!parent) return false;
+		current = parent.parentId;
+		guard += 1;
+	}
+	return false;
+}
+/**
+* 修补父链问题：父不存在/父是按钮/自指/形成环时把子项上抬到最近合法祖组或顶层。
+* @author ddj 2026年10月30号
+* @param items 归一化后的项
+* @returns 修补后的项
+*/
+function repairParents(items) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const item of items) byId.set(item.id, item);
+	for (const item of items) {
+		let resolved = item.parentId;
+		let guard = 0;
+		while (resolved !== null && guard <= 7) {
+			const parent = byId.get(resolved);
+			if (!parent) {
+				resolved = null;
+				break;
+			}
+			if (parent.type === "group") break;
+			resolved = parent.parentId;
+			guard += 1;
+		}
+		if (resolved !== null && chainHas(byId, resolved, item.id)) resolved = null;
+		item.parentId = resolved;
+	}
+	return items;
+}
+/**
+* 按父级分组重排优先级（order 归一为 10/20/30…，保证展示稳定且无并列）。
+* @author ddj 2026年10月30号
+* @param items 菜单项
+* @returns 同一数组（就地写入 order）
+*/
+function normalizeOrder(items) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = item.parentId ?? "";
+		const bucket = groups.get(key);
+		if (bucket) bucket.push(item);
+		else groups.set(key, [item]);
+	}
+	for (const bucket of groups.values()) {
+		bucket.sort((left, right) => {
+			if (left.order !== right.order) return left.order - right.order;
+			if (left.name !== right.name) return left.name < right.name ? -1 : 1;
+			return left.id < right.id ? -1 : 1;
+		});
+		bucket.forEach((item, index) => {
+			item.order = (index + 1) * 10;
+		});
+	}
+	return items;
+}
+/**
+* 归一化整份文档（任何脏数据都收敛到可用形态，绝不抛错）。
+* @author ddj 2026年10月30号
+* @param raw 原始值（JSON.parse 结果或任意 unknown）
+* @returns 合法文档
+*/
+function normalizeDoc(raw) {
+	const fallback = defaultDoc();
+	const record = asRecord$1(raw);
+	if (!record) return fallback;
+	const rawItems = Array.isArray(record.items) ? record.items : [];
+	const seen = /* @__PURE__ */ new Set();
+	const items = [];
+	for (const entry of rawItems) {
+		const item = normalizeItem(entry);
+		if (!item || seen.has(item.id)) continue;
+		seen.add(item.id);
+		items.push(item);
+		if (items.length >= 200) break;
+	}
+	const x = typeof record.launcher === "object" && record.launcher !== null ? asRecord$1(record.launcher) : null;
+	return {
+		version: 1,
+		revision: Math.floor(clampNumber(record.revision, 0, Number.MAX_SAFE_INTEGER, 0)),
+		updatedAt: cutText(asString$1(record.updatedAt), 40),
+		enabled: typeof record.enabled === "boolean" ? record.enabled : true,
+		clickAction: record.clickAction === "fill" ? "fill" : "send",
+		maxDepth: Math.round(clampNumber(record.maxDepth, 1, 5, 3)),
+		launcher: {
+			x: x && typeof x.x === "number" && Number.isFinite(x.x) ? x.x : null,
+			y: x && typeof x.y === "number" && Number.isFinite(x.y) ? x.y : null
+		},
+		items: normalizeOrder(repairParents(items))
+	};
+}
+/**
+* 结构迁移入口（当前只有 v1；后续版本在此收敛旧结构）。
+* @author ddj 2026年10月30号
+* @param raw 原始值
+* @returns 合法文档
+*/
+function migrateDoc(raw) {
+	return normalizeDoc(raw);
+}
+/**
+* 序列化文档（host 落盘与导入导出共用）。
+* @author ddj 2026年10月30号
+* @param doc 文档
+* @returns JSON 文本
+*/
+function serializeDoc(doc) {
+	return JSON.stringify(normalizeDoc(doc), null, 2);
+}
+/**
+* 解析文档文本（解析失败返回默认文档并给出告警文案）。
+* @author ddj 2026年10月30号
+* @param text 文件内容
+* @returns 文档 + 可选告警
+*/
+function parseDoc(text) {
+	try {
+		return { doc: migrateDoc(JSON.parse(text)) };
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		return {
+			doc: defaultDoc(),
+			warning: "快捷菜单配置解析失败（" + reason + "），已回落默认配置"
+		};
+	}
+}
+//#endregion
+//#region src/quickMenu.ts
+/**
+* dsh-vscode-mode host — 快捷菜单配置的读写（~/.dsh/dsh-vscode-mode/data/quick-menu.json）。
+*
+* 为什么单独成模块：菜单项是用户数据而不是界面镜像——不能落在 cache/（会被 sweep、
+* 且与 uiState 共享 512KB 预算），也不适合塞进 Config schema（嵌套 JSON 不参与校验）。
+* 写入约定：revision 乐观并发 + 同文件串行队列 + tmp 原子替换 + 单代 .bak 备份，
+* 解析失败时把原文件另存 .bad-<ts>.json 再回落默认文档，绝不让坏文件阻塞功能。
+* 作者 ddj 2026年10月30号
+*/
+/** mtime 缓存（文件未变则复用解析结果，避免每次打开菜单都读盘）。 */
+const stateCache = /* @__PURE__ */ new Map();
+/** 同文件写队列尾（串行化并发写入；队列清空即移除条目，与 uiState 同套路）。 */
+const writeChains$1 = /* @__PURE__ */ new Map();
+/**
+* 把写任务挂到该文件的队尾串行执行（前序失败不影响后续）。
+* @author ddj 2026年10月30号
+* @param file 目标文件绝对路径
+* @param run 实际写操作
+* @returns 本次写操作结果
+*/
+function chainWrite$1(file, run) {
+	const next = (writeChains$1.get(file) ?? Promise.resolve()).then(run, run);
+	const tail = next.then(() => void 0, () => void 0);
+	writeChains$1.set(file, tail);
+	tail.then(() => {
+		if (writeChains$1.get(file) === tail) writeChains$1.delete(file);
+	});
+	return next;
+}
+/**
+* 读取文件修改时间（缺失/不可读返回 0）。
+* @author ddj 2026年10月30号
+* @param file 文件路径
+* @returns mtime 毫秒
+*/
+async function mtimeOf(file) {
+	try {
+		return (await stat(file)).mtimeMs;
+	} catch {
+		return 0;
+	}
+}
+/**
+* 原子写文本（先写 .tmp 再改名，缺目录自动建；失败时尽量清掉临时文件）。
+* @author ddj 2026年10月30号
+* @param file 目标文件
+* @param text 文本
+*/
+async function writeAtomic(file, text) {
+	await mkdir(dirname(file), { recursive: true });
+	const temporary = file + ".tmp";
+	await writeFile(temporary, text, "utf8");
+	await rename(temporary, file);
+}
+/**
+* 把坏文件另存为 .bad-<ts>.json（尽力而为，失败不影响主流程）。
+* @author ddj 2026年10月30号
+* @param file 源文件
+* @returns 备份路径（失败为 null）
+*/
+async function backupCorrupt(file) {
+	const target = file + ".bad-" + Date.now() + ".json";
+	try {
+		await copyFile(file, target);
+		return target;
+	} catch {
+		return null;
+	}
+}
+/**
+* 把上一次内容写成单代备份（quick-menu.bak.json）。
+* @author ddj 2026年10月30号
+* @param file 源文件
+*/
+async function backupPrevious(file) {
+	try {
+		await copyFile(file, file.replace(/\.json$/, "") + ".bak.json");
+	} catch {}
+}
+/**
+* 读盘并归一（绕过缓存；文件缺失按默认文档处理）。
+* @author ddj 2026年10月30号
+* @param file 文件路径
+* @returns 文档 + 告警 + mtime
+*/
+async function loadFile(file) {
+	const mtime = await mtimeOf(file);
+	if (mtime === 0) return {
+		doc: defaultDoc(),
+		mtime: 0
+	};
+	let text = "";
+	try {
+		text = await readFile(file, "utf8");
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		return {
+			doc: defaultDoc(),
+			warning: "快捷菜单配置读取失败（" + reason + "），已回落默认配置",
+			mtime
+		};
+	}
+	const parsed = parseDoc(text);
+	if (!parsed.warning) return {
+		doc: parsed.doc,
+		mtime
+	};
+	const backup = await backupCorrupt(file);
+	const doc = parsed.doc;
+	try {
+		await writeAtomic(file, serializeDoc(doc));
+	} catch {}
+	const hint = backup ? "已备份为 " + backup : "备份失败";
+	return {
+		doc,
+		warning: parsed.warning + "（" + hint + "）",
+		mtime
+	};
+}
+/**
+* 读取快捷菜单文档（mtime 未变时复用缓存）。
+* @author ddj 2026年10月30号
+* @param home DSH home（测试可注入）
+* @returns 文档 + 告警
+*/
+async function readQuickMenu(home) {
+	const file = quickMenuFile(home);
+	const mtime = await mtimeOf(file);
+	const cached = stateCache.get(file);
+	if (cached && cached.mtime === mtime) return cached;
+	const state = await loadFile(file);
+	stateCache.set(file, state);
+	return state;
+}
+/**
+* 校验待保存文档的硬性上限（超出即拒绝，避免静默截断用户数据）。
+* @author ddj 2026年10月30号
+* @param doc 待保存文档
+* @returns 错误文案（合法为 null）
+*/
+function checkLimits(doc) {
+	if (doc.items.length > 200) return "菜单项超过上限（200 项）";
+	if (Buffer.byteLength(serializeDoc(doc), "utf8") > 262144) return "配置超出容量上限（262144 字节）";
+	return null;
+}
+/**
+* 保存文档（revision 不匹配即判定为并发冲突，返回磁盘最新文档）。
+* @author ddj 2026年10月30号
+* @param doc 客户端提交的完整文档
+* @param baseRevision 客户端读到的 revision
+* @param home DSH home（测试可注入）
+* @returns 保存结果
+*/
+async function saveQuickMenu(doc, baseRevision, home) {
+	const file = quickMenuFile(home);
+	return chainWrite$1(file, async () => {
+		const limit = checkLimits(doc);
+		if (limit) return {
+			ok: false,
+			error: limit
+		};
+		const current = await loadFile(file);
+		if (current.doc.revision !== baseRevision) return {
+			ok: false,
+			error: "配置已被其他窗口修改，请重新加载后再保存",
+			doc: current.doc
+		};
+		const next = normalizeDoc(doc);
+		next.launcher = current.doc.launcher;
+		next.revision = current.doc.revision + 1;
+		next.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		try {
+			await backupPrevious(file);
+			await writeAtomic(file, serializeDoc(next));
+		} catch (error) {
+			return {
+				ok: false,
+				error: "快捷菜单配置写入失败：" + (error instanceof Error ? error.message : String(error))
+			};
+		}
+		const state = {
+			doc: next,
+			mtime: await mtimeOf(file)
+		};
+		stateCache.set(file, state);
+		return {
+			ok: true,
+			doc: next
+		};
+	});
+}
+/**
+* 只更新悬浮按钮坐标（不推进 revision，避免拖拽把正在编辑的表单顶掉）。
+* @author ddj 2026年10月30号
+* @param launcher 坐标（null 表示回到输入框锚点）
+* @param home DSH home（测试可注入）
+* @returns 保存结果
+*/
+async function patchLauncher(launcher, home) {
+	const file = quickMenuFile(home);
+	return chainWrite$1(file, async () => {
+		const next = {
+			...(await loadFile(file)).doc,
+			launcher: {
+				x: launcher.x,
+				y: launcher.y
+			},
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		try {
+			await writeAtomic(file, serializeDoc(next));
+		} catch (error) {
+			return {
+				ok: false,
+				error: "保存悬浮按钮位置失败：" + (error instanceof Error ? error.message : String(error))
+			};
 		}
-	};
-	await load(userSnippetsDir(), "user");
-	const registered = workspaceList(ctx).some((item) => item.path === workspacePath);
-	if (workspacePath && registered) await load(projectSnippetsDir(workspacePath), "project");
-	return { entries: flattenSnippetEntries(loaded) };
+		const state = {
+			doc: next,
+			mtime: await mtimeOf(file)
+		};
+		stateCache.set(file, state);
+		return {
+			ok: true,
+			doc: next
+		};
+	});
 }
 //#endregion
 //#region src/shared/externalOpen.ts
@@ -13152,15 +15993,67 @@ function reviewHandlers(ctx, registry) {
 		await bucketOf(registry, ctx, scope.cwd);
 		return scope.cwd;
 	}
+	/**
+	* @private
+	* @author ddj 2026年10月30号
+	* @description: 读取待审页；待审库尚未建立或迁移失败时按空页处理。
+	* 待审投影是增量能力，不能因为它让官方列表整体不可用。
+	* @param cwd 工作区
+	* @param sessionId 请求会话
+	* @returns 待审页（失败为空页）
+	*/
+	function pendingPageOf(cwd, sessionId) {
+		try {
+			return loadPage(cwd, sessionId);
+		} catch {
+			return {
+				items: [],
+				pending: 0,
+				nextCursor: null,
+				gaps: []
+			};
+		}
+	}
 	return {
 		"edrv.review.list": async (args) => {
+			const cwd = await workspace(args.sessionId);
+			const official = reviewPage(cwd, args.cursor, args.history, args.path);
+			const pending = pendingPageOf(cwd, args.sessionId);
+			if (args.history) return {
+				ok: true,
+				page: official
+			};
+			if (args.path !== void 0) {
+				const key = args.path;
+				const own = pending.items.filter((item) => pendingSamePath(item.path, key)).map((item) => pendingItemOf(item, cwd));
+				const history = own.length ? official.items.filter((item) => !pendingSamePath(item.path, key)) : official.items;
+				return {
+					ok: true,
+					page: {
+						...official,
+						items: [...own, ...history]
+					}
+				};
+			}
 			return {
 				ok: true,
-				page: reviewPage(await workspace(args.sessionId), args.cursor, args.history, args.path)
+				page: mergedPage(official, pending, cwd)
 			};
 		},
 		"edrv.review.detail": async (args) => {
-			const detail = reviewDetail(await workspace(args.sessionId), args.id);
+			const cwd = await workspace(args.sessionId);
+			if (args.id.startsWith("pending:")) {
+				const detail = loadDetail(cwd, args.id.slice(8));
+				if (!detail) return {
+					ok: false,
+					error: "待审条目不存在"
+				};
+				return {
+					ok: true,
+					detail: pendingDetailOf(detail, new Date(detail.item.updatedAt).toISOString(), cwd)
+				};
+			}
+			const detail = reviewDetail(cwd, args.id);
 			return detail ? {
 				ok: true,
 				detail
@@ -13171,6 +16064,25 @@ function reviewHandlers(ctx, registry) {
 		},
 		"edrv.review.decide": async (args) => {
 			const cwd = await liveWorkspace(args.sessionId);
+			if (args.id.startsWith("pending:")) {
+				const result = await applyDecide(ctx.get("fs"), cwd, {
+					sessionId: args.sessionId,
+					id: args.id.slice(8),
+					revision: args.revision,
+					operationId: args.operationId,
+					decision: args.decision,
+					scope: args.scope === "hunk" ? "block" : "file",
+					...args.blockId === void 0 ? {} : { blockId: args.blockId }
+				});
+				if (!result.ok) return {
+					ok: false,
+					error: result.reason
+				};
+				return {
+					ok: true,
+					revision: result.flags.revision
+				};
+			}
 			try {
 				return {
 					ok: true,
@@ -13186,6 +16098,248 @@ function reviewHandlers(ctx, registry) {
 	};
 }
 //#endregion
+//#region src/pendingRpc.ts
+/**
+* @author ddj 2026年10月30号
+* @description: 解析会话工作区并预热记录桶；读路径也走它，避免冷读时桶未就绪。
+* @param ctx Host 上下文
+* @param registry 工作区记录桶缓存
+* @param sessionId 请求作用域
+* @returns 工作区路径
+*/
+async function workspaceOf(ctx, registry, sessionId) {
+	const scope = await resolveScope(ctx, sessionId);
+	if ("err" in scope) throw new Error("会话不存在或没有工作区");
+	await bucketOf(registry, ctx, scope.cwd);
+	return scope.cwd;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 写路径专用的工作区解析：本端没有该会话就直接拒绝，不做跨实例写。
+* @param ctx Host 上下文
+* @param registry 工作区记录桶缓存
+* @param sessionId 请求作用域
+* @returns 工作区路径
+*/
+async function writeWorkspaceOf(ctx, registry, sessionId) {
+	const cwd = await workspaceOf(ctx, registry, sessionId);
+	if (!sessionOf(ctx, sessionId)) throw new Error("写入要求本端活跃会话");
+	return cwd;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 把异常归一成可播报文案，避免处理器各自重复三元表达式。
+* @param error 捕获到的异常
+* @returns 错误文案
+*/
+function failureOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 按会话策略包装 shell：执行器默认按 workspace-write 跑，本机无可用沙箱后端会直接拒绝。
+* @param raw 原始 shell 能力
+* @param policy 会话沙箱策略
+* @returns 带策略的 shell 视图
+*/
+function shellOf(raw, policy) {
+	return {
+		resolve: (request) => raw.resolve(policy ? {
+			...request,
+			sandboxPolicy: policy
+		} : request),
+		execute: (spec) => raw.execute(spec)
+	};
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 读路径处理器：列表与详情，允许跨实例冷读。
+* @param kit 作用域能力
+* @returns 处理器表
+*/
+function readHandlers(kit) {
+	return {
+		"edrv.pending.list": async (args) => {
+			const cwd = await kit.read(args.sessionId);
+			const page = loadPage(cwd, args.sessionId);
+			for (const item of page.items) trackPendingCover(cwd, item.path, true);
+			return {
+				ok: true,
+				page
+			};
+		},
+		"edrv.pending.detail": async (args) => {
+			const detail = loadDetail(await kit.read(args.sessionId), pendingRawId(args.id));
+			return detail ? {
+				ok: true,
+				detail
+			} : {
+				ok: false,
+				error: "待审条目不存在"
+			};
+		}
+	};
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 判定处理器：Keep/Revert 与已解决条目移除，都会改变待审状态。
+* @param kit 作用域能力
+* @returns 处理器表
+*/
+function decideHandlers(kit) {
+	return {
+		"edrv.pending.decide": async (args) => {
+			const cwd = await kit.write(args.sessionId);
+			const id = pendingRawId(args.id);
+			try {
+				const policy = policyOf(kit.ctx, sessionOf(kit.ctx, args.sessionId));
+				const result = await applyDecide(kit.ctx.get("fs"), cwd, {
+					...args,
+					id
+				}, void 0, policy);
+				if (!result.ok) return {
+					ok: false,
+					error: result.reason
+				};
+				const detail = loadDetail(cwd, id);
+				return detail ? {
+					ok: true,
+					item: detail.item,
+					wrote: result.wrote
+				} : {
+					ok: false,
+					error: "待审条目不存在"
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: failureOf(error)
+				};
+			}
+		},
+		"edrv.pending.remove": async (args) => {
+			const cwd = await kit.write(args.sessionId);
+			const id = pendingRawId(args.id);
+			const path = loadEntries(cwd).find((stored) => stored.entry.id === id)?.entry.path;
+			const removed = removeEntry(cwd, id, args.revision);
+			if (removed && path) trackPendingCover(cwd, path, false);
+			return {
+				ok: true,
+				removed
+			};
+		}
+	};
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 历史处理器：撤销/重做一次决定。
+* @param kit 作用域能力
+* @returns 处理器表
+*/
+function historyHandlers(kit) {
+	return { "edrv.pending.history": async (args) => {
+		const cwd = await kit.write(args.sessionId);
+		const policy = policyOf(kit.ctx, sessionOf(kit.ctx, args.sessionId));
+		try {
+			const result = await undoDecide(kit.ctx.get("fs"), cwd, args, void 0, policy);
+			return result.ok ? {
+				ok: true,
+				item: result.item,
+				wrote: result.wrote
+			} : {
+				ok: false,
+				error: result.reason
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: failureOf(error)
+			};
+		}
+	} };
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 投影维护处理器：从版本库导入、按磁盘现状刷新单条。
+* @param kit 作用域能力
+* @returns 处理器表
+*/
+function refreshHandlers(kit) {
+	return {
+		"edrv.pending.import": async (args) => {
+			const cwd = await kit.write(args.sessionId);
+			const raw = kit.ctx.get("shell");
+			if (!raw) return {
+				ok: false,
+				error: "当前环境没有 shell 能力，无法读取版本库基线"
+			};
+			const policy = policyOf(kit.ctx, sessionOf(kit.ctx, args.sessionId));
+			try {
+				const result = await importFromVcs(shellOf(raw, policy), cwd, args.sessionId, {
+					includeUntracked: args.includeUntracked,
+					path: args.path
+				});
+				for (const item of loadPage(cwd, args.sessionId).items) trackPendingCover(cwd, item.path, true);
+				return {
+					ok: true,
+					imported: result.imported,
+					changes: result.changes
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: failureOf(error)
+				};
+			}
+		},
+		"edrv.pending.refresh": async (args) => {
+			const cwd = await kit.write(args.sessionId);
+			const id = pendingRawId(args.id);
+			const stored = loadEntries(cwd).find((entry) => entry.entry.id === id);
+			if (!stored) return {
+				ok: false,
+				error: "待审条目不存在"
+			};
+			const fs = kit.ctx.get("fs");
+			const session = sessionOf(kit.ctx, args.sessionId);
+			const content = await readText(fs, await fs.resolve(id, {
+				cwd,
+				agent: session
+			})).catch(() => void 0);
+			if (content === void 0) return {
+				ok: false,
+				error: "读取失败"
+			};
+			const next = refreshed(stored, content, Date.now());
+			if (next) saveEntry(cwd, next);
+			return {
+				ok: true,
+				item: itemOf(next ?? stored)
+			};
+		}
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 待审投影处理器表：按用途拆成读/判定/历史/维护四组，便于分别收敛权限。
+* @param ctx Host 上下文
+* @param registry 工作区记录桶缓存
+* @returns 待审相关处理器表
+*/
+function pendingHandlers(ctx, registry) {
+	const kit = {
+		ctx,
+		read: (sessionId) => workspaceOf(ctx, registry, sessionId),
+		write: (sessionId) => writeWorkspaceOf(ctx, registry, sessionId)
+	};
+	return {
+		...readHandlers(kit),
+		...decideHandlers(kit),
+		...historyHandlers(kit),
+		...refreshHandlers(kit)
+	};
+}
+//#endregion
 //#region src/missingReview.ts
 /** Missing historical files: frozen, whole-file deletion reviews. */
 const frozen = /* @__PURE__ */ new Map();
@@ -13209,13 +16363,18 @@ function revisionOf(records) {
 	}));
 	return createHash("sha256").update(JSON.stringify(evidence)).digest("hex");
 }
+/** @private @author ddj 2026年10月30号 @param ctx Host capability. @param target Resolve 结果：宿主路径字符串或不透明 FsTarget。 @returns 平台一致的物理身份；无法还原时返回空串。 */
+function fileKeyOf(ctx, target) {
+	const path = targetPathOf(ctx, target);
+	return path ? fileKey(path) : "";
+}
 /** @private @author ddj 2026年10月28号 @param ctx Host capability. @param cwd Workspace. @param bucket Records. @param target Resolved file. @returns Records for the same physical path spelling, oldest first. */
 async function fileRecords(ctx, cwd, bucket, target) {
 	const matches = [];
-	const identity = fileKey(target);
+	const identity = fileKeyOf(ctx, target);
 	for (const record of bucket.values()) {
 		if (record.superseded) continue;
-		if (fileKey(await resolveTargetIn(ctx, cwd, record.path)) === identity) matches.push(record);
+		if (fileKeyOf(ctx, await resolveTargetIn(ctx, cwd, record.path)) === identity) matches.push(record);
 	}
 	return matches.sort((left, right) => left.at.localeCompare(right.at));
 }
@@ -13233,10 +16392,11 @@ async function fileAbsent(ctx, cwd, path) {
 }
 /** @public @author ddj 2026年10月28号 @param ctx Host. @param session Live session. @param cwd Workspace. @param bucket Records. @param path Requested file. @returns Frozen complete snapshot; never constructs text from hunks or writes files. @throws Missing evidence or nonmissing target. */
 async function missingReview(ctx, session, cwd, bucket, path) {
-	const target = await resolveTargetIn(ctx, cwd, path);
-	if (hasOfficial(cwd, path) || hasOfficial(cwd, target)) throw new Error("该文件已有官方审查记录，请使用官方审查入口");
-	if (!await fileAbsent(ctx, cwd, target)) throw new Error("文件已重新出现，请刷新");
-	const records = await fileRecords(ctx, cwd, bucket, target);
+	const abs = targetPathOf(ctx, await resolveTargetIn(ctx, cwd, path));
+	if (!abs) throw new Error("无法解析目标文件路径");
+	if (hasOfficial(cwd, path) || hasOfficial(cwd, abs)) throw new Error("该文件已有官方审查记录，请使用官方审查入口");
+	if (!await fileAbsent(ctx, cwd, abs)) throw new Error("文件已重新出现，请刷新");
+	const records = await fileRecords(ctx, cwd, bucket, abs);
 	const latest = records.at(-1);
 	if (!records.some((record) => !record.archived && !recordResolved(record))) throw new Error("没有待审历史记录");
 	if (!latest || typeof latest.after !== "string") throw new Error("缺少可靠的完整历史快照，无法展示或恢复；不会用局部差异拼接文件");
@@ -13276,37 +16436,48 @@ async function applyDisk(ctx, item, target, undo) {
 	if (absent && operation.restored && !await fs.stat(target)) throw new Error("恢复后的文件再次缺失，未结清记录");
 	if (await fs.readText(target) !== item.view.content) throw new Error("恢复内容校验失败，未结清记录");
 }
+/**
+* @author ddj 2026年10月29号
+* @description: 取删除预览对应的文件路径，供服务端判定该路径是否已由待审投影接管。
+* @param token 冻结预览 token
+* @returns 文件路径，token 无效时为 undefined
+*/
+function missingPath(token) {
+	return frozen.get(token)?.view.path;
+}
 /** @public @author ddj 2026年10月28号 @param ctx Host. @param session Requesting session. @param cwd Workspace. @param bucket Records. @param token Frozen preview token. @param operationId Stable retry ID. @param undo True restores shown snapshot; false keeps deletion. @returns Covered call IDs. @throws Changed evidence, concurrent action or sandbox/IO failure. */
 async function missingDecide(ctx, session, cwd, bucket, token, operationId, undo) {
 	const item = frozen.get(token);
 	if (!item || item.expires < Date.now() || item.cwd !== cwd || item.session.id !== session.id) throw new Error("删除预览已过期，请刷新后重试");
 	if (!operationId || operationId.length > 128) throw new Error("缺少有效操作 ID");
 	const target = await resolveTargetIn(ctx, cwd, item.view.path);
-	const key = JSON.stringify([cwd, fileKey(target)]);
+	const abs = targetPathOf(ctx, target);
+	if (!abs) throw new Error("无法解析目标文件路径");
+	const key = JSON.stringify([cwd, fileKey(abs)]);
 	if (locks.has(key)) throw new Error("该文件正在处理，请稍后重试");
 	locks.add(key);
 	item.session = session;
 	try {
-		return await commitMissing(ctx, item, bucket, target, operationId, undo);
+		return await commitMissing(ctx, item, bucket, target, abs, operationId, undo);
 	} finally {
 		locks.delete(key);
 	}
 }
-/** @private @author ddj 2026年10月28号 @param ctx Host. @param item Frozen preview. @param bucket Live records. @param target Resolved target. @param operationId Retry identity. @param undo Restore action. @returns Archived pending call IDs; disk success survives bookkeeping failure in the same Host lifetime. */
-async function commitMissing(ctx, item, bucket, target, operationId, undo) {
+/** @private @author ddj 2026年10月28号 @param ctx Host. @param item Frozen preview. @param bucket Live records. @param target Resolved target. @param abs Host path of the target. @param operationId Retry identity. @param undo Restore action. @returns Archived pending call IDs; disk success survives bookkeeping failure in the same Host lifetime. */
+async function commitMissing(ctx, item, bucket, target, abs, operationId, undo) {
 	const previous = item.operation;
 	if (previous && (previous.id !== operationId || previous.undo !== undo)) throw new Error("已有不同操作，请刷新后重试");
 	if (previous?.done) return item.view.callIds;
-	if (hasOfficial(item.cwd, target) || hasOfficial(item.cwd, item.view.path)) throw new Error("该文件已有官方审查记录，请刷新");
-	if (revisionOf(await fileRecords(ctx, item.cwd, bucket, target)) !== item.revision) throw new Error("历史记录已变化，请刷新删除预览");
+	if (hasOfficial(item.cwd, abs) || hasOfficial(item.cwd, item.view.path)) throw new Error("该文件已有官方审查记录，请刷新");
+	if (revisionOf(await fileRecords(ctx, item.cwd, bucket, abs)) !== item.revision) throw new Error("历史记录已变化，请刷新删除预览");
 	item.operation ??= {
 		id: operationId,
 		undo,
 		restored: false,
 		done: false
 	};
-	await applyDisk(ctx, item, target, undo);
-	const current = await fileRecords(ctx, item.cwd, bucket, target);
+	await applyDisk(ctx, item, abs, undo);
+	const current = await fileRecords(ctx, item.cwd, bucket, abs);
 	if (revisionOf(current) !== item.revision) throw new Error("历史记录已变化，未结清记录，请刷新");
 	const pending = current.filter((record) => item.view.callIds.includes(record.callId));
 	const decisions = pending.map((record) => record.decisions);
@@ -13364,6 +16535,18 @@ function recView(record, ws = null) {
 		...ws ? { displayPath: remoteDisplayOf(record.path, ws) ?? void 0 } : {}
 	};
 }
+/**
+* 旧写入口守卫：路径已由待审累计基线接管时一律拒绝，避免两套权威同时写同一文件。
+* @author ddj 2026年10月29号
+* @param cwd 工作区
+* @param path 请求涉及的路径（可为空表示无法定位）
+* @returns 拒绝原因，未接管时为 null
+*/
+function legacyBlocked(cwd, path) {
+	if (!path) return null;
+	if (!pendingCovers(cwd, path)) return null;
+	return "该文件已由待审累计基线接管，请使用面板 Keep/Revert（edrv.review.decide）";
+}
 /** 会话/工作区公共前置：返回 {session,cwd} 或错误文案。 */
 async function requireSession(ctx, sessionId) {
 	const session = sessionOf(ctx, sessionId);
@@ -13846,6 +17029,7 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 		...svnHandlers ?? {},
 		...dapHandlers ?? {},
 		...reviewHandlers(ctx, registry),
+		...pendingHandlers(ctx, registry),
 		"edrv.list": async (args) => {
 			const start = performance.now();
 			let staleMs = 0;
@@ -13937,6 +17121,11 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				error: sc.err
 			};
 			const bucket = await bucketOf(registry, ctx, sc.cwd);
+			const blocked = legacyBlocked(sc.cwd, bucket.get(args.callId)?.path);
+			if (blocked) return {
+				ok: false,
+				error: blocked
+			};
 			const item = (await applyDecisions(ctx, sc.session, sc.cwd, bucket, [{
 				callId: args.callId,
 				scope: args.scope,
@@ -13959,6 +17148,11 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				error: sc.err
 			};
 			const bucket = await bucketOf(registry, ctx, sc.cwd);
+			const blocked = legacyBlocked(sc.cwd, bucket.get(args.callId)?.path);
+			if (blocked) return {
+				ok: false,
+				error: blocked
+			};
 			const item = (await applyDecisions(ctx, sc.session, sc.cwd, bucket, [{
 				callId: args.callId,
 				scope: args.scope,
@@ -13980,6 +17174,11 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				ok: false,
 				error: sc.err
 			};
+			const blocked = legacyBlocked(sc.cwd, args.path);
+			if (blocked) return {
+				ok: false,
+				error: blocked
+			};
 			try {
 				const bucket = await bucketOf(registry, ctx, sc.cwd);
 				if (!await fileAbsent(ctx, sc.cwd, args.path)) return {
@@ -14003,6 +17202,11 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				ok: false,
 				error: sc.err
 			};
+			const blocked = legacyBlocked(sc.cwd, missingPath(args.token));
+			if (blocked) return {
+				ok: false,
+				error: blocked
+			};
 			try {
 				const bucket = await bucketOf(registry, ctx, sc.cwd);
 				return {
@@ -14023,9 +17227,15 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				error: sc.err
 			};
 			const bucket = await bucketOf(registry, ctx, sc.cwd);
+			const items = Array.isArray(args.items) ? args.items : [];
+			const blocked = items.map((item) => legacyBlocked(sc.cwd, bucket.get(item.callId)?.path)).find((reason) => reason !== null);
+			if (blocked) return {
+				ok: false,
+				error: blocked
+			};
 			return {
 				ok: true,
-				results: await applyDecisions(ctx, sc.session, sc.cwd, bucket, Array.isArray(args.items) ? args.items : [])
+				results: await applyDecisions(ctx, sc.session, sc.cwd, bucket, items)
 			};
 		},
 		/** @author ddj 2026年10月22号 @param args Read-only request. @returns Bounded official range read, or unsupported on older providers; never bypasses Host IO. */
@@ -15538,6 +18748,19 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				};
 			}
 		},
+		"skills.list": async (args) => {
+			try {
+				return {
+					ok: true,
+					...await listSkillCatalog(args?.cwd)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "读取技能候选失败：" + String(error)
+				};
+			}
+		},
 		"snippets.list": async () => {
 			try {
 				return {
@@ -15601,6 +18824,60 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 					error: "读取代码片段条目失败：" + String(error)
 				};
 			}
+		},
+		"quickMenu.get": async () => {
+			try {
+				const state = await readQuickMenu();
+				return {
+					ok: true,
+					doc: state.doc,
+					warning: state.warning
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "读取快捷菜单失败：" + String(error)
+				};
+			}
+		},
+		"quickMenu.save": async (args) => {
+			try {
+				const result = await saveQuickMenu(args.doc, args.baseRevision);
+				if (!result.ok) return {
+					ok: false,
+					error: result.error
+				};
+				return {
+					ok: true,
+					doc: result.doc
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "保存快捷菜单失败：" + String(error)
+				};
+			}
+		},
+		"quickMenu.launcher": async (args) => {
+			try {
+				const result = await patchLauncher({
+					x: args.x,
+					y: args.y
+				});
+				if (!result.ok) return {
+					ok: false,
+					error: result.error
+				};
+				return {
+					ok: true,
+					doc: result.doc
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "保存悬浮按钮位置失败：" + String(error)
+				};
+			}
 		}
 	};
 }
@@ -26039,6 +29316,16 @@ function attachRuntime(ctx, runtime) {
 		evidence.persist(cwd, snapshot);
 		return true;
 	});
+	const pending = installPending(ctx, (write) => {
+		try {
+			trackPendingCover(write.cwd, write.path, true);
+		} catch {}
+		try {
+			recordWrite(write);
+		} catch (error) {
+			log.warn("待审差异落库失败：" + String(error));
+		}
+	});
 	/** @author ddj 2026年09月28号 @param exec Tool execution. @param result Tool result. */
 	function onResult(exec, result) {
 		captureToolResult(ctx, runtime.registry, exec, result);
@@ -26058,6 +29345,7 @@ function attachRuntime(ctx, runtime) {
 	async function cleanup() {
 		await stopCapture();
 		evidence.dispose();
+		pending.dispose();
 		runtime.fileVersions.dispose();
 		closeArchiveDbs();
 		disposeAllServers();