dsh-vscode-mode 0.9.0 → 0.11.0

package/lib/index.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { chmod, copyFile, cp, mkdir, readFile, readdir, rename, rm, stat, truncate, writeFile } from "node:fs/promises";
-import { basename, dirname, extname, join, normalize, resolve, sep } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, normalize, posix, relative, resolve, sep, win32 } from "node:path";
 import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync, watch, writeFileSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { homedir, tmpdir } from "node:os";
@@ -8335,6 +8335,32 @@ function patchInsertPerfConfig(text) {
 	return patchRemovePerfConfig(text).replace(/\n+$/, "") + "\n" + perfConfigBlock();
 }
 //#endregion
+//#region src/settingsDocPath.ts
+/**
+* Resolve the settings document only when the request names its exact configured path.
+*
+* Both sides are resolved with the path rules of `platform` (win32 → `C:`-style paths and
+* case-insensitive comparison; otherwise POSIX rules and case-sensitive comparison), so the
+* function keeps its meaning when the host platform is passed explicitly instead of implied.
+* @author ddj 2026年10月02号
+* @param configuredPath Path exposed by the active settings provider
+* @param requestedPath Path requested by the editor RPC
+* @param platform Platform whose path rules resolve both sides and drive case comparison
+* @returns The configured absolute path when authorized; otherwise null
+*/
+function settingsDocPath(configuredPath, requestedPath, platform = process.platform) {
+	if (typeof configuredPath !== "string" || !configuredPath.trim() || !requestedPath) return null;
+	try {
+		const api = platform === "win32" ? win32 : posix;
+		const configured = api.resolve(configuredPath);
+		const requested = api.resolve(requestedPath);
+		const fold = (value) => platform === "win32" ? value.toLowerCase() : value;
+		return fold(configured) === fold(requested) ? configured : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/rpc.ts
 /** cwd → 上次 stale 自动清理时间：全量轮询（EditorView/DiffBadge/Dock 各自 5s）节流，避免每轮都读文件算指纹。 */
 const staleCheckedAt = /* @__PURE__ */ new Map();
@@ -8384,6 +8410,20 @@ function snippetTargetOf(path) {
 	return isSnippetFilePath(path) ? path.replace(/\\/g, "/") : null;
 }
 /**
+* 返回与当前 settings provider 文档路径精确匹配的授权目标。
+* @author ddj 2026年10月02号
+* @param ctx DSH host 上下文
+* @param path 编辑器请求路径
+* @returns provider 当前配置文档的绝对路径；未匹配返回 null
+*/
+function settingsTargetOf(ctx, path) {
+	try {
+		return settingsDocPath(ctx.get("settings")?.documentPath, path);
+	} catch {
+		return null;
+	}
+}
+/**
 * 二进制/文本读取共用前置（edrv.read 与 edrv.readBinary）：解析路径 + debugRecord +
 * stat + 文件类型校验 + 32MB 二进制上限，保证两条读通道的错误口径完全一致。
 * @author ddj 2026年09月22号
@@ -8748,6 +8788,31 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 			};
 		},
 		"edrv.read": async (args) => {
+			const settingsTarget = settingsTargetOf(ctx, args.path);
+			if (settingsTarget && args.encoding !== "base64") try {
+				const info = await stat(settingsTarget);
+				if (!info.isFile()) return {
+					ok: false,
+					error: "设置配置文件不存在"
+				};
+				if (info.size > 8388608) return {
+					ok: false,
+					error: "设置配置文件过大（>8MB）"
+				};
+				const content = await readFile(settingsTarget, "utf8");
+				return {
+					ok: true,
+					content,
+					size: content.length,
+					version: fileVersionOf(info)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "读取设置配置文件失败：" + String(error),
+					resolvedPath: settingsTarget
+				};
+			}
 			const snippetTarget = snippetTargetOf(args.path);
 			if (snippetTarget && args.encoding !== "base64") try {
 				const content = await readFile(snippetTarget, "utf8");
@@ -8829,11 +8894,47 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 			}
 		},
 		"edrv.versions": async (args) => {
+			const items = [];
+			const regularPaths = [];
+			for (const path of args.paths) {
+				const target = settingsTargetOf(ctx, path);
+				if (!target) {
+					regularPaths.push(path);
+					continue;
+				}
+				try {
+					const info = await stat(target);
+					items.push({
+						path,
+						version: fileVersionOf(info),
+						size: info.size,
+						type: "file"
+					});
+				} catch (error) {
+					items.push({
+						path,
+						version: "",
+						type: "missing",
+						error: String(error)
+					});
+				}
+			}
+			if (regularPaths.length === 0) return {
+				ok: true,
+				items
+			};
 			if (!fileVersions) return {
 				ok: false,
 				error: "文件版本观察器未装配"
 			};
-			return fileVersions.versions(args);
+			const regular = await fileVersions.versions({
+				...args,
+				paths: regularPaths
+			});
+			return {
+				...regular,
+				items: [...items, ...regular.items]
+			};
 		},
 		"edrv.original": async (args) => {
 			const sc = await requireSession(ctx, args.sessionId);
@@ -8890,6 +8991,29 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 			}
 		},
 		"edrv.save": async (args) => {
+			const settingsTarget = settingsTargetOf(ctx, args.path);
+			if (settingsTarget) try {
+				const currentRev = fileVersionOf(await stat(settingsTarget));
+				if (args.rev && args.rev !== currentRev) return {
+					ok: false,
+					conflict: true,
+					error: "设置配置文件已被外部修改，请先重新加载"
+				};
+				if (settingsTargetOf(ctx, args.path) !== settingsTarget) return {
+					ok: false,
+					error: "设置配置文件路径已变化，拒绝保存"
+				};
+				await writeFile(settingsTarget, args.content, "utf8");
+				return {
+					ok: true,
+					rev: fileVersionOf(await stat(settingsTarget).catch(() => null)) || currentRev
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "保存设置配置文件失败：" + String(error)
+				};
+			}
 			const snippetTarget = snippetTargetOf(args.path);
 			if (snippetTarget) try {
 				await writeFile(snippetTarget, args.content, "utf8");
@@ -9580,6 +9704,29 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				revision: section?.revision
 			};
 		},
+		"vscode.settingsDocumentPath": async () => {
+			try {
+				const settings = ctx.get("settings");
+				if (typeof settings?.prepareDocument !== "function") return {
+					ok: false,
+					error: "设置配置文件不可用"
+				};
+				const path = await settings.prepareDocument();
+				if (typeof path !== "string" || !path.trim()) return {
+					ok: false,
+					error: "设置配置文件路径为空"
+				};
+				return {
+					ok: true,
+					path
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "准备设置配置文件失败：" + String(error)
+				};
+			}
+		},
 		"vscode.fileOpenSettingsUpdate": async (args) => {
 			const settings = ctx.get("settings");
 			const patch = { fileOpenTool: normalizeFileOpenTool(args.fileOpenTool) };
@@ -10892,6 +11039,18 @@ function deriveDefinitionFromLocations(queryPos, locations, docText, docAbsPath)
 * 请求封装（definition/references/documentSymbol/workspaceSymbol/hover）、状态上报。
 * 作者 ddj 2026-08-27
 */
+const MAX_DOC_VERSION = 2147483647;
+/**
+* 使用合法、递增的 Int32 文档版本；旧客户端的毫秒时间戳不能直发给 Roslyn。
+* @author ddj 2026年09月24号
+* @param incoming 客户端传来的版本
+* @param previous 当前服务器记录的版本
+* @returns 可发送给语言服务器的版本
+*/
+function lspDocVersion(incoming, previous) {
+	const next = Math.min(MAX_DOC_VERSION, (previous ?? 0) + 1);
+	return Number.isInteger(incoming) && incoming >= next && incoming <= MAX_DOC_VERSION ? incoming : next;
+}
 /**
 * 创建语言服务器会话。
 * @author ddj 2026年08月27号
@@ -11079,13 +11238,14 @@ function createLspServer(spec, root, languageId, logger) {
 		sync(path, text, version) {
 			const existing = docs.get(path);
 			const uri = existing?.uri ?? docUriOf(path);
+			const safeVersion = lspDocVersion(version, existing?.version);
 			if (existing) {
-				existing.version = version;
+				existing.version = safeVersion;
 				existing.text = text;
 				if (phase === "ready" || phase === "indexing") client?.notify("textDocument/didChange", {
 					textDocument: {
 						uri,
-						version
+						version: safeVersion
 					},
 					contentChanges: [{ text }]
 				});
@@ -11094,13 +11254,13 @@ function createLspServer(spec, root, languageId, logger) {
 			docs.set(path, {
 				path,
 				uri,
-				version,
+				version: safeVersion,
 				text
 			});
 			if (phase === "ready" || phase === "indexing") client?.notify("textDocument/didOpen", { textDocument: {
 				uri,
 				languageId,
-				version,
+				version: safeVersion,
 				text
 			} });
 		},
@@ -11606,6 +11766,13 @@ function normalizeSemanticData(data, types, modifiers) {
 * 实例注册表（key=root|languageId，refcount 共享），崩溃退避重启，session/disposed 清理。
 * 作者 ddj 2026-08-27
 */
+const BACKOFF_MS = [
+	1e3,
+	5e3,
+	3e4
+];
+const MAX_FAILURES = 3;
+const STABLE_MS = 6e4;
 /**
 * 创建 LSP 管理器。
 * @author ddj 2026年08月27号
@@ -11616,6 +11783,20 @@ function createLspManager(logger) {
 	const entries = /* @__PURE__ */ new Map();
 	const keyOf = (root, languageId) => root + "|" + languageId;
 	const log = (line) => logger?.("[lsp-manager] " + line);
+	/**
+	* 重试耗尽后保留退出根因，并让 UI 不再误报“未启动”。
+	* @author ddj 2026年09月24号
+	* @param entry 服务器条目
+	* @returns 当前可见状态
+	*/
+	const statusOf = (entry) => {
+		const status = entry.server.status();
+		return entry.failures >= MAX_FAILURES ? {
+			...status,
+			phase: "unavailable",
+			reason: (status.reason ?? "服务器已退出") + "（已停止自动重试）"
+		} : status;
+	};
 	/** 同步摘除注册表项并后台回收（refs 归零/工作区清理用；statusAll 立即可见归零）。 */
 	const dropEntry = (entry) => {
 		if (entry.restartTimer) {
@@ -11625,6 +11806,25 @@ function createLspManager(logger) {
 		entries.delete(entry.key);
 		entry.server.dispose().catch(() => {});
 	};
+	const scheduleRestart = (entry) => {
+		if (entry.restartTimer || entry.refs === 0 || entries.get(entry.key) !== entry) return;
+		if (entry.failures >= MAX_FAILURES) {
+			log("unavailable after " + entry.failures + " failures: " + entry.key);
+			manager.onStatusChange?.(statusOf(entry));
+			return;
+		}
+		const delay = BACKOFF_MS[Math.min(Math.max(entry.failures - 1, 0), BACKOFF_MS.length - 1)];
+		entry.restartTimer = setTimeout(() => {
+			entry.restartTimer = null;
+			if (entries.get(entry.key) !== entry || entry.refs === 0) return;
+			(async () => {
+				if (!await entry.server.start() && entries.get(entry.key) === entry && !entry.restartTimer) {
+					entry.failures++;
+					scheduleRestart(entry);
+				}
+			})();
+		}, delay);
+	};
 	const manager = {
 		acquire(root, languageId, resolveSpec) {
 			const key = keyOf(root, languageId);
@@ -11632,17 +11832,33 @@ function createLspManager(logger) {
 			if (!entry) {
 				const spec = resolveSpec(languageId);
 				const server = createLspServer(spec, root, languageId, log);
-				server.onStateChange = (status) => manager.onStatusChange?.(status);
 				entry = {
 					key,
 					server,
 					refs: 0,
 					failures: 0,
+					readyAt: 0,
 					restartTimer: null
 				};
 				entries.set(key, entry);
+				server.onStateChange = (status) => {
+					const live = entries.get(key);
+					if (live?.server === server) {
+						if (status.phase === "ready" && live.readyAt === 0) live.readyAt = Date.now();
+						if (status.phase === "idle" && status.reason?.startsWith("服务器已退出")) {
+							if (live.readyAt && Date.now() - live.readyAt >= STABLE_MS) live.failures = 0;
+							live.failures++;
+							live.readyAt = 0;
+							scheduleRestart(live);
+						}
+					}
+					manager.onStatusChange?.(live?.server === server ? statusOf(live) : status);
+				};
 				if (spec.ready) server.start().then((ok) => {
-					if (!ok && entries.has(key)) entry.failures++;
+					if (!ok && entries.get(key) === entry && server.phase === "idle" && !entry.restartTimer) {
+						entry.failures++;
+						scheduleRestart(entry);
+					}
 				});
 			}
 			entry.refs++;
@@ -11665,7 +11881,7 @@ function createLspManager(logger) {
 			for (const entry of [...entries.values()]) if (entry.server.languageId === languageId) dropEntry(entry);
 		},
 		statusAll() {
-			return [...entries.values()].map((entry) => entry.server.status());
+			return [...entries.values()].map(statusOf);
 		},
 		peek(root, languageId) {
 			return entries.get(keyOf(root, languageId))?.server;
@@ -12920,6 +13136,74 @@ function langOfPath(path) {
 	})) if (exts.includes(ext)) return lang;
 	return null;
 }
+/**
+* 判断 needle 是否为 haystack 的子序列（两侧均已小写）。
+*
+* 与 Monaco 候选列表的模糊匹配同口径，保证「分桶判为命中」的条目确实是
+* 用户输入能筛出来的那些，避免分桶顺序与前端过滤结果互相矛盾。
+* @author ddj 2026年09月24号
+* @param haystack 候选文本（已小写）
+* @param needle 输入前缀（已小写、非空）
+* @returns 是否为子序列
+*/
+function isSubsequence(haystack, needle) {
+	let matched = 0;
+	for (let i = 0; i < haystack.length && matched < needle.length; i++) if (haystack[i] === needle[matched]) matched++;
+	return matched === needle.length;
+}
+/**
+* 取补全项的匹配文本（Monaco 口径：filterText 优先，回落 label；统一小写）。
+* @author ddj 2026年09月24号
+* @param item 补全项
+* @returns 小写匹配文本；无可用文本时为空串
+*/
+function textOfItem(item) {
+	const raw = typeof item?.filterText === "string" && item.filterText ? item.filterText : item?.label;
+	return typeof raw === "string" ? raw.toLowerCase() : "";
+}
+/**
+* 按输入前缀分桶后截断补全列表。
+*
+* 分桶优先级：startsWith > includes > 子序列 > 其余；桶内保持服务器原始顺序
+* （服务器已按相关性排序，不重新打分）。无前缀或未超限时与旧行为完全一致。
+* @author ddj 2026年09月24号
+* @param items 服务器归一化后的补全条目
+* @param prefix 当前输入前缀（Monaco getWordUntilPosition 的词）
+* @param cap 条目上限（缺省 COMPLETION_ITEM_CAP；测试可注入小值）
+* @returns 有界条目与截断标记
+*/
+function capCompletions(items, prefix, cap = 500) {
+	if (!Array.isArray(items)) return {
+		items: [],
+		truncated: false
+	};
+	if (items.length <= cap) return {
+		items,
+		truncated: false
+	};
+	const needle = String(prefix ?? "").toLowerCase();
+	if (!needle) return {
+		items: items.slice(0, cap),
+		truncated: true
+	};
+	const buckets = [
+		[],
+		[],
+		[],
+		[]
+	];
+	for (const item of items) {
+		const text = textOfItem(item);
+		if (text.startsWith(needle)) buckets[0].push(item);
+		else if (text.includes(needle)) buckets[1].push(item);
+		else if (isSubsequence(text, needle)) buckets[2].push(item);
+		else buckets[3].push(item);
+	}
+	return {
+		items: buckets[0].concat(buckets[1], buckets[2], buckets[3]).slice(0, cap),
+		truncated: true
+	};
+}
 //#endregion
 //#region src/lsp/envRequirements.ts
 /**
@@ -13484,13 +13768,16 @@ function createLspRpc(deps) {
 						ok: true,
 						completions: void 0
 					};
+					const capped = capCompletions(completions.items, args.prefix);
+					const payload = {
+						...completions,
+						items: capped.items
+					};
+					if (capped.truncated) payload.truncated = true;
+					else delete payload.truncated;
 					return {
 						ok: true,
-						completions: completions.items.length > 500 ? {
-							...completions,
-							items: completions.items.slice(0, 500),
-							truncated: true
-						} : completions
+						completions: payload
 					};
 				} catch (error) {
 					return {
@@ -14382,7 +14669,27 @@ const UPDATE_ACTION_LABEL = {
 	" ": "无变化"
 };
 /** update 结果行：行首若干空白 + 单字母 + 空白 + 路径（路径可含空格，取整段）。 */
-const UPDATE_LINE_RE = /^([ADGCEUR]|\s{3})\s{2,}(\S.*)$/;
+const UPDATE_LINE_RE = /^([A-Z_ ]{1,4})\s{2,}(\S.*)$/;
+/**
+* 解析 update 的单行状态（正文/摘要不匹配）。属性列 U/C 也按该条目状态处理。
+* @author ddj 2026年09月24号
+* @param line 原始输出行
+* @returns 可识别条目或 null
+*/
+function updateLineOf(line) {
+	const hit = UPDATE_LINE_RE.exec(line);
+	if (!hit) return null;
+	const status = hit[1].replace(/[ _]/g, "");
+	if (!status || /[^ADGCEUR]/.test(status)) return null;
+	const action = status.includes("C") ? "C" : status[0];
+	const path = hit[2].trim();
+	if (!path) return null;
+	return {
+		action,
+		path,
+		label: UPDATE_ACTION_LABEL[action] ?? action
+	};
+}
 /**
 * 解析 `svn update` 文本输出为**条目级**结构化结果（附冲突清单与一行摘要）。
 *
@@ -14404,16 +14711,10 @@ function updateResultOf(stdout, stderr, code) {
 	const entries = [];
 	const conflicts = [];
 	for (const line of output.split(/\r?\n/)) {
-		const hit = UPDATE_LINE_RE.exec(line);
-		if (hit) {
-			const action = hit[1].trim();
-			const path = hit[2].trim();
-			if (path && entries.length < 4e3) entries.push({
-				action,
-				path,
-				label: UPDATE_ACTION_LABEL[action] ?? action
-			});
-			if (action === "C" && conflicts.length < 64) conflicts.push(path);
+		const entry = updateLineOf(line);
+		if (entry) {
+			if (entries.length < 4e3) entries.push(entry);
+			if (entry.action === "C" && conflicts.length < 64) conflicts.push(entry.path);
 			continue;
 		}
 		const loose = /^(?:\s?[A-Z_ ]?C)\s+(\S.*)$/.exec(line);
@@ -14697,153 +14998,798 @@ function parseSvnInfoRevision(xml) {
 	const at = /<commit[^>]*\brevision="(\d+)"/.exec(text);
 	return at ? Number(at[1]) : null;
 }
-/** CLI 探测超时。 */
-const CLI_GRACE_MS = 6e3;
-/** svn update 超时（大工作副本留足预算）。 */
-const UPDATE_GRACE_MS = 18e4;
-/** TortoiseProc 发射超时预算（不 await done，仅约束服务侧资源）。 */
-const TORTOISE_GRACE_MS = 6e5;
-/** 前台置顶助手超时预算（轮询 ≤8s + PowerShell 启动余量）。 */
-const HELPER_GRACE_MS = 2e4;
-/** 输出载荷上限（1MB，对齐 runSvn stdio 限额；文本解析上限见 svnText.TEXT_OUTPUT_CAP）。 */
-const OUTPUT_CAP = TEXT_OUTPUT_CAP;
-/**
-* 日志拉取的 stdout 上限：默认窗口 LOG_CAP=500 条、Show All 上限 SVN_LOG_SHOW_ALL_CAP=5000 条。
-*
-* 实测（2026-09-18，IslandSplash_BugFix `Assets`，svn 1.14.5）：`-l 500` → 2.52MB / 2.0s，
-* `-l 5000` → 18.86MB / 30.1s（约 3.8~5KB/条，含中文路径与提交信息）。故取 64MB 留约 3× 余量，
-* `-g`（merged）单条更大也吃这份余量。
-* 实测教训（勿复踩）：默认 1MB 上限时收集器保留**尾部**，Assets 全量 100 条（1.19MB）
-* 恰好把最新的 52 条挤出（用户报「显示的数据不对」）。
-* @author ddj 2026年09月17号 / 2026年09月18号
-*/
-const LOG_OUTPUT_CAP = 67108864;
-/** 变更条目上限（防超大工作副本撑爆载荷）。 */
-const CHANGES_CAP = 4e3;
-/** `svn status --xml` 超时（大工作副本留足预算）。 */
-const STATUS_GRACE_MS = 12e4;
-/** 其他只读子命令（cat/info）超时。 */
-const READ_GRACE_MS = 3e4;
-/** revert/add 超时。 */
-const MUTATE_GRACE_MS = 12e4;
-/** 文本读取上限（对齐 rpc.ts READ_CAP：>8MB 拒绝整文件读取/差异）。 */
-const READ_CAP = 8388608;
-/**
-* W2-1 补丁文本输出上限（16MB）。实测教训复用（PROGRESS §六.1）：DSH stdout 收集器
-* 超限**保留尾部**——补丁被截断时头部 `Index:` 会丢失，host 以「不以 Index: 开头」
-* 标记 truncated，客户端明示「不完整」而非让用户拿半份补丁去用。
-*/
-const PATCH_OUTPUT_CAP = 16777216;
-/** W2-2 目录对比 summarize 输出上限（8MB；大目录长区间的变更条目 XML）。 */
-const SUM_OUTPUT_CAP = 8388608;
-/**
-* W2-3 远端检查超时（15s）。M3 实测：无凭据/离线时 `status -u` 会长时间挂起
-* （受限沙箱内 120s 无输出），远端检查必须短超时 + 失败降级，绝不阻塞面板。
-*/
-const REMOTE_GRACE_MS = 15e3;
-/** W2-2 summarize 服务器往返预算（大目录长区间可能较慢）。 */
-const SUM_GRACE_MS = 6e4;
-/** 工作副本根向上查找（≤10 层，命中含 .svn 的最近祖先）。 */
-const SVN_ROOT_MAX_DEPTH = 10;
-/** 默认存在性探测（node fs；异常一律按不存在）。 */
-const defaultExists = async (path) => {
-	try {
-		await stat(path);
-		return true;
-	} catch {
-		return false;
-	}
-};
+//#endregion
+//#region src/svnUpdateJob.ts
 /**
-* 从 cwd 向上查找 SVN 工作副本根（.svn 目录/文件均算，SvnHelper 同口径）。
-* `.svn` 判定与平台无关（Linux/macOS 亦为目录），无需平台参数。
-* @author ddj 2026年09月16号
-* @param cwd 起始绝对路径
-* @param exists 存在性探测（测试注入）
-* @returns 工作副本根绝对路径；未命中返回 null
+* dsh-vscode-mode host — SVN update job with incremental output and bounded replay.
+* @author ddj 2026年09月24号
 */
-async function findSvnRoot(cwd, exists = defaultExists) {
-	let dir = cwd;
-	for (let depth = 0; dir && depth < SVN_ROOT_MAX_DEPTH; depth += 1) {
-		if (await exists(join(dir, ".svn"))) return dir;
-		const parent = dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-	return null;
-}
+const ROW_CAP = 2e4;
+const PAGE_SIZE = 250;
+const LINE_CAP = 16e3;
+const JOB_CAP = 16;
+const RESULT_TTL_MS = 6e5;
+const UPDATE_MAX_MS = 36e5;
+const COLLECT_MS = 100;
 /**
-* 解析 TortoiseProc.exe（候选序：设置目录 → bin 子目录 → 默认安装目录 → PATH 逐项）。
-* @author ddj 2026年09月16号
-* @param dirSetting 设置里的 TortoiseSVN 目录（空 = 默认）
-* @param exists 存在性探测（测试注入）
-* @param platform 目标平台（非 win32 恒 null）
-* @param pathEnv PATH 环境变量（测试注入）
-* @returns TortoiseProc.exe 绝对路径；不可用返回 null
+* 创建每个任务独立的 SVN 状态计数。
+* @author ddj 2026年09月24号
+* @returns 初始计数
 */
-async function findTortoiseProc(dirSetting, exists = defaultExists, platform = process.platform, pathEnv = process.env?.PATH) {
-	if (platform !== "win32") return null;
-	const dir = dirSetting && dirSetting.trim() ? dirSetting.trim() : "";
-	const candidates = [dir && join(dir, "bin", "TortoiseProc.exe"), dir && join(dir, "TortoiseProc.exe")].filter((item) => Boolean(item));
-	for (const entry of (pathEnv ?? "").split(";")) {
-		const trim = entry.trim();
-		if (trim) candidates.push(join(trim, TORTOISE_EXE));
-	}
-	for (const candidate of candidates) if (await exists(candidate)) return candidate;
-	return null;
+function emptyCounts() {
+	return {
+		A: 0,
+		U: 0,
+		D: 0,
+		G: 0,
+		C: 0,
+		E: 0,
+		R: 0
+	};
 }
 /**
-* svn:ignore 名称合法性校验（host 权威；防换行注入 propset 值与路径穿越）。
-* 规则：去空白后非空、无换行、无路径分隔符、不以 `-` 开头（防被 svn 当选项解析）。
-* @author ddj 2026年09月23号
-* @param name 待写入的忽略名（basename / 通配模式）
-* @returns 错误文案；合法为 null
+* 工作副本根作为并发键；Windows 路径大小写不敏感。
+* @author ddj 2026年09月24号
+* @param root 工作副本根
+* @param platform 目标平台
+* @returns 并发键
 */
-function ignoreNameErrorOf(name) {
-	if (typeof name !== "string") return "忽略名必须是字符串";
-	const trimmed = name.trim();
-	if (!trimmed) return "忽略名不能为空";
-	if (/[\r\n]/.test(trimmed)) return "忽略名不能包含换行";
-	if (trimmed.includes("/") || trimmed.includes("\\")) return "忽略名不能包含路径分隔符";
-	if (trimmed.startsWith("-")) return "忽略名不能以 - 开头";
-	return null;
+function rootKey(root, platform) {
+	return platform === "win32" ? root.toLowerCase() : root;
 }
 /**
-* 本插件已自研的 SVN 能力（「自研替换时间线」的推进点）。
-*
-* 每完成一个阶段就把对应能力加进来：client 会据此隐藏被覆盖的 TortoiseProc 项，
-* 避免自研项与官方同名项并列、用户误点到官方弹窗。
-* 当前：差异（P2「与基线比较」）、还原（P2 `revert -R`）、日志（P3 日志弹窗）。
-* 待补：提交（P4 完成后加入 'commit'）；追溯无自研计划（P5 另议），故不含 'blame'。
+* 有状态更新任务：原 RPC 与新后台任务独立，测试可注入进程服务/时钟。
+* @author ddj 2026年09月24号
 */
-const SVN_FEATURES = [
-	"diff",
-	"revert",
-	"log"
-];
-/** `svn status --xml` 的 `<wc-status item="...">` 合法取值（未知值一律按 modified 兜底）。 */
-const KNOWN_ITEM_STATUS = /* @__PURE__ */ new Set([
-	"normal",
-	"added",
-	"deleted",
-	"replaced",
-	"conflicted",
-	"missing",
-	"unversioned",
-	"obstructed",
-	"ignored",
-	"modified",
-	"external",
-	"incomplete"
-]);
-/** 受版本控制判据：unversioned/ignored 之外均为版本化条目。 */
-const UNVERSIONED_STATUS = /* @__PURE__ */ new Set(["unversioned", "ignored"]);
-/**
-* 归一化 XML 中的条目路径为工作区相对路径（`/` 分隔、无前导 `./`）。
-* XML 路径相对「执行 status 时的 cwd」（实测 Windows 下用 `\`），故 host 必须以
-* 工作副本根为 cwd 执行，这里只做分隔符与形态归一；`''`/`.` 表示根自身。
-* @author ddj 2026年09月16号
-* @param raw XML path 属性原文（已反转义）
+var SvnUpdateJobs = class {
+	service;
+	jobs = /* @__PURE__ */ new Map();
+	platform;
+	now;
+	/**
+	* 建立任务管理器。
+	* @author ddj 2026年09月24号
+	* @param service DSH subprocess 服务获取器
+	* @param platform 平台
+	* @param now 时钟
+	*/
+	constructor(service, platform = process.platform, now = Date.now) {
+		this.service = service;
+		this.platform = platform;
+		this.now = now;
+	}
+	/**
+	* 同根重复点击只返回当前任务；旧结果可由 active 取回，新点击启动新任务。
+	* @author ddj 2026年09月24号
+	* @param target 已验证的工作副本目标
+	* @returns 任务初始状态
+	*/
+	start(target) {
+		this.prune();
+		const key = rootKey(target.root, this.platform);
+		const old = this.jobs.get(key);
+		if (old && !this.isFinal(old.phase)) return this.stateOf(old);
+		if (!old && this.jobs.size >= JOB_CAP) throw new Error("同时保留的 SVN 更新任务过多，请稍后重试");
+		const job = {
+			id: randomUUID(),
+			root: target.root,
+			cwd: target.cwd,
+			target: target.path,
+			phase: "starting",
+			counts: emptyCounts(),
+			revision: null,
+			error: "",
+			rawTail: "",
+			truncated: false,
+			startedAt: this.now(),
+			endedAt: null,
+			rows: [],
+			seq: 0,
+			pending: "",
+			cancelled: false,
+			exited: false
+		};
+		this.jobs.set(key, job);
+		this.launch(job, target.exe);
+		return this.stateOf(job);
+	}
+	/**
+	* 游标分页取状态；即使前端掉线，有限窗口仍可重新读取。
+	* @author ddj 2026年09月24号
+	* @param root 已验证会话的工作副本根
+	* @param jobId 任务 id
+	* @param since 最后一条已读序号
+	* @returns 一页增量及状态
+	*/
+	poll(root, jobId, since) {
+		const job = this.getJob(root, jobId);
+		const offset = job.rows[0]?.seq ?? job.seq + 1;
+		const cursor = Math.max(offset - 1, Number.isFinite(since) ? Math.floor(since) : 0);
+		const start = Math.max(0, cursor - offset + 1);
+		const rows = job.rows.slice(start, start + PAGE_SIZE);
+		return {
+			...this.stateOf(job),
+			rows,
+			offset,
+			totalSeq: job.seq,
+			nextSeq: rows.at(-1)?.seq ?? cursor
+		};
+	}
+	/**
+	* 请求终止整个受管进程范围；真实退出前保持 cancelling 状态。
+	* @author ddj 2026年09月24号
+	* @param root 已验证会话的工作副本根
+	* @param jobId 任务 id
+	* @returns 当前状态
+	*/
+	cancel(root, jobId) {
+		const job = this.getJob(root, jobId);
+		if (!this.isFinal(job.phase) && !job.exited) {
+			job.cancelled = true;
+			job.phase = "cancelling";
+			job.probeAbort?.abort(/* @__PURE__ */ new Error("用户已取消 SVN 更新"));
+			try {
+				job.stop?.();
+			} catch (error) {
+				job.error = String(error);
+			}
+		}
+		return this.stateOf(job);
+	}
+	/**
+	* 按当前会话工作副本恢复进行中或最近一次结果。
+	* @author ddj 2026年09月24号
+	* @param root 已验证的工作副本根
+	* @returns 状态或 null
+	*/
+	active(root) {
+		this.prune();
+		const job = this.jobs.get(rootKey(root, this.platform));
+		return job ? this.stateOf(job) : null;
+	}
+	/**
+	* 插件卸载回收任务与定时器。
+	* @author ddj 2026年09月24号
+	*/
+	dispose() {
+		for (const job of this.jobs.values()) {
+			if (job.timer) clearInterval(job.timer);
+			if (job.deadline) clearTimeout(job.deadline);
+			if (!this.isFinal(job.phase)) {
+				job.cancelled = true;
+				job.probeAbort?.abort(/* @__PURE__ */ new Error("SVN 插件已卸载"));
+				try {
+					job.stop?.();
+				} catch {}
+			}
+		}
+		this.jobs.clear();
+	}
+	/**
+	* 先用只读 version 探测捕获通道，再允许启动会修改工作副本的 update。
+	* @author ddj 2026年09月24号
+	* @param job 待启动任务
+	* @param exe 已配置 SVN CLI
+	*/
+	async launch(job, exe) {
+		const controller = new AbortController();
+		job.probeAbort = controller;
+		const probeDeadline = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("SVN 输出探测超时（8 秒）")), 8e3);
+		probeDeadline.unref?.();
+		try {
+			const service = this.service();
+			if (!service) throw new Error("subprocess 服务不可用");
+			const modes = this.platform === "win32" ? ["terminal", "collect"] : ["collect", "terminal"];
+			let mode = null;
+			let reason = "";
+			for (const candidate of modes) {
+				controller.signal.throwIfAborted();
+				try {
+					await this.probe(service, exe, job.cwd, candidate, controller.signal);
+					mode = candidate;
+					break;
+				} catch (error) {
+					if (controller.signal.aborted) throw error;
+					reason = String(error);
+				}
+			}
+			if (job.cancelled) {
+				this.finish(job, null);
+				return;
+			}
+			if (!mode) throw new Error("SVN 输出通道不可用：" + reason);
+			clearTimeout(probeDeadline);
+			await this.startUpdate(job, service, mode, exe, controller);
+		} catch (error) {
+			job.error = String(error);
+			this.finish(job, null);
+		} finally {
+			clearTimeout(probeDeadline);
+			job.probeAbort = void 0;
+		}
+	}
+	/**
+	* 分配实际更新句柄时继续允许取消；未完成的分配不盲目重试更新。
+	* @author ddj 2026年09月24号
+	* @param job 当前任务
+	* @param service DSH 子进程服务
+	* @param mode 已探测可用的流式通道
+	* @param exe SVN 可执行文件
+	* @param controller 启动阶段的取消信号
+	*/
+	async startUpdate(job, service, mode, exe, controller) {
+		const argv = [
+			exe,
+			"--non-interactive",
+			"update",
+			"--",
+			job.target || "."
+		];
+		job.phase = "running";
+		job.stop = () => controller.abort(/* @__PURE__ */ new Error("更新启动期间被取消"));
+		job.deadline = setTimeout(() => {
+			job.error = "SVN 更新超过 60 分钟，已请求停止；工作副本可能已部分更新";
+			try {
+				job.stop?.();
+			} catch {}
+		}, UPDATE_MAX_MS);
+		job.deadline.unref?.();
+		if (mode === "terminal" && service.spawnTerminal) {
+			const pending = service.spawnTerminal({
+				...this.terminalSpec(argv, job.cwd),
+				signal: controller.signal
+			});
+			const handle = await this.awaitTerminal(pending, controller.signal);
+			job.stop = () => {
+				handle.terminate().catch((error) => {
+					job.error = String(error);
+				});
+			};
+			if (job.cancelled) job.stop();
+			this.watchTerminal(job, handle);
+		} else {
+			const handle = service.spawn({
+				...this.collectSpec(argv, job.cwd),
+				signal: controller.signal
+			});
+			job.stop = () => handle.terminate();
+			if (job.cancelled) job.stop();
+			this.watchCollect(job, handle);
+		}
+	}
+	/**
+	* 终端句柄分配与 Abort 之间的微任务间隙也必须回收晚到句柄。
+	* @author ddj 2026年09月24号
+	* @param pending 分配中的终端
+	* @param signal 用户取消或截止信号
+	* @returns 可受管的终端句柄
+	*/
+	async awaitTerminal(pending, signal) {
+		let handle = null;
+		const stop = () => {
+			if (handle) handle.terminate().catch(() => {});
+		};
+		signal.addEventListener("abort", stop, { once: true });
+		try {
+			const guarded = pending.then((ready) => {
+				handle = ready;
+				if (signal.aborted) stop();
+				return ready;
+			});
+			return await this.waitProbe(guarded, signal, () => {});
+		} finally {
+			signal.removeEventListener("abort", stop);
+		}
+	}
+	/**
+	* 探针/启动 Promise 可由超时和用户取消立即打断，并终止已分配的句柄。
+	* @author ddj 2026年09月24号
+	* @param pending 待完成操作
+	* @param signal 任务取消信号
+	* @param stop 停止已经分配的子进程
+	* @returns 操作结果
+	*/
+	waitProbe(pending, signal, stop) {
+		return new Promise((resolve, reject) => {
+			let finished = false;
+			const abort = () => {
+				if (finished) return;
+				finished = true;
+				try {
+					stop();
+				} catch {}
+				reject(signal.reason ?? /* @__PURE__ */ new Error("SVN 探测已取消"));
+			};
+			if (signal.aborted) {
+				abort();
+				pending.catch(() => {});
+				return;
+			}
+			signal.addEventListener("abort", abort, { once: true });
+			pending.then((value) => {
+				signal.removeEventListener("abort", abort);
+				if (!finished) {
+					finished = true;
+					resolve(value);
+				}
+			}, (error) => {
+				signal.removeEventListener("abort", abort);
+				if (!finished) {
+					finished = true;
+					reject(error);
+				}
+			});
+		});
+	}
+	/**
+	* 探针失败只换读法，不会重试一次已启动的实际 update。
+	* @author ddj 2026年09月24号
+	* @param service DSH 服务
+	* @param exe SVN 命令
+	* @param cwd 进程目录
+	* @param mode 输出通道
+	* @param signal 用户取消或探针超时
+	*/
+	async probe(service, exe, cwd, mode, signal) {
+		signal.throwIfAborted();
+		const argv = [
+			exe,
+			"--version",
+			"--quiet"
+		];
+		if (mode === "terminal") {
+			if (!service.spawnTerminal) throw new Error("终端输出通道不可用");
+			const pending = service.spawnTerminal({
+				...this.terminalSpec(argv, cwd),
+				signal
+			});
+			const handle = await this.awaitTerminal(pending, signal);
+			let text = "";
+			let failure = "";
+			const drained = new Promise((resolve) => {
+				handle.output.on("data", (chunk) => {
+					text += String(chunk);
+				});
+				handle.output.once("end", resolve);
+				handle.output.once("error", (error) => {
+					failure = String(error);
+					resolve();
+				});
+			});
+			const outcome = await this.waitProbe(handle.done, signal, () => {
+				handle.terminate().catch(() => {});
+			});
+			await this.waitProbe(Promise.race([drained, new Promise((resolve) => {
+				setTimeout(resolve, 2e3).unref?.();
+			})]), signal, () => {
+				handle.terminate().catch(() => {});
+			});
+			if (outcome.exitCode !== 0 || !text.trim() || failure) throw new Error("终端输出探测失败：" + failure);
+			return;
+		}
+		const handle = service.spawn({
+			...this.collectSpec(argv, cwd),
+			signal
+		});
+		const outcome = await this.waitProbe(handle.done, signal, () => handle.terminate());
+		const text = handle.collected?.stdout?.readFrom(0).text ?? "";
+		if (outcome.exitCode !== 0 || !text.trim()) throw new Error("收集输出探测失败");
+	}
+	/**
+	* DSH PTY 读取：TextDecoder 保证跨数据块的 UTF-8 字符不被截断。
+	* @author ddj 2026年09月24号
+	* @param job 活动任务
+	* @param handle 终端句柄
+	*/
+	watchTerminal(job, handle) {
+		const decoder = new TextDecoder();
+		let drained = false;
+		let finishOutput = () => {};
+		const outputDone = new Promise((resolve) => {
+			finishOutput = resolve;
+		});
+		handle.output.on("data", (chunk) => {
+			const text = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+			this.ingest(job, text);
+		});
+		handle.output.on("end", () => {
+			drained = true;
+			this.ingest(job, decoder.decode());
+			finishOutput();
+		});
+		handle.output.on("error", (error) => {
+			job.error = "读取输出失败：" + String(error);
+			finishOutput();
+		});
+		handle.done.then(async (outcome) => {
+			job.exited = true;
+			if (!drained) await Promise.race([outputDone, new Promise((resolve) => {
+				setTimeout(resolve, 2e3).unref?.();
+			})]);
+			this.finish(job, outcome.exitCode);
+		}, (error) => {
+			job.exited = true;
+			job.error = String(error);
+			this.finish(job, null);
+		});
+	}
+	/**
+	* 管道收集的读取器独立管理 stdout/stderr 字节偏移；只消费完整行，避免截断中文。
+	* @author ddj 2026年09月24号
+	* @param job 活动任务
+	* @param handle 子进程句柄
+	*/
+	watchCollect(job, handle) {
+		const offsets = {
+			stdout: 0,
+			stderr: 0
+		};
+		job.timer = setInterval(() => this.readCollect(job, handle, offsets, false), COLLECT_MS);
+		job.timer.unref?.();
+		handle.done.then((outcome) => {
+			job.exited = true;
+			if (job.timer) clearInterval(job.timer);
+			this.readCollect(job, handle, offsets, true);
+			this.finish(job, outcome.exitCode ?? outcome.code ?? null);
+		}, (error) => {
+			job.exited = true;
+			job.error = String(error);
+			this.finish(job, null);
+		});
+	}
+	/**
+	* 从两个 bounded collector 取完整行；lossy 时标记不完整且不伪造丢失计数。
+	* @author ddj 2026年09月24号
+	* @param job 活动任务
+	* @param handle 子进程句柄
+	* @param offsets 各路已消费字节位置
+	* @param final 进程已结束，可以消费末尾无换行内容
+	*/
+	readCollect(job, handle, offsets, final) {
+		for (const key of ["stdout", "stderr"]) {
+			const reader = handle.collected?.[key];
+			if (!reader) {
+				job.truncated = true;
+				continue;
+			}
+			const read = reader.readFrom(offsets[key]);
+			if (read.lossy) {
+				job.truncated = true;
+				offsets[key] = read.nextOffset;
+				job.pending = "";
+				this.recordLine(job, "输出前段已截断，以下是可恢复的尾部记录", null);
+				const firstEnd = read.text.indexOf("\n");
+				if (firstEnd >= 0) this.ingest(job, read.text.slice(firstEnd + 1));
+				continue;
+			}
+			const last = final ? read.text.length : read.text.lastIndexOf("\n") + 1;
+			if (!last) continue;
+			const chunk = read.text.slice(0, last);
+			offsets[key] = final ? read.nextOffset : offsets[key] + Buffer.byteLength(chunk, "utf8");
+			this.ingest(job, chunk);
+		}
+	}
+	/**
+	* 增量行缓冲：ANSI 和 CR/LF 归一；过长单行主动截断并告警。
+	* @author ddj 2026年09月24号
+	* @param job 活动任务
+	* @param text 新输出
+	*/
+	ingest(job, text) {
+		if (!text) return;
+		job.pending += text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
+		const lines = job.pending.split(/\r\n|\n|\r/);
+		job.pending = lines.pop() ?? "";
+		for (const line of lines) this.recordLine(job, line, updateLineOf(line));
+		if (job.pending.length > LINE_CAP) {
+			job.truncated = true;
+			this.recordLine(job, job.pending.slice(0, LINE_CAP) + "…（单行过长）", null);
+			job.pending = "";
+		}
+	}
+	/**
+	* 记录有界行与原文；修订号只读 svn 自己的完成/无变化行。
+	* @author ddj 2026年09月24号
+	* @param job 活动任务
+	* @param line 完整输出行
+	* @param entry 可识别的逐文件状态
+	*/
+	recordLine(job, line, entry) {
+		const raw = line.trimEnd();
+		if (!raw) return;
+		job.rawTail = (job.rawTail + raw + "\n").slice(-32e3);
+		const rev = /(?:Updated to revision|At revision|已更新到版本|版本)\s*\.?\s*(\d+)/i.exec(raw);
+		if (rev) job.revision = Number(rev[1]);
+		if (entry) job.counts[entry.action] += 1;
+		const path = entry?.path ?? "";
+		const row = {
+			seq: ++job.seq,
+			action: entry?.action ?? null,
+			path,
+			relPath: entry ? this.relPathOf(job, path) : null,
+			label: entry?.label ?? raw.trim(),
+			raw
+		};
+		job.rows.push(row);
+		if (job.rows.length > ROW_CAP) {
+			job.rows.splice(0, 1e3);
+			job.truncated = true;
+		}
+	}
+	/**
+	* 只给工作区内的输出路径开放文件动作（不信任 CLI 文本直接当作目标）。
+	* @author ddj 2026年09月24号
+	* @param job 活动任务
+	* @param path SVN 输出路径
+	* @returns 工作区相对路径或 null
+	*/
+	relPathOf(job, path) {
+		const abs = resolve(job.cwd, path);
+		const wcRel = relative(job.root, abs);
+		const rel = relative(job.cwd, abs);
+		if (isAbsolute(wcRel) || wcRel === ".." || wcRel.startsWith("..\\") || wcRel.startsWith("../")) return null;
+		if (isAbsolute(rel) || rel === ".." || rel.startsWith("..\\") || rel.startsWith("../")) return null;
+		return rel.replace(/\\/g, "/") || null;
+	}
+	/**
+	* 保留终态行供用户检查，取消不能误报成功。
+	* @author ddj 2026年09月24号
+	* @param job 活动任务
+	* @param code 真实退出码
+	*/
+	finish(job, code) {
+		if (this.isFinal(job.phase)) return;
+		if (job.pending.trim()) this.recordLine(job, job.pending, updateLineOf(job.pending));
+		job.pending = "";
+		if (job.timer) {
+			clearInterval(job.timer);
+			job.timer = void 0;
+		}
+		if (job.deadline) {
+			clearTimeout(job.deadline);
+			job.deadline = void 0;
+		}
+		job.endedAt = this.now();
+		if (job.cancelled) job.phase = "cancelled";
+		else if (code === 0 && !job.error) job.phase = "completed";
+		else {
+			job.phase = "failed";
+			job.error ||= "SVN 更新失败（退出码 " + String(code) + "）：" + job.rawTail.slice(-500);
+		}
+	}
+	/**
+	* 快照不暴露可变数组；耗时使用现场时钟或终态时间。
+	* @author ddj 2026年09月24号
+	* @param job 目标任务
+	* @returns 纯数据快照
+	*/
+	stateOf(job) {
+		return {
+			jobId: job.id,
+			target: job.target,
+			phase: job.phase,
+			counts: { ...job.counts },
+			revision: job.revision,
+			elapsedMs: Math.max(0, (job.endedAt ?? this.now()) - job.startedAt),
+			error: job.error,
+			rawTail: this.isFinal(job.phase) || job.truncated ? job.rawTail : "",
+			truncated: job.truncated,
+			nextSeq: job.seq
+		};
+	}
+	/**
+	* 任务 ID 必须属于调用会话的工作副本根。
+	* @author ddj 2026年09月24号
+	* @param root 已验证工作副本根
+	* @param jobId 客户端任务 id
+	* @returns job
+	*/
+	getJob(root, jobId) {
+		this.prune();
+		const job = this.jobs.get(rootKey(root, this.platform));
+		if (!job || job.id !== jobId) throw new Error("SVN 更新任务不存在或工作区不匹配");
+		return job;
+	}
+	/**
+	* 清理过期终态，不丢活动中的更新。
+	* @author ddj 2026年09月24号
+	*/
+	prune() {
+		for (const [key, job] of this.jobs) if (job.endedAt !== null && this.now() - job.endedAt > RESULT_TTL_MS) this.jobs.delete(key);
+	}
+	/**
+	* 终态判断集中定义，避免取消请求被误视作结束。
+	* @author ddj 2026年09月24号
+	* @param phase 当前阶段
+	* @returns 是否结束
+	*/
+	isFinal(phase) {
+		return phase === "completed" || phase === "failed" || phase === "cancelled";
+	}
+	/**
+	* 不启 shell：每个 argv 直接传入，标准输入忽略且提供进程清理预算。
+	* @author ddj 2026年09月24号
+	* @param argv 可执行文件及参数
+	* @param cwd 目标工作目录
+	* @returns DSH terminal spec
+	*/
+	terminalSpec(argv, cwd) {
+		return {
+			argv,
+			cwd,
+			rows: 30,
+			cols: 180,
+			terminalType: "xterm-256color",
+			graceMs: 1e4
+		};
+	}
+	/**
+	* collected reader 大于单次 RPC：后台按 100ms 消费，避免 1MB 尾部静默丢头。
+	* @author ddj 2026年09月24号
+	* @param argv 可执行文件及参数
+	* @param cwd 目标工作目录
+	* @returns DSH process spec
+	*/
+	collectSpec(argv, cwd) {
+		return {
+			argv,
+			cwd,
+			graceMs: 1e4,
+			stdio: {
+				stdin: "ignore",
+				stdout: { maxBytes: 4194304 },
+				stderr: { maxBytes: 131072 }
+			}
+		};
+	}
+};
+/** CLI 探测超时。 */
+const CLI_GRACE_MS = 6e3;
+/** svn update 超时（大工作副本留足预算）。 */
+const UPDATE_GRACE_MS = 18e4;
+/** TortoiseProc 发射超时预算（不 await done，仅约束服务侧资源）。 */
+const TORTOISE_GRACE_MS = 6e5;
+/** 前台置顶助手超时预算（轮询 ≤8s + PowerShell 启动余量）。 */
+const HELPER_GRACE_MS = 2e4;
+/** 输出载荷上限（1MB，对齐 runSvn stdio 限额；文本解析上限见 svnText.TEXT_OUTPUT_CAP）。 */
+const OUTPUT_CAP = TEXT_OUTPUT_CAP;
+/**
+* 日志拉取的 stdout 上限：默认窗口 LOG_CAP=500 条、Show All 上限 SVN_LOG_SHOW_ALL_CAP=5000 条。
+*
+* 实测（2026-09-18，IslandSplash_BugFix `Assets`，svn 1.14.5）：`-l 500` → 2.52MB / 2.0s，
+* `-l 5000` → 18.86MB / 30.1s（约 3.8~5KB/条，含中文路径与提交信息）。故取 64MB 留约 3× 余量，
+* `-g`（merged）单条更大也吃这份余量。
+* 实测教训（勿复踩）：默认 1MB 上限时收集器保留**尾部**，Assets 全量 100 条（1.19MB）
+* 恰好把最新的 52 条挤出（用户报「显示的数据不对」）。
+* @author ddj 2026年09月17号 / 2026年09月18号
+*/
+const LOG_OUTPUT_CAP = 67108864;
+/** 变更条目上限（防超大工作副本撑爆载荷）。 */
+const CHANGES_CAP = 4e3;
+/** `svn status --xml` 超时（大工作副本留足预算）。 */
+const STATUS_GRACE_MS = 12e4;
+/** 其他只读子命令（cat/info）超时。 */
+const READ_GRACE_MS = 3e4;
+/** revert/add 超时。 */
+const MUTATE_GRACE_MS = 12e4;
+/** 文本读取上限（对齐 rpc.ts READ_CAP：>8MB 拒绝整文件读取/差异）。 */
+const READ_CAP = 8388608;
+/**
+* W2-1 补丁文本输出上限（16MB）。实测教训复用（PROGRESS §六.1）：DSH stdout 收集器
+* 超限**保留尾部**——补丁被截断时头部 `Index:` 会丢失，host 以「不以 Index: 开头」
+* 标记 truncated，客户端明示「不完整」而非让用户拿半份补丁去用。
+*/
+const PATCH_OUTPUT_CAP = 16777216;
+/** W2-2 目录对比 summarize 输出上限（8MB；大目录长区间的变更条目 XML）。 */
+const SUM_OUTPUT_CAP = 8388608;
+/**
+* W2-3 远端检查超时（15s）。M3 实测：无凭据/离线时 `status -u` 会长时间挂起
+* （受限沙箱内 120s 无输出），远端检查必须短超时 + 失败降级，绝不阻塞面板。
+*/
+const REMOTE_GRACE_MS = 15e3;
+/** W2-2 summarize 服务器往返预算（大目录长区间可能较慢）。 */
+const SUM_GRACE_MS = 6e4;
+/** 工作副本根向上查找（≤10 层，命中含 .svn 的最近祖先）。 */
+const SVN_ROOT_MAX_DEPTH = 10;
+/** 默认存在性探测（node fs；异常一律按不存在）。 */
+const defaultExists = async (path) => {
+	try {
+		await stat(path);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* 从 cwd 向上查找 SVN 工作副本根（.svn 目录/文件均算，SvnHelper 同口径）。
+* `.svn` 判定与平台无关（Linux/macOS 亦为目录），无需平台参数。
+* @author ddj 2026年09月16号
+* @param cwd 起始绝对路径
+* @param exists 存在性探测（测试注入）
+* @returns 工作副本根绝对路径；未命中返回 null
+*/
+async function findSvnRoot(cwd, exists = defaultExists) {
+	let dir = cwd;
+	for (let depth = 0; dir && depth < SVN_ROOT_MAX_DEPTH; depth += 1) {
+		if (await exists(join(dir, ".svn"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+/**
+* 解析 TortoiseProc.exe（候选序：设置目录 → bin 子目录 → 默认安装目录 → PATH 逐项）。
+* @author ddj 2026年09月16号
+* @param dirSetting 设置里的 TortoiseSVN 目录（空 = 默认）
+* @param exists 存在性探测（测试注入）
+* @param platform 目标平台（非 win32 恒 null）
+* @param pathEnv PATH 环境变量（测试注入）
+* @returns TortoiseProc.exe 绝对路径；不可用返回 null
+*/
+async function findTortoiseProc(dirSetting, exists = defaultExists, platform = process.platform, pathEnv = process.env?.PATH) {
+	if (platform !== "win32") return null;
+	const dir = dirSetting && dirSetting.trim() ? dirSetting.trim() : "";
+	const candidates = [dir && join(dir, "bin", "TortoiseProc.exe"), dir && join(dir, "TortoiseProc.exe")].filter((item) => Boolean(item));
+	for (const entry of (pathEnv ?? "").split(";")) {
+		const trim = entry.trim();
+		if (trim) candidates.push(join(trim, TORTOISE_EXE));
+	}
+	for (const candidate of candidates) if (await exists(candidate)) return candidate;
+	return null;
+}
+/**
+* svn:ignore 名称合法性校验（host 权威；防换行注入 propset 值与路径穿越）。
+* 规则：去空白后非空、无换行、无路径分隔符、不以 `-` 开头（防被 svn 当选项解析）。
+* @author ddj 2026年09月23号
+* @param name 待写入的忽略名（basename / 通配模式）
+* @returns 错误文案；合法为 null
+*/
+function ignoreNameErrorOf(name) {
+	if (typeof name !== "string") return "忽略名必须是字符串";
+	const trimmed = name.trim();
+	if (!trimmed) return "忽略名不能为空";
+	if (/[\r\n]/.test(trimmed)) return "忽略名不能包含换行";
+	if (trimmed.includes("/") || trimmed.includes("\\")) return "忽略名不能包含路径分隔符";
+	if (trimmed.startsWith("-")) return "忽略名不能以 - 开头";
+	return null;
+}
+/**
+* 本插件已自研的 SVN 能力（「自研替换时间线」的推进点）。
+*
+* 每完成一个阶段就把对应能力加进来：client 会据此隐藏被覆盖的 TortoiseProc 项，
+* 避免自研项与官方同名项并列、用户误点到官方弹窗。
+* 当前：差异（P2「与基线比较」）、还原（P2 `revert -R`）、日志（P3 日志弹窗）。
+* 待补：提交（P4 完成后加入 'commit'）；追溯无自研计划（P5 另议），故不含 'blame'。
+*/
+const SVN_FEATURES = [
+	"diff",
+	"revert",
+	"log"
+];
+/** `svn status --xml` 的 `<wc-status item="...">` 合法取值（未知值一律按 modified 兜底）。 */
+const KNOWN_ITEM_STATUS = /* @__PURE__ */ new Set([
+	"normal",
+	"added",
+	"deleted",
+	"replaced",
+	"conflicted",
+	"missing",
+	"unversioned",
+	"obstructed",
+	"ignored",
+	"modified",
+	"external",
+	"incomplete"
+]);
+/** 受版本控制判据：unversioned/ignored 之外均为版本化条目。 */
+const UNVERSIONED_STATUS = /* @__PURE__ */ new Set(["unversioned", "ignored"]);
+/**
+* 归一化 XML 中的条目路径为工作区相对路径（`/` 分隔、无前导 `./`）。
+* XML 路径相对「执行 status 时的 cwd」（实测 Windows 下用 `\`），故 host 必须以
+* 工作副本根为 cwd 执行，这里只做分隔符与形态归一；`''`/`.` 表示根自身。
+* @author ddj 2026年09月16号
+* @param raw XML path 属性原文（已反转义）
 * @returns 归一化路径；根自身返回 ''
 */
 function changePathOf(raw) {
@@ -15100,6 +16046,20 @@ function safeRel(raw) {
 	return rel;
 }
 /**
+* 会话根可在 SVN 工作副本的子目录；CLI 在 wcRoot 执行时必须换算目标坐标。
+* @author ddj 2026年09月24号
+* @param cwd 当前会话目录
+* @param wcRoot SVN 工作副本根
+* @param rel 会话相对目标
+* @returns SVN 根相对目标；越界返回 null
+*/
+function svnPathOf(cwd, wcRoot, rel) {
+	if (safeRel(rel) === null) return null;
+	const wcRel = relative(wcRoot, resolve(cwd, rel || "."));
+	if (isAbsolute(wcRel) || wcRel === ".." || wcRel.startsWith("../") || wcRel.startsWith("..\\")) return null;
+	return wcRel.replace(/\\/g, "/") || ".";
+}
+/**
 * 创建 svn.* RPC handlers（缓存随装配生命周期；lsp/ai 同模式并入 buildHandlers）。
 * @author ddj 2026年09月16号
 * @param deps ctx + 设置读取面 + 可注入时钟
@@ -15111,6 +16071,8 @@ function createSvnRpc(deps) {
 	const findRoot = deps.findRoot ?? ((cwd) => findSvnRoot(cwd));
 	const findTortoise = deps.findTortoise ?? ((dir) => findTortoiseProc(dir));
 	const statusCache = /* @__PURE__ */ new Map();
+	/** 运行中更新按会话目录复用工作副本根；TTL 到期才重新扫描 .svn。 */
+	const updateRootCache = /* @__PURE__ */ new Map();
 	/** 变更清单缓存（键 = 工作副本根；TTL 短，仅合并同一轮 UI 的多处拉取）。 */
 	const changesCache = /* @__PURE__ */ new Map();
 	/** 混合通道方案收件箱（key = 工作副本根；覆盖式入箱 + TTL，见 svn.aiPlanSubmit/Pending）。 */
@@ -15118,6 +16080,7 @@ function createSvnRpc(deps) {
 	/** 工作副本根 relative-url 缓存（日志路径映射用；探测失败也缓存空串避免反复 spawn）。 */
 	const urlCache = /* @__PURE__ */ new Map();
 	let cliProbe = null;
+	const updateJobs = new SvnUpdateJobs(() => ctx.get("subprocess"), deps.platform ?? process.platform, now);
 	const subprocess = () => {
 		const sub = ctx.get("subprocess");
 		if (!sub || typeof sub.spawn !== "function") return null;
@@ -15129,24 +16092,41 @@ function createSvnRpc(deps) {
 		if (cliProbe && cliProbe.exe === exe && at - cliProbe.at < 3e5) return cliProbe.ok;
 		let ok = false;
 		const spawn = subprocess();
-		if (spawn) try {
-			const outcome = await spawn({
-				argv: [
-					exe,
-					"--version",
-					"--quiet"
-				],
-				cwd: tmpdir(),
-				stdio: {
-					stdout: "inherit",
-					stderr: "inherit",
-					stdin: "ignore"
-				},
-				graceMs: CLI_GRACE_MS
-			}).done;
-			ok = (outcome?.exitCode ?? outcome?.code) === 0;
-		} catch {
-			ok = false;
+		if (spawn) {
+			const controller = new AbortController();
+			const deadline = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("SVN CLI 探测超时")), CLI_GRACE_MS);
+			deadline.unref?.();
+			try {
+				const handle = spawn({
+					argv: [
+						exe,
+						"--version",
+						"--quiet"
+					],
+					cwd: tmpdir(),
+					stdio: {
+						stdout: "inherit",
+						stderr: "inherit",
+						stdin: "ignore"
+					},
+					graceMs: CLI_GRACE_MS,
+					signal: controller.signal
+				});
+				const expired = new Promise((_, reject) => {
+					controller.signal.addEventListener("abort", () => {
+						try {
+							handle.terminate?.();
+						} catch {}
+						reject(controller.signal.reason);
+					}, { once: true });
+				});
+				const outcome = await Promise.race([handle.done, expired]);
+				ok = (outcome?.exitCode ?? outcome?.code) === 0;
+			} catch {
+				ok = false;
+			} finally {
+				clearTimeout(deadline);
+			}
 		}
 		cliProbe = {
 			at,
@@ -15181,6 +16161,43 @@ function createSvnRpc(deps) {
 		return payload;
 	};
 	/**
+	* 验证更新请求属于当前会话的工作副本；取消/轮询不依赖 CLI 仍可用。
+	* @author ddj 2026年09月24号
+	* @param sessionId 当前会话 id
+	* @param needCli 仅真正启动更新时才探测 SVN 客户端
+	* @returns 已校验的目录和状态，或错误
+	*/
+	const updateScope = async (sessionId, needCli = false) => {
+		const sc = await requireSvnSession(ctx, sessionId);
+		if ("err" in sc) return { err: sc.err };
+		if (!needCli) {
+			const cached = updateRootCache.get(sc.cwd);
+			const root = cached && now() - cached.at < 6e4 ? cached.root : await findRoot(sc.cwd);
+			if (root && (!cached || now() - cached.at >= 6e4)) updateRootCache.set(sc.cwd, {
+				at: now(),
+				root
+			});
+			return root ? {
+				cwd: sc.cwd,
+				root,
+				exe: "",
+				cli: false
+			} : { err: "当前工作区不受 SVN 管理" };
+		}
+		const status = await statusOf(sc.cwd);
+		if (!status.managed || !status.wcRoot) return { err: "当前工作区不受 SVN 管理" };
+		updateRootCache.set(sc.cwd, {
+			at: now(),
+			root: status.wcRoot
+		});
+		return {
+			cwd: sc.cwd,
+			root: status.wcRoot,
+			exe: status.svnPath,
+			cli: status.svnCli
+		};
+	};
+	/**
 	* 运行 svn CLI（管道收集；spawn 级失败回退 inherit，输出降级为空）。
 	* @author ddj 2026年08月26号 / 2026年09月17号
 	* @param cwd 运行目录
@@ -15601,979 +16618,1080 @@ function createSvnRpc(deps) {
 			output: [...notes, ...failures].join("\n")
 		};
 	};
-	return { handlers: {
-		"svn.status": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			return {
-				ok: true,
-				...await statusOf(sc.cwd, args.force === true)
-			};
-		},
-		"svn.changes": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const result = await changesOf(status.wcRoot, args.force === true);
+	return {
+		handlers: {
+			"svn.status": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
 				return {
 					ok: true,
-					wcRoot: status.wcRoot,
-					...result
+					...await statusOf(sc.cwd, args.force === true)
+				};
+			},
+			"svn.changes": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				try {
+					const result = await changesOf(status.wcRoot, args.force === true);
+					return {
+						ok: true,
+						wcRoot: status.wcRoot,
+						...result
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "读取变更失败：" + String(error)
+					};
+				}
+			},
+			"svn.diffBase": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const rel = safeRel(args.path);
+				if (rel === null || rel === "") return {
+					ok: false,
+					error: "路径不合法"
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				const fs = ctx.get("fs");
+				if (!fs?.resolve || !fs?.stat || !fs?.readText) return {
+					ok: false,
+					error: "缺少 fs"
+				};
+				try {
+					const target = await fs.resolve(rel, { cwd: sc.cwd });
+					const info = await fs.stat(target);
+					if (!info || info.type !== "file") return {
+						ok: false,
+						error: "文件不存在"
+					};
+					if ((info.size ?? 0) > READ_CAP) return {
+						ok: false,
+						error: "文件过大（>8MB），不支持基线差异"
+					};
+					const working = await fs.readText(target);
+					const outcome = await runSvn(status.wcRoot, [
+						"cat",
+						"-r",
+						"BASE",
+						"--",
+						rel
+					], READ_GRACE_MS);
+					if (outcome.code !== 0) {
+						const text = (outcome.stderr || outcome.stdout).trim();
+						return {
+							ok: true,
+							base: null,
+							working,
+							reason: /pristine|E200009/i.test(text) ? "no-pristine" : "cat-failed",
+							error: tailOfText(text),
+							...guardSides(null, working)
+						};
+					}
+					return {
+						ok: true,
+						base: outcome.stdout,
+						working,
+						...guardSides(outcome.stdout, working)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "读取基线失败：" + String(error)
+					};
+				}
+			},
+			"svn.revert": async (args) => {
+				return mutate("还原", ["revert", "-R"], args.sessionId, args.paths);
+			},
+			"svn.add": async (args) => {
+				return mutate("加入版本控制", ["add"], args.sessionId, args.paths);
+			},
+			/**
+			* 分区（changelist）批量操作：关联或解除工作副本条目的 changelist 登记。
+			* 复用 mutate 全套护栏（路径白名单 / BATCH_PATHS_CAP / 超时 / 变更缓存作废）；
+			* 分区名 host 权威校验（`-` 开头会被 svn 当成选项解析），remove 分支不需要名字。
+			* @author ddj 2026年09月23号
+			* @param args.paths 工作区相对路径列表
+			* @param args.name 目标分区名（remove 时忽略）
+			* @param args.remove true = 移出分区（`changelist --remove`）
+			* @returns 批量动作结果
+			*/
+			"svn.changelist": async (args) => {
+				if (args.remove !== true) {
+					const nameError = svnChangelistNameErrorOf(String(args.name ?? ""));
+					if (nameError) return {
+						ok: false,
+						error: nameError
+					};
+				}
+				return mutate(args.remove === true ? "移出分区" : "分区", args.remove === true ? ["changelist", "--remove"] : ["changelist", String(args.name ?? "").trim()], args.sessionId, args.paths);
+			},
+			"svn.log": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const rel = safeRel(args.path);
+				if (rel === null) return {
+					ok: false,
+					error: "路径不合法"
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				const svnTarget = svnPathOf(sc.cwd, status.wcRoot, rel);
+				if (svnTarget === null) return {
+					ok: false,
+					error: "日志路径不在 SVN 工作副本内"
+				};
+				try {
+					return {
+						ok: true,
+						...await logOf(status.wcRoot, svnTarget === "." ? "" : svnTarget, args.limit ?? 100, {
+							stopOnCopy: args.stopOnCopy === true,
+							showMerged: args.showMerged === true,
+							range: args.startRev && args.endRev ? {
+								start: Math.floor(args.startRev),
+								end: Math.floor(args.endRev)
+							} : null
+						}, SVN_LOG_SHOW_ALL_CAP),
+						target: rel
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "读取日志失败：" + String(error)
+					};
+				}
+			},
+			"svn.diffRev": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
 				};
-			} catch (error) {
-				return {
+				const rel = safeRel(args.path);
+				if (rel === null || rel === "") return {
 					ok: false,
-					error: "读取变更失败：" + String(error)
+					error: "路径不合法"
 				};
-			}
-		},
-		"svn.diffBase": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null || rel === "") return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			const fs = ctx.get("fs");
-			if (!fs?.resolve || !fs?.stat || !fs?.readText) return {
-				ok: false,
-				error: "缺少 fs"
-			};
-			try {
-				const target = await fs.resolve(rel, { cwd: sc.cwd });
-				const info = await fs.stat(target);
-				if (!info || info.type !== "file") return {
+				const revision = Number(args.revision);
+				if (!Number.isFinite(revision) || revision < 1) return {
 					ok: false,
-					error: "文件不存在"
+					error: "版本号不合法"
 				};
-				if ((info.size ?? 0) > READ_CAP) return {
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
 					ok: false,
-					error: "文件过大（>8MB），不支持基线差异"
+					error: "当前工作区不受 SVN 管理"
 				};
-				const working = await fs.readText(target);
-				const outcome = await runSvn(status.wcRoot, [
-					"cat",
-					"-r",
-					"BASE",
-					"--",
-					rel
-				], READ_GRACE_MS);
-				if (outcome.code !== 0) {
-					const text = (outcome.stderr || outcome.stdout).trim();
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				try {
+					const result = await diffRevSides(status.wcRoot, rel, Math.floor(revision));
 					return {
 						ok: true,
-						base: null,
-						working,
-						reason: /pristine|E200009/i.test(text) ? "no-pristine" : "cat-failed",
-						error: tailOfText(text),
+						...result,
+						...guardSides(result.left, result.right)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "读取版本差异失败：" + String(error)
+					};
+				}
+			},
+			"svn.diffPair": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const rel = safeRel(args.path);
+				if (rel === null || rel === "") return {
+					ok: false,
+					error: "路径不合法"
+				};
+				const revA = Number(args.revA);
+				const revB = Number(args.revB);
+				if (!Number.isFinite(revA) || revA < 1 || !Number.isFinite(revB) || revB < 1) return {
+					ok: false,
+					error: "版本号不合法"
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				try {
+					const result = await pairSides(status.wcRoot, rel, Math.floor(revA), Math.floor(revB));
+					return {
+						ok: true,
+						...result,
+						...guardSides(result.left, result.right)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "读取版本差异失败：" + String(error)
+					};
+				}
+			},
+			"svn.diffWorking": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const rel = safeRel(args.path);
+				if (rel === null || rel === "") return {
+					ok: false,
+					error: "路径不合法"
+				};
+				const revision = Number(args.revision);
+				if (!Number.isFinite(revision) || revision < 1) return {
+					ok: false,
+					error: "版本号不合法"
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				const svnRel = svnPathOf(sc.cwd, status.wcRoot, rel);
+				if (!svnRel) return {
+					ok: false,
+					error: "比较路径不在 SVN 工作副本内"
+				};
+				const fs = ctx.get("fs");
+				if (!fs?.resolve || !fs?.stat || !fs?.readText) return {
+					ok: false,
+					error: "缺少 fs"
+				};
+				try {
+					const resolved = await fs.resolve(rel, { cwd: sc.cwd });
+					const info = await fs.stat(resolved);
+					if (!info || info.type !== "file") return {
+						ok: false,
+						error: "文件不存在"
+					};
+					if ((info.size ?? 0) > READ_CAP) return {
+						ok: false,
+						error: "文件过大（>8MB），不支持与工作副本比较"
+					};
+					const working = await fs.readText(resolved);
+					const leftOutcome = await runSvn(status.wcRoot, [
+						"cat",
+						"-r",
+						String(Math.floor(revision)),
+						"--",
+						svnRel
+					], READ_GRACE_MS);
+					if (leftOutcome.code !== 0) return {
+						ok: true,
+						left: null,
+						right: working,
+						reason: "not-exist",
+						error: tailOfText((leftOutcome.stderr || leftOutcome.stdout).trim()),
 						...guardSides(null, working)
 					};
+					return {
+						ok: true,
+						left: leftOutcome.stdout,
+						right: working,
+						...guardSides(leftOutcome.stdout, working)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "读取工作副本差异失败：" + String(error)
+					};
 				}
-				return {
-					ok: true,
-					base: outcome.stdout,
-					working,
-					...guardSides(outcome.stdout, working)
+			},
+			"svn.patchText": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
 				};
-			} catch (error) {
-				return {
+				const rel = safeRel(args.path);
+				if (rel === null || rel === "") return {
 					ok: false,
-					error: "读取基线失败：" + String(error)
+					error: "路径不合法"
 				};
-			}
-		},
-		"svn.revert": async (args) => {
-			return mutate("还原", ["revert", "-R"], args.sessionId, args.paths);
-		},
-		"svn.add": async (args) => {
-			return mutate("加入版本控制", ["add"], args.sessionId, args.paths);
-		},
-		/**
-		* 分区（changelist）批量操作：关联或解除工作副本条目的 changelist 登记。
-		* 复用 mutate 全套护栏（路径白名单 / BATCH_PATHS_CAP / 超时 / 变更缓存作废）；
-		* 分区名 host 权威校验（`-` 开头会被 svn 当成选项解析），remove 分支不需要名字。
-		* @author ddj 2026年09月23号
-		* @param args.paths 工作区相对路径列表
-		* @param args.name 目标分区名（remove 时忽略）
-		* @param args.remove true = 移出分区（`changelist --remove`）
-		* @returns 批量动作结果
-		*/
-		"svn.changelist": async (args) => {
-			if (args.remove !== true) {
-				const nameError = svnChangelistNameErrorOf(String(args.name ?? ""));
-				if (nameError) return {
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
 					ok: false,
-					error: nameError
+					error: "当前工作区不受 SVN 管理"
 				};
-			}
-			return mutate(args.remove === true ? "移出分区" : "分区", args.remove === true ? ["changelist", "--remove"] : ["changelist", String(args.name ?? "").trim()], args.sessionId, args.paths);
-		},
-		"svn.log": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null) return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				return {
-					ok: true,
-					...await logOf(status.wcRoot, rel, args.limit ?? 100, {
-						stopOnCopy: args.stopOnCopy === true,
-						showMerged: args.showMerged === true,
-						range: args.startRev && args.endRev ? {
-							start: Math.floor(args.startRev),
-							end: Math.floor(args.endRev)
-						} : null
-					}, SVN_LOG_SHOW_ALL_CAP),
-					target: rel
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
 				};
-			} catch (error) {
-				return {
+				try {
+					const ext = patchExtOf({
+						whitespace: args.whitespace,
+						ignoreEol: args.ignoreEol === true,
+						unified: args.unified
+					});
+					const argv = [
+						"diff",
+						...ext ? ["-x", ext] : [],
+						"--",
+						rel
+					];
+					const outcome = await runSvn(status.wcRoot, argv, READ_GRACE_MS, PATCH_OUTPUT_CAP);
+					if (outcome.code !== 0) return {
+						ok: false,
+						error: "生成补丁失败：" + tailOfText([outcome.stderr, outcome.stdout].filter(Boolean).join("\n"))
+					};
+					const text = outcome.stdout;
+					const head = text.slice(0, 200);
+					return {
+						ok: true,
+						text,
+						truncated: !head.startsWith("Index:") && !head.startsWith("Property changes on:"),
+						binary: text.includes("Cannot display:")
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "生成补丁失败：" + String(error)
+					};
+				}
+			},
+			"svn.diffSum": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
 					ok: false,
-					error: "读取日志失败：" + String(error)
+					error: sc.err
 				};
-			}
-		},
-		"svn.diffRev": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null || rel === "") return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const revision = Number(args.revision);
-			if (!Number.isFinite(revision) || revision < 1) return {
-				ok: false,
-				error: "版本号不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const result = await diffRevSides(status.wcRoot, rel, Math.floor(revision));
-				return {
-					ok: true,
-					...result,
-					...guardSides(result.left, result.right)
+				const rel = safeRel(args.path);
+				if (rel === null) return {
+					ok: false,
+					error: "路径不合法"
 				};
-			} catch (error) {
-				return {
+				const revA = Number(args.revA);
+				const revB = Number(args.revB);
+				if (!Number.isFinite(revA) || revA < 1 || !Number.isFinite(revB) || revB < 1) return {
 					ok: false,
-					error: "读取版本差异失败：" + String(error)
+					error: "版本号不合法"
 				};
-			}
-		},
-		"svn.diffPair": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null || rel === "") return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const revA = Number(args.revA);
-			const revB = Number(args.revB);
-			if (!Number.isFinite(revA) || revA < 1 || !Number.isFinite(revB) || revB < 1) return {
-				ok: false,
-				error: "版本号不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const result = await pairSides(status.wcRoot, rel, Math.floor(revA), Math.floor(revB));
-				return {
-					ok: true,
-					...result,
-					...guardSides(result.left, result.right)
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				try {
+					const argv = [
+						"diff",
+						"--summarize",
+						"--xml",
+						"-r",
+						String(Math.floor(revA)) + ":" + String(Math.floor(revB))
+					];
+					if (rel) argv.push("--", rel);
+					const outcome = await runSvn(status.wcRoot, argv, SUM_GRACE_MS, SUM_OUTPUT_CAP);
+					if (outcome.code !== 0) return {
+						ok: false,
+						error: "目录对比失败：" + tailOfText([outcome.stderr, outcome.stdout].filter(Boolean).join("\n"))
+					};
+					return {
+						ok: true,
+						...parseSummarizeXml(outcome.stdout, status.wcRoot)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "目录对比失败：" + String(error)
+					};
+				}
+			},
+			"svn.remoteStatus": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const rel = safeRel(args.path);
+				if (rel === null) return {
+					ok: false,
+					error: "路径不合法"
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				try {
+					const argv = [
+						"status",
+						"-u",
+						"--xml"
+					];
+					if (rel) argv.push("--", rel);
+					const outcome = await runSvn(status.wcRoot, argv, REMOTE_GRACE_MS, SUM_OUTPUT_CAP);
+					if (outcome.code !== 0) return {
+						ok: false,
+						error: "远端检查失败：" + tailOfText([outcome.stderr, outcome.stdout].filter(Boolean).join("\n"))
+					};
+					return {
+						ok: true,
+						...parseRemoteStatusXml(outcome.stdout, status.wcRoot)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "远端检查失败：" + String(error)
+					};
+				}
+			},
+			"svn.conflictArtifacts": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const rel = safeRel(args.path);
+				if (rel === null || rel === "") return {
+					ok: false,
+					error: "路径不合法"
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				try {
+					return {
+						ok: true,
+						artifacts: await conflictArtifactsOf(status.wcRoot, rel)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "扫描冲突副本失败：" + String(error)
+					};
+				}
+			},
+			"svn.diffLocalPair": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
 				};
-			} catch (error) {
-				return {
+				const left = safeRel(args.left);
+				const right = safeRel(args.right);
+				if (!left || !right) return {
 					ok: false,
-					error: "读取版本差异失败：" + String(error)
+					error: "路径不合法（需工作副本内相对路径）"
 				};
-			}
-		},
-		"svn.diffWorking": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null || rel === "") return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const revision = Number(args.revision);
-			if (!Number.isFinite(revision) || revision < 1) return {
-				ok: false,
-				error: "版本号不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			const fs = ctx.get("fs");
-			if (!fs?.resolve || !fs?.stat || !fs?.readText) return {
-				ok: false,
-				error: "缺少 fs"
-			};
-			try {
-				const resolved = await fs.resolve(rel, { cwd: sc.cwd });
-				const info = await fs.stat(resolved);
-				if (!info || info.type !== "file") return {
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
 					ok: false,
-					error: "文件不存在"
+					error: "当前工作区不受 SVN 管理"
 				};
-				if ((info.size ?? 0) > READ_CAP) return {
+				const fs = ctx.get("fs");
+				if (!fs?.resolve || !fs?.stat || !fs?.readText) return {
 					ok: false,
-					error: "文件过大（>8MB），不支持与工作副本比较"
+					error: "缺少 fs"
 				};
-				const working = await fs.readText(resolved);
-				const leftOutcome = await runSvn(status.wcRoot, [
-					"cat",
-					"-r",
-					String(Math.floor(revision)),
-					"--",
-					rel
-				], READ_GRACE_MS);
-				if (leftOutcome.code !== 0) return {
-					ok: true,
-					left: null,
-					right: working,
-					reason: "not-exist",
-					error: tailOfText((leftOutcome.stderr || leftOutcome.stdout).trim()),
-					...guardSides(null, working)
+				try {
+					const sides = [];
+					for (const rel of [left, right]) {
+						const resolved = await fs.resolve(rel, { cwd: sc.cwd });
+						const info = await fs.stat(resolved);
+						if (!info || info.type !== "file") return {
+							ok: false,
+							error: "文件不存在：" + rel
+						};
+						if ((info.size ?? 0) > READ_CAP) return {
+							ok: false,
+							error: "文件过大（>8MB）：" + rel
+						};
+						sides.push(await fs.readText(resolved));
+					}
+					return {
+						ok: true,
+						left: sides[0],
+						right: sides[1],
+						...guardSides(sides[0], sides[1])
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "读取冲突副本失败：" + String(error)
+					};
+				}
+			},
+			"svn.fileSizes": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
 				};
-				return {
+				const list = Array.isArray(args.paths) ? args.paths.slice(0, 200) : [];
+				if (!list.length) return {
 					ok: true,
-					left: leftOutcome.stdout,
-					right: working,
-					...guardSides(leftOutcome.stdout, working)
+					sizes: []
 				};
-			} catch (error) {
-				return {
+				const fs = ctx.get("fs");
+				if (!fs?.resolve || !fs?.stat) return {
 					ok: false,
-					error: "读取工作副本差异失败：" + String(error)
+					error: "缺少 fs"
 				};
-			}
-		},
-		"svn.patchText": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null || rel === "") return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const ext = patchExtOf({
-					whitespace: args.whitespace,
-					ignoreEol: args.ignoreEol === true,
-					unified: args.unified
-				});
-				const argv = [
-					"diff",
-					...ext ? ["-x", ext] : [],
-					"--",
-					rel
-				];
-				const outcome = await runSvn(status.wcRoot, argv, READ_GRACE_MS, PATCH_OUTPUT_CAP);
-				if (outcome.code !== 0) return {
-					ok: false,
-					error: "生成补丁失败：" + tailOfText([outcome.stderr, outcome.stdout].filter(Boolean).join("\n"))
+				const sizeOne = async (raw) => {
+					const rel = safeRel(raw);
+					if (rel === null || rel === "") return {
+						path: String(raw ?? ""),
+						size: null
+					};
+					try {
+						const resolved = await fs.resolve(rel, { cwd: sc.cwd });
+						const info = await fs.stat(resolved);
+						return {
+							path: rel,
+							size: info && info.type === "file" ? info.size ?? null : null
+						};
+					} catch {
+						return {
+							path: rel,
+							size: null
+						};
+					}
 				};
-				const text = outcome.stdout;
-				const head = text.slice(0, 200);
+				const sizes = [];
+				const BATCH = 16;
+				for (let start = 0; start < list.length; start += BATCH) sizes.push(...await Promise.all(list.slice(start, start + BATCH).map(sizeOne)));
 				return {
 					ok: true,
-					text,
-					truncated: !head.startsWith("Index:") && !head.startsWith("Property changes on:"),
-					binary: text.includes("Cannot display:")
+					sizes
 				};
-			} catch (error) {
-				return {
+			},
+			/**
+			* AI 智能整理分析（只读）：拉最新变更 → 附 diff 上下文（超限降级 paths-only）→
+			* LLM 流式产出 JSON → normalizeAiPlan 以真实清单白名单归一。任何失败零执行只报错。
+			* @author ddj 2026年09月23号
+			* @param args.sessionId 会话 id
+			* @returns 三段方案 + 分析元信息（条目数/是否含 diff/丢弃数/模型）
+			*/
+			"svn.aiPlan": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
 					ok: false,
-					error: "生成补丁失败：" + String(error)
+					error: sc.err
 				};
-			}
-		},
-		"svn.diffSum": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null) return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const revA = Number(args.revA);
-			const revB = Number(args.revB);
-			if (!Number.isFinite(revA) || revA < 1 || !Number.isFinite(revB) || revB < 1) return {
-				ok: false,
-				error: "版本号不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const argv = [
-					"diff",
-					"--summarize",
-					"--xml",
-					"-r",
-					String(Math.floor(revA)) + ":" + String(Math.floor(revB))
-				];
-				if (rel) argv.push("--", rel);
-				const outcome = await runSvn(status.wcRoot, argv, SUM_GRACE_MS, SUM_OUTPUT_CAP);
-				if (outcome.code !== 0) return {
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
 					ok: false,
-					error: "目录对比失败：" + tailOfText([outcome.stderr, outcome.stdout].filter(Boolean).join("\n"))
+					error: "当前工作区不受 SVN 管理"
 				};
-				return {
-					ok: true,
-					...parseSummarizeXml(outcome.stdout, status.wcRoot)
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
 				};
-			} catch (error) {
-				return {
+				try {
+					const { entries } = await changesOf(status.wcRoot, true);
+					let diffText = null;
+					try {
+						const outcome = await runSvn(status.wcRoot, [
+							"diff",
+							"-x",
+							"-U0"
+						], READ_GRACE_MS, AI_PLAN_DIFF_CAP);
+						if (outcome.code === 0 && outcome.stdout.trim() && outcome.stdout.length < 2097152) diffText = outcome.stdout;
+					} catch {}
+					const capped = entries.length > AI_PLAN_PATHS_CAP;
+					const used = capped ? entries.slice(0, AI_PLAN_PATHS_CAP) : entries;
+					const diffIncluded = diffText !== null && !capped;
+					const prompt = buildAiPrompt(used, diffIncluded ? diffText : null, capped);
+					const cfg = settings.ai ? settings.ai() : {
+						enabled: true,
+						provider: "",
+						model: "",
+						effort: ""
+					};
+					const result = await svnAiPlanOf(ctx, cfg, prompt);
+					const { plan, dropped } = normalizeAiPlan(result.raw, entries);
+					return {
+						ok: true,
+						plan,
+						entriesCount: entries.length,
+						diffIncluded,
+						dropped,
+						model: result.model
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: String(error instanceof Error ? error.message : error)
+					};
+				}
+			},
+			/**
+			* AI 智能整理执行段③：按目录合并写入 svn:ignore 属性（propget 合并，不整体覆盖）。
+			* 复用受管理/svnCli 校验与变更缓存作废语义（对齐 mutate）。
+			* @author ddj 2026年09月23号
+			* @param args.items 目录聚合写入项（dir + 该目录下新增忽略名）
+			* @returns 新增计数/摘要/原文
+			*/
+			"svn.ignore": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
 					ok: false,
-					error: "目录对比失败：" + String(error)
+					error: sc.err
 				};
-			}
-		},
-		"svn.remoteStatus": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null) return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const argv = [
-					"status",
-					"-u",
-					"--xml"
-				];
-				if (rel) argv.push("--", rel);
-				const outcome = await runSvn(status.wcRoot, argv, REMOTE_GRACE_MS, SUM_OUTPUT_CAP);
-				if (outcome.code !== 0) return {
+				const items = Array.isArray(args.items) ? args.items : [];
+				if (!items.length) return {
 					ok: false,
-					error: "远端检查失败：" + tailOfText([outcome.stderr, outcome.stdout].filter(Boolean).join("\n"))
+					error: "未选择任何路径"
 				};
-				return {
-					ok: true,
-					...parseRemoteStatusXml(outcome.stdout, status.wcRoot)
+				const clean = [];
+				let total = 0;
+				for (const item of items) {
+					const rel = safeRel(item?.dir);
+					if (rel === null) return {
+						ok: false,
+						error: "路径不合法"
+					};
+					const names = Array.isArray(item?.names) ? item.names : [];
+					if (!names.length) return {
+						ok: false,
+						error: "忽略名列表为空"
+					};
+					const checked = [];
+					for (const name of names) {
+						const nameError = ignoreNameErrorOf(name);
+						if (nameError) return {
+							ok: false,
+							error: nameError
+						};
+						checked.push(String(name).trim());
+					}
+					total += checked.length;
+					if (total > 64) return {
+						ok: false,
+						error: "一次最多处理 64 个路径"
+					};
+					clean.push({
+						dir: rel === "" ? "." : rel,
+						names: checked
+					});
+				}
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
 				};
-			} catch (error) {
-				return {
+				if (!status.svnCli) return {
 					ok: false,
-					error: "远端检查失败：" + String(error)
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
 				};
-			}
-		},
-		"svn.conflictArtifacts": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null || rel === "") return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			try {
-				return {
-					ok: true,
-					artifacts: await conflictArtifactsOf(status.wcRoot, rel)
+				try {
+					const result = await ignoreApplyOf(status.wcRoot, clean);
+					changesCache.delete(status.wcRoot);
+					if (!result.ok) return {
+						ok: false,
+						error: result.summary + (result.output ? "\n" + tailOfText(result.output) : "")
+					};
+					return {
+						ok: true,
+						count: result.count,
+						summary: result.summary,
+						output: result.output
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "svn:ignore 写入失败：" + String(error)
+					};
+				}
+			},
+			/**
+			* 混合通道投递口（01-hybrid-deep-analysis）：会话 agent 深度分析后 POST 方案入收件箱。
+			* 只读 + 内存态：经 normalizeAiPlan 以最新变更清单白名单归一（幻觉路径丢弃计数），
+			* 零接受拒收（防 agent 空转误报成功）；覆盖式入箱（新投递顶掉旧件）。
+			* @author ddj 2026年09月23号
+			* @param args.plan agent 产出的方案 JSON（形状宽松，归一兜底）
+			* @returns 接受路径数与丢弃数
+			*/
+			"svn.aiPlanSubmit": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
 				};
-			} catch (error) {
-				return {
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
 					ok: false,
-					error: "扫描冲突副本失败：" + String(error)
+					error: "当前工作区不受 SVN 管理"
 				};
-			}
-		},
-		"svn.diffLocalPair": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const left = safeRel(args.left);
-			const right = safeRel(args.right);
-			if (!left || !right) return {
-				ok: false,
-				error: "路径不合法（需工作副本内相对路径）"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			const fs = ctx.get("fs");
-			if (!fs?.resolve || !fs?.stat || !fs?.readText) return {
-				ok: false,
-				error: "缺少 fs"
-			};
-			try {
-				const sides = [];
-				for (const rel of [left, right]) {
-					const resolved = await fs.resolve(rel, { cwd: sc.cwd });
-					const info = await fs.stat(resolved);
-					if (!info || info.type !== "file") return {
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				try {
+					const { entries } = await changesOf(status.wcRoot, true);
+					const { plan, dropped } = normalizeAiPlan(args.plan, entries);
+					const accepted = plan.reverts.length + plan.ignores.length + plan.groups.reduce((n, group) => n + group.paths.length, 0);
+					if (!accepted) return {
 						ok: false,
-						error: "文件不存在：" + rel
+						error: "方案为空：无任何路径通过白名单校验（丢弃 " + dropped + " 项）"
 					};
-					if ((info.size ?? 0) > READ_CAP) return {
+					planInbox.set(status.wcRoot, {
+						plan,
+						dropped,
+						at: now()
+					});
+					return {
+						ok: true,
+						accepted,
+						dropped
+					};
+				} catch (error) {
+					return {
 						ok: false,
-						error: "文件过大（>8MB）：" + rel
+						error: "方案投递失败：" + String(error)
 					};
-					sides.push(await fs.readText(resolved));
 				}
-				return {
+			},
+			/**
+			* 混合通道取件口：面板轮询取收件箱方案。
+			* since = 注入时刻——早于它的旧投递不算新件（防上一轮残留被误认为本轮结果）；
+			* TTL 过期返回 plan:null。非破坏性读取（重复取到同一份由 client 侧取件即停消化）。
+			* @author ddj 2026年09月23号
+			* @param args.since 注入时刻时间戳（缺省 0 = 取任意件）
+			* @returns 方案与元信息（无新件 plan 为 null）
+			*/
+			"svn.aiPlanPending": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				const hit = planInbox.get(status.wcRoot);
+				const since = Number(args.since) || 0;
+				if (!hit || hit.at < since || now() - hit.at > 18e5) return {
 					ok: true,
-					left: sides[0],
-					right: sides[1],
-					...guardSides(sides[0], sides[1])
+					plan: null,
+					dropped: 0,
+					at: 0
 				};
-			} catch (error) {
 				return {
+					ok: true,
+					plan: hit.plan,
+					dropped: hit.dropped,
+					at: hit.at
+				};
+			},
+			"svn.wcRev": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
 					ok: false,
-					error: "读取冲突副本失败：" + String(error)
+					error: sc.err
 				};
-			}
-		},
-		"svn.fileSizes": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const list = Array.isArray(args.paths) ? args.paths.slice(0, 200) : [];
-			if (!list.length) return {
-				ok: true,
-				sizes: []
-			};
-			const fs = ctx.get("fs");
-			if (!fs?.resolve || !fs?.stat) return {
-				ok: false,
-				error: "缺少 fs"
-			};
-			const sizeOne = async (raw) => {
-				const rel = safeRel(raw);
+				const rel = safeRel(args.path);
 				if (rel === null || rel === "") return {
-					path: String(raw ?? ""),
-					size: null
+					ok: true,
+					revision: null
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				const outcome = await runSvn(status.wcRoot, [
+					"info",
+					"--xml",
+					"--",
+					rel
+				], READ_GRACE_MS);
+				if (outcome.code !== 0) return {
+					ok: true,
+					revision: null
+				};
+				return {
+					ok: true,
+					revision: parseSvnInfoRevision(outcome.stdout)
+				};
+			},
+			"svn.cleanup": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
+					ok: false,
+					error: sc.err
+				};
+				const status = await statusOf(sc.cwd);
+				if (!status.managed || !status.wcRoot) return {
+					ok: false,
+					error: "当前工作区不受 SVN 管理"
+				};
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
 				};
+				const argv = ["cleanup"];
+				if (args.removeUnversioned === true) argv.push("--remove-unversioned");
+				if (args.removeIgnored === true) argv.push("--remove-ignored");
 				try {
-					const resolved = await fs.resolve(rel, { cwd: sc.cwd });
-					const info = await fs.stat(resolved);
+					const outcome = await runSvn(status.wcRoot, argv, MUTATE_GRACE_MS);
+					const result = batchResultOf(outcome.stdout, outcome.stderr, outcome.code, "清理");
+					if (outcome.code !== 0) return {
+						ok: false,
+						error: "清理失败：" + tailOfText(result.output)
+					};
+					changesCache.delete(status.wcRoot);
 					return {
-						path: rel,
-						size: info && info.type === "file" ? info.size ?? null : null
+						ok: true,
+						...result
 					};
-				} catch {
+				} catch (error) {
 					return {
-						path: rel,
-						size: null
+						ok: false,
+						error: "清理失败：" + String(error)
 					};
 				}
-			};
-			const sizes = [];
-			const BATCH = 16;
-			for (let start = 0; start < list.length; start += BATCH) sizes.push(...await Promise.all(list.slice(start, start + BATCH).map(sizeOne)));
-			return {
-				ok: true,
-				sizes
-			};
-		},
-		/**
-		* AI 智能整理分析（只读）：拉最新变更 → 附 diff 上下文（超限降级 paths-only）→
-		* LLM 流式产出 JSON → normalizeAiPlan 以真实清单白名单归一。任何失败零执行只报错。
-		* @author ddj 2026年09月23号
-		* @param args.sessionId 会话 id
-		* @returns 三段方案 + 分析元信息（条目数/是否含 diff/丢弃数/模型）
-		*/
-		"svn.aiPlan": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const { entries } = await changesOf(status.wcRoot, true);
-				let diffText = null;
-				try {
-					const outcome = await runSvn(status.wcRoot, [
-						"diff",
-						"-x",
-						"-U0"
-					], READ_GRACE_MS, AI_PLAN_DIFF_CAP);
-					if (outcome.code === 0 && outcome.stdout.trim() && outcome.stdout.length < 2097152) diffText = outcome.stdout;
-				} catch {}
-				const capped = entries.length > AI_PLAN_PATHS_CAP;
-				const used = capped ? entries.slice(0, AI_PLAN_PATHS_CAP) : entries;
-				const diffIncluded = diffText !== null && !capped;
-				const prompt = buildAiPrompt(used, diffIncluded ? diffText : null, capped);
-				const cfg = settings.ai ? settings.ai() : {
-					enabled: true,
-					provider: "",
-					model: "",
-					effort: ""
-				};
-				const result = await svnAiPlanOf(ctx, cfg, prompt);
-				const { plan, dropped } = normalizeAiPlan(result.raw, entries);
-				return {
-					ok: true,
-					plan,
-					entriesCount: entries.length,
-					diffIncluded,
-					dropped,
-					model: result.model
-				};
-			} catch (error) {
-				return {
+			},
+			"svn.update": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
 					ok: false,
-					error: String(error instanceof Error ? error.message : error)
+					error: sc.err
 				};
-			}
-		},
-		/**
-		* AI 智能整理执行段③：按目录合并写入 svn:ignore 属性（propget 合并，不整体覆盖）。
-		* 复用受管理/svnCli 校验与变更缓存作废语义（对齐 mutate）。
-		* @author ddj 2026年09月23号
-		* @param args.items 目录聚合写入项（dir + 该目录下新增忽略名）
-		* @returns 新增计数/摘要/原文
-		*/
-		"svn.ignore": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const items = Array.isArray(args.items) ? args.items : [];
-			if (!items.length) return {
-				ok: false,
-				error: "未选择任何路径"
-			};
-			const clean = [];
-			let total = 0;
-			for (const item of items) {
-				const rel = safeRel(item?.dir);
+				const rel = safeRel(args.path);
 				if (rel === null) return {
 					ok: false,
 					error: "路径不合法"
 				};
-				const names = Array.isArray(item?.names) ? item.names : [];
-				if (!names.length) return {
+				const status = await statusOf(sc.cwd);
+				if (!status.managed) return {
 					ok: false,
-					error: "忽略名列表为空"
+					error: "当前工作区不受 SVN 管理"
 				};
-				const checked = [];
-				for (const name of names) {
-					const nameError = ignoreNameErrorOf(name);
-					if (nameError) return {
+				if (!status.svnCli) return {
+					ok: false,
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
+				};
+				try {
+					const outcome = await runSvn(sc.cwd, [
+						"update",
+						"--",
+						rel || "."
+					], UPDATE_GRACE_MS);
+					const result = updateResultOf(outcome.stdout, outcome.stderr, outcome.code);
+					if (outcome.code !== 0) return {
 						ok: false,
-						error: nameError
+						error: "更新失败：" + tailOfText(result.output)
+					};
+					return {
+						ok: true,
+						...result
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "更新失败：" + String(error)
 					};
-					checked.push(String(name).trim());
 				}
-				total += checked.length;
-				if (total > 64) return {
+			},
+			"svn.updateStart": async (args) => {
+				const scope = await updateScope(args.sessionId, true);
+				if ("err" in scope) return {
 					ok: false,
-					error: "一次最多处理 64 个路径"
+					error: scope.err
 				};
-				clean.push({
-					dir: rel === "" ? "." : rel,
-					names: checked
-				});
-			}
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const result = await ignoreApplyOf(status.wcRoot, clean);
-				changesCache.delete(status.wcRoot);
-				if (!result.ok) return {
+				if (!scope.cli) return {
 					ok: false,
-					error: result.summary + (result.output ? "\n" + tailOfText(result.output) : "")
-				};
-				return {
-					ok: true,
-					count: result.count,
-					summary: result.summary,
-					output: result.output
+					error: "svn 命令不可用（可在设置页配置 svn 路径）"
 				};
-			} catch (error) {
-				return {
+				const rel = safeRel(args.path);
+				if (rel === null) return {
 					ok: false,
-					error: "svn:ignore 写入失败：" + String(error)
+					error: "路径不合法"
 				};
-			}
-		},
-		/**
-		* 混合通道投递口（01-hybrid-deep-analysis）：会话 agent 深度分析后 POST 方案入收件箱。
-		* 只读 + 内存态：经 normalizeAiPlan 以最新变更清单白名单归一（幻觉路径丢弃计数），
-		* 零接受拒收（防 agent 空转误报成功）；覆盖式入箱（新投递顶掉旧件）。
-		* @author ddj 2026年09月23号
-		* @param args.plan agent 产出的方案 JSON（形状宽松，归一兜底）
-		* @returns 接受路径数与丢弃数
-		*/
-		"svn.aiPlanSubmit": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const { entries } = await changesOf(status.wcRoot, true);
-				const { plan, dropped } = normalizeAiPlan(args.plan, entries);
-				const accepted = plan.reverts.length + plan.ignores.length + plan.groups.reduce((n, group) => n + group.paths.length, 0);
-				if (!accepted) return {
+				try {
+					const fs = ctx.get("fs");
+					const cwd = fs?.resolve && fs?.processPath ? fs.processPath(await fs.resolve(scope.cwd, {})) : scope.cwd;
+					return {
+						ok: true,
+						...updateJobs.start({
+							cwd,
+							root: scope.root,
+							path: rel,
+							exe: scope.exe
+						})
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "启动 SVN 更新失败：" + String(error)
+					};
+				}
+			},
+			"svn.updatePoll": async (args) => {
+				const scope = await updateScope(args.sessionId);
+				if ("err" in scope) return {
 					ok: false,
-					error: "方案为空：无任何路径通过白名单校验（丢弃 " + dropped + " 项）"
-				};
-				planInbox.set(status.wcRoot, {
-					plan,
-					dropped,
-					at: now()
-				});
-				return {
-					ok: true,
-					accepted,
-					dropped
+					error: scope.err
 				};
-			} catch (error) {
-				return {
+				try {
+					return {
+						ok: true,
+						...updateJobs.poll(scope.root, args.jobId, args.since)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: String(error)
+					};
+				}
+			},
+			"svn.updateCancel": async (args) => {
+				const scope = await updateScope(args.sessionId);
+				if ("err" in scope) return {
 					ok: false,
-					error: "方案投递失败：" + String(error)
+					error: scope.err
 				};
-			}
-		},
-		/**
-		* 混合通道取件口：面板轮询取收件箱方案。
-		* since = 注入时刻——早于它的旧投递不算新件（防上一轮残留被误认为本轮结果）；
-		* TTL 过期返回 plan:null。非破坏性读取（重复取到同一份由 client 侧取件即停消化）。
-		* @author ddj 2026年09月23号
-		* @param args.since 注入时刻时间戳（缺省 0 = 取任意件）
-		* @returns 方案与元信息（无新件 plan 为 null）
-		*/
-		"svn.aiPlanPending": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			const hit = planInbox.get(status.wcRoot);
-			const since = Number(args.since) || 0;
-			if (!hit || hit.at < since || now() - hit.at > 18e5) return {
-				ok: true,
-				plan: null,
-				dropped: 0,
-				at: 0
-			};
-			return {
-				ok: true,
-				plan: hit.plan,
-				dropped: hit.dropped,
-				at: hit.at
-			};
-		},
-		"svn.wcRev": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null || rel === "") return {
-				ok: true,
-				revision: null
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			const outcome = await runSvn(status.wcRoot, [
-				"info",
-				"--xml",
-				"--",
-				rel
-			], READ_GRACE_MS);
-			if (outcome.code !== 0) return {
-				ok: true,
-				revision: null
-			};
-			return {
-				ok: true,
-				revision: parseSvnInfoRevision(outcome.stdout)
-			};
-		},
-		"svn.cleanup": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed || !status.wcRoot) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			const argv = ["cleanup"];
-			if (args.removeUnversioned === true) argv.push("--remove-unversioned");
-			if (args.removeIgnored === true) argv.push("--remove-ignored");
-			try {
-				const outcome = await runSvn(status.wcRoot, argv, MUTATE_GRACE_MS);
-				const result = batchResultOf(outcome.stdout, outcome.stderr, outcome.code, "清理");
-				if (outcome.code !== 0) return {
+				try {
+					return {
+						ok: true,
+						...updateJobs.cancel(scope.root, args.jobId)
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: String(error)
+					};
+				}
+			},
+			"svn.updateActive": async (args) => {
+				const scope = await updateScope(args.sessionId);
+				if ("err" in scope) return {
 					ok: false,
-					error: "清理失败：" + tailOfText(result.output)
+					error: scope.err
 				};
-				changesCache.delete(status.wcRoot);
 				return {
 					ok: true,
-					...result
+					job: updateJobs.active(scope.root)
 				};
-			} catch (error) {
-				return {
+			},
+			"svn.tortoise": async (args) => {
+				const sc = await requireSvnSession(ctx, args.sessionId);
+				if ("err" in sc) return {
 					ok: false,
-					error: "清理失败：" + String(error)
+					error: sc.err
 				};
-			}
-		},
-		"svn.update": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const rel = safeRel(args.path);
-			if (rel === null) return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.svnCli) return {
-				ok: false,
-				error: "svn 命令不可用（可在设置页配置 svn 路径）"
-			};
-			try {
-				const outcome = await runSvn(sc.cwd, ["update", rel || "."], UPDATE_GRACE_MS);
-				const result = updateResultOf(outcome.stdout, outcome.stderr, outcome.code);
-				if (outcome.code !== 0) return {
+				const action = args.action;
+				if (action !== "update" && action !== "commit" && action !== "log" && action !== "diff" && action !== "blame" && action !== "revert") return {
 					ok: false,
-					error: "更新失败：" + tailOfText(result.output)
+					error: "未知动作: " + String(action)
 				};
-				return {
-					ok: true,
-					...result
-				};
-			} catch (error) {
-				return {
+				const rel = safeRel(args.path);
+				if (rel === null) return {
 					ok: false,
-					error: "更新失败：" + String(error)
+					error: "路径不合法"
 				};
-			}
-		},
-		"svn.tortoise": async (args) => {
-			const sc = await requireSvnSession(ctx, args.sessionId);
-			if ("err" in sc) return {
-				ok: false,
-				error: sc.err
-			};
-			const action = args.action;
-			if (action !== "update" && action !== "commit" && action !== "log" && action !== "diff" && action !== "blame" && action !== "revert") return {
-				ok: false,
-				error: "未知动作: " + String(action)
-			};
-			const rel = safeRel(args.path);
-			if (rel === null) return {
-				ok: false,
-				error: "路径不合法"
-			};
-			const status = await statusOf(sc.cwd);
-			if (!status.managed) return {
-				ok: false,
-				error: "当前工作区不受 SVN 管理"
-			};
-			if (!status.tortoise) return {
-				ok: false,
-				error: "TortoiseProc.exe 不可用（仅 Windows；可在设置页配置目录）"
-			};
-			const fs = ctx.get("fs");
-			if (!fs?.resolve || !fs?.stat || !fs?.processPath) return {
-				ok: false,
-				error: "缺少 fs"
-			};
-			try {
-				const target = await fs.resolve(rel || ".", { cwd: sc.cwd });
-				if (!await fs.stat(target)) return {
+				const status = await statusOf(sc.cwd);
+				if (!status.managed) return {
 					ok: false,
-					error: "路径不存在"
+					error: "当前工作区不受 SVN 管理"
 				};
-				const abs = fs.processPath(target);
-				launchTortoise(status.tortoiseExe, action, abs);
-				return {
-					ok: true,
-					launched: abs
+				if (!status.tortoise) return {
+					ok: false,
+					error: "TortoiseProc.exe 不可用（仅 Windows；可在设置页配置目录）"
 				};
-			} catch (error) {
-				return {
+				const fs = ctx.get("fs");
+				if (!fs?.resolve || !fs?.stat || !fs?.processPath) return {
 					ok: false,
-					error: "启动 TortoiseSVN 失败：" + String(error)
+					error: "缺少 fs"
 				};
+				try {
+					const target = await fs.resolve(rel || ".", { cwd: sc.cwd });
+					if (!await fs.stat(target)) return {
+						ok: false,
+						error: "路径不存在"
+					};
+					const abs = fs.processPath(target);
+					launchTortoise(status.tortoiseExe, action, abs);
+					return {
+						ok: true,
+						launched: abs
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error: "启动 TortoiseSVN 失败：" + String(error)
+					};
+				}
 			}
+		},
+		dispose: () => {
+			updateJobs.dispose();
+			updateRootCache.clear();
 		}
-	} };
+	};
 }
 //#endregion
 //#region src/shared/dap.ts
@@ -18246,10 +19364,12 @@ function apply(ctx, config) {
 		ctx,
 		settings: openSettings
 	}).handlers;
-	const svnHandlers = createSvnRpc({
+	/** SVN RPC（检测/更新/Tortoise 发射；settings 提供 svnPath/tortoisePath）。 */
+	const svnRpc = createSvnRpc({
 		ctx,
 		settings: openSettings
-	}).handlers;
+	});
+	const svnHandlers = svnRpc.handlers;
 	/** 调试 RPC（DAP 桥单例：spawn 扩展适配器 + 事件缓冲 + findFile 反向匹配）。 */
 	const dapRpc = createDapRpc(ctx);
 	const dapHandlers = dapRpc.handlers;
@@ -18279,6 +19399,7 @@ function apply(ctx, config) {
 		disposeAllServers();
 	});
 	ctx.effect(() => () => fileVersions.dispose());
+	ctx.effect(() => () => svnRpc.dispose());
 	ctx.effect(() => () => dapRpc.dispose());
 	hookExitReclaim();
 	log.info("编辑差异审查已装配（/edrv/rpc 路由就绪，项目 MCP 隔离已启用，语言服务器 LSP 已接入，规则注入" + (rulesInstalled ? "已接入" : "未接入") + "，技能组" + (skillsDispatched ? "装配中" : "未装配") + "）");