dsh-vscode-mode 0.21.4 → 0.22.0

package/lib/index.js

@@ -2488,6 +2488,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 +5061,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 +5118,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 +5160,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
@@ -7340,10 +7360,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 +7580,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 +7624,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 +7642,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 +7660,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,
@@ -8079,20 +8109,2066 @@ function installEvidence(ctx) {
 		chains.clear();
 		staged.clear();
 	}
-	return {
-		persist,
-		dispose
+	return {
+		persist,
+		dispose
+	};
+}
+/** @private @author ddj 2026年10月27号 @param fs Public filesystem. @param target Backend identity. @returns Raw bounded file or confirmed missing. @throws Any non-missing read error. */
+async function readRaw(fs, target, signal) {
+	try {
+		return rawReviewFile(await fs.readBytes(target, signal, 1048576));
+	} catch (error) {
+		const code = error.code;
+		if (code === "ENOENT" || code === "FS_NOT_FOUND") return rawReviewFile(null);
+		throw error;
+	}
+}
+//#endregion
+//#region src/pending/capture.ts
+/**
+* 待审差异采集：环绕一次文件写入读取真实前后内容，只有内容确实变化才落库。
+* @author ddj 2026年10月29号
+*/
+/** 可被采信为待审来源的写文件工具。 */
+const WRITE_TOOLS = [
+	"edit",
+	"write",
+	"str_replace_editor"
+];
+/** 单文件文本上限：超过即标注 oversized，不静默截断。 */
+const MAX_TEXT = 1048576;
+/**
+* @author ddj 2026年10月29号
+* @description: 安装写文件采集；读写失败只影响待审来源，绝不影响用户工具本身。
+* @param ctx Host 生命周期
+* @param sink 已确认写入的接收方
+* @returns 可释放的采集器
+*/
+function installPendingCapture(ctx, sink) {
+	const busy = /* @__PURE__ */ new Set();
+	let stopped = false;
+	ctx.on("tools/execute", aroundTool);
+	return { dispose };
+	/**
+	* @author ddj 2026年10月29号
+	* @description: 写工具执行前后各读一次，内容变化才上报。
+	* @param exec 工具分发上下文
+	* @param next 原始分发
+	* @returns 原始工具结果，永不因采集失败而改变
+	*/
+	async function aroundTool(exec, next) {
+		const session = exec.agent?.session;
+		const path = exec.arguments?.file_path ?? exec.arguments?.path;
+		if (stopped || !session?.id || typeof path !== "string" || !WRITE_TOOLS.includes(exec.name)) return next();
+		const cwd = cwdOf(session);
+		if (!cwd) return next();
+		let before = null;
+		let identity = null;
+		try {
+			const fs = ctx.get("fs");
+			const target = await resolveTarget(ctx, session, path);
+			const key = fs.processPath(target);
+			if (typeof key !== "string" || !key) return next();
+			if (busy.has(key)) return next();
+			before = await readText(fs, target);
+			if (before !== null && before.length > MAX_TEXT) return next();
+			identity = key;
+			busy.add(key);
+		} catch (error) {
+			log.debug("待审采集跳过：" + String(error));
+			return next();
+		}
+		try {
+			return await next();
+		} finally {
+			if (identity !== null) {
+				const key = identity;
+				try {
+					report(String(cwd), String(session.id), String(path), key, before, exec);
+				} catch (error) {
+					log.debug("待审上报失败：" + String(error));
+				}
+				busy.delete(key);
+			}
+		}
+	}
+	/**
+	* @author ddj 2026年10月29号
+	* @description: 写后读回并比较，内容一致视为无净变化不产生条目。
+	* @param cwd 工作区
+	* @param sessionId 会话
+	* @param path 展示路径
+	* @param identity 目标身份
+	* @param before 写前内容
+	* @param exec 工具分发上下文
+	* @returns 无
+	*/
+	function report(cwd, sessionId, path, identity, before, exec) {
+		const fs = ctx.get("fs");
+		resolveTarget(ctx, exec.agent.session, path).then(async (target) => {
+			const after = await readText(fs, target);
+			if (after !== null && after.length > MAX_TEXT) return;
+			if (before === after) return;
+			sink({
+				cwd,
+				sessionId,
+				path,
+				identity,
+				before,
+				after,
+				now: Date.now()
+			});
+		}).catch((error) => log.debug("待审读回失败：" + String(error)));
+	}
+	/**
+	* @author ddj 2026年10月29号
+	* @description: 释放监听。
+	* @returns 无
+	*/
+	function dispose() {
+		stopped = true;
+		busy.clear();
+	}
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 读取全文；缺失或不可读按"无内容"处理，交由上层决定语义。
+* @param fs 文件系统
+* @param target 目标
+* @returns 文本或 null
+*/
+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/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
+*/
+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;
+	}
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 判断目录是否是 Perforce 工作区根（P4CONFIG 文件所在目录）。
+* @param dir 目录
+* @returns 是否 P4 根
+*/
+async function isP4Root(dir) {
+	return await exists(join(dir, ".p4config")) || await exists(join(dir, ".p4config.txt"));
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 读出当前工作副本相对基线的改动，只返回给定范围（含未跟踪按选项）。
+* @param shell shell 能力
+* @param cwd 工作区
+* @param options 导入选项
+* @returns 改动列表
+*/
+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));
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 按探测到的种类取改动，新增种类只在这里分流。
+* @param shell shell 能力
+* @param detected 版本库种类与根目录
+* @param cwd 工作区
+* @param options 导入选项
+* @returns 改动列表
+*/
+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);
+}
+/**
+* @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;
+}
+/**
+* @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
+*/
+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));
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 取 svn BASE 版本内容；失败一律抛出（svn 没有可靠的"不存在"判据）。
+* @param shell shell 能力
+* @param root 工作副本根
+* @param relative 相对路径
+* @returns 基线内容
+*/
+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;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 解析 `p4 opened` 输出，只取 depot 路径（`//depot/x#3 - edit ...`）。
+* @param text 输出
+* @returns depot 路径列表
+*/
+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年10月30号
+* @description: 解析 `p4 status` 输出；每行以本地路径或 depot 路径开头，取路径本身。
+* @param text 输出
+* @returns depot 或本地路径列表
+*/
+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;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: `p4 where` 把小写 depot 路径折成本地绝对路径。
+* @param shell shell 能力
+* @param root P4 工作区根
+* @param depot depot 路径
+* @returns 本地路径，失败时 undefined
+*/
+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);
+}
+/**
+* @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');
+`;
+/** v1 历史表补 state 列（rebuild 成本高于一次 ALTER）。 */
+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
+/** 统计一次差异的增删行数。 */
+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 info = await fs.stat(target, signal).catch(() => void 0);
+		try {
+			await fs.writeText(target, content ?? "", info ? {
+				kind: "replaceIfVersion",
+				version: info.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;
 }
-/** @private @author ddj 2026年10月27号 @param fs Public filesystem. @param target Backend identity. @returns Raw bounded file or confirmed missing. @throws Any non-missing read error. */
-async function readRaw(fs, target, signal) {
+/**
+* @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 {
-		return rawReviewFile(await fs.readBytes(target, signal, 1048576));
+		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) {
-		const code = error.code;
-		if (code === "ENOENT" || code === "FS_NOT_FOUND") return rawReviewFile(null);
-		throw 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/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: 统一路径比较口径，消除分隔符与 Windows 大小写差异；远端身份保留原大小写。
+* @param path 路径
+* @returns 比较键
+*/
+function pathKey$1(path) {
+	const unified = path.replace(/\\/g, "/");
+	if (/^[a-z]+:\/\//i.test(unified)) return unified;
+	if (/^[a-z]:\//i.test(unified)) return unified.toLowerCase();
+	return process.platform === "win32" ? unified.toLowerCase() : unified;
+}
+/**
+* @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
@@ -13152,15 +15228,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 +15299,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 +15333,179 @@ function reviewHandlers(ctx, registry) {
 	};
 }
 //#endregion
+//#region src/pendingRpc.ts
+/**
+* @author ddj 2026年10月29号
+* @description: 待审投影处理器。读路径允许跨实例冷读，写路径必须本端 live 会话。
+* @param ctx Host 上下文
+* @param registry 工作区记录桶缓存
+* @returns 待审相关处理器表
+*/
+function pendingHandlers(ctx, registry) {
+	/** @private @author ddj 2026年10月29号 @param sessionId 请求作用域 @returns 工作区 */
+	async function workspace(sessionId) {
+		const scope = await resolveScope(ctx, sessionId);
+		if ("err" in scope) throw new Error("会话不存在或没有工作区");
+		await bucketOf(registry, ctx, scope.cwd);
+		return scope.cwd;
+	}
+	/** @private @author ddj 2026年10月29号 @param sessionId 请求作用域 @returns 本端 live 会话的工作区 */
+	async function liveWorkspace(sessionId) {
+		const cwd = await workspace(sessionId);
+		if (!sessionOf(ctx, sessionId)) throw new Error("写入要求本端活跃会话");
+		return cwd;
+	}
+	/**
+	* @private
+	* @author ddj 2026年10月30号
+	* @description: 面板列表里的条目 id 带待审前缀（用于和官方条目区分），
+	* 而待审内核按原始身份存取；各处理器统一走 pendingRawId 剥掉前缀。
+	* @param id 请求里的条目 id
+	* @returns 待审内核使用的原始 id
+	*/
+	const rawId = pendingRawId;
+	return {
+		"edrv.pending.list": async (args) => {
+			const cwd = await workspace(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 workspace(args.sessionId), rawId(args.id));
+			return detail ? {
+				ok: true,
+				detail
+			} : {
+				ok: false,
+				error: "待审条目不存在"
+			};
+		},
+		"edrv.pending.decide": async (args) => {
+			const cwd = await liveWorkspace(args.sessionId);
+			try {
+				const id = rawId(args.id);
+				const result = await applyDecide(ctx.get("fs"), cwd, {
+					...args,
+					id
+				}, void 0, policyOf(ctx, sessionOf(ctx, args.sessionId)));
+				if (!result.ok) return {
+					ok: false,
+					error: result.reason
+				};
+				const detail = loadDetail(cwd, id);
+				if (!detail) return {
+					ok: false,
+					error: "待审条目不存在"
+				};
+				return {
+					ok: true,
+					item: detail.item,
+					wrote: result.wrote
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				};
+			}
+		},
+		"edrv.pending.remove": async (args) => {
+			const cwd = await liveWorkspace(args.sessionId);
+			const id = rawId(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
+			};
+		},
+		"edrv.pending.history": async (args) => {
+			const cwd = await liveWorkspace(args.sessionId);
+			try {
+				const result = await undoDecide(ctx.get("fs"), cwd, args, void 0, policyOf(ctx, sessionOf(ctx, args.sessionId)));
+				if (!result.ok) return {
+					ok: false,
+					error: result.reason
+				};
+				return {
+					ok: true,
+					item: result.item,
+					wrote: result.wrote
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				};
+			}
+		},
+		"edrv.pending.import": async (args) => {
+			const cwd = await liveWorkspace(args.sessionId);
+			const raw = ctx.get("shell");
+			if (!raw) return {
+				ok: false,
+				error: "当前环境没有 shell 能力，无法读取版本库基线"
+			};
+			const policy = policyOf(ctx, sessionOf(ctx, args.sessionId));
+			const shell = {
+				resolve: (request) => raw.resolve(policy ? {
+					...request,
+					sandboxPolicy: policy
+				} : request),
+				execute: (spec) => raw.execute(spec)
+			};
+			try {
+				const result = await importFromVcs(shell, cwd, args.sessionId, {
+					includeUntracked: args.includeUntracked,
+					path: args.path
+				});
+				const page = loadPage(cwd, args.sessionId);
+				for (const item of page.items) trackPendingCover(cwd, item.path, true);
+				return {
+					ok: true,
+					imported: result.imported,
+					changes: result.changes
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				};
+			}
+		},
+		"edrv.pending.refresh": async (args) => {
+			const cwd = await liveWorkspace(args.sessionId);
+			const id = rawId(args.id);
+			const stored = loadEntries(cwd).find((entry) => entry.entry.id === id);
+			if (!stored) return {
+				ok: false,
+				error: "待审条目不存在"
+			};
+			const session = sessionOf(ctx, args.sessionId);
+			const fs = ctx.get("fs");
+			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)
+			};
+		}
+	};
+}
+//#endregion
 //#region src/missingReview.ts
 /** Missing historical files: frozen, whole-file deletion reviews. */
 const frozen = /* @__PURE__ */ new Map();
@@ -13209,13 +15529,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 +15558,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 +15602,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 +15701,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 +16195,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 +16287,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 +16314,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 +16340,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 +16368,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 +16393,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. */
@@ -26039,6 +28415,16 @@ function attachRuntime(ctx, runtime) {
 		evidence.persist(cwd, snapshot);
 		return true;
 	});
+	const pending = installPendingCapture(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 +28444,7 @@ function attachRuntime(ctx, runtime) {
 	async function cleanup() {
 		await stopCapture();
 		evidence.dispose();
+		pending.dispose();
 		runtime.fileVersions.dispose();
 		closeArchiveDbs();
 		disposeAllServers();