dsh-vscode-mode 0.10.0 → 0.12.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";
@@ -118,6 +118,8 @@ async function refreshMcp(ctx, id) {
 * `|` 连接多个候选（任一命中即触发），如 `Alt+ArrowLeft|Ctrl+Alt+-`。
 * 约束：本模块被 host 与 client 两半共用，**禁止 import client 侧模块**（React/浏览器 API）。
 * 与 client/ui/commandCatalog 的一致性由 tests/commands.test.ts 断言兜底。
+* 官方机制（2026-10）：SHORTCUT_PROFILES 描述各命令在官方 ctx.shortcuts 的 profile 默认键位
+* （由 client 注册官方服务时使用）；chordToBinding/bindingToChord 负责插件弦与官方绑定互转。
 * 作者 ddj 2026年08月26号 / 2026年09月10号
 */
 /** 命令 id → 默认键位（可为多候选）。命令目录以此为准，新增命令只需加一项。 */
@@ -900,6 +902,9 @@ async function updateSection(provider, ns, patch, expectedRevision) {
 * 构建设置 section schema（install 路径与插件 Config 声明共用，保证两代形状同源）。
 * 字段集 = fileOpenTool/keybindings/sidebarMinWidth/maxOpenEditors/integrationBaseUrl/
 * aiInline/aiProvider/aiModel/aiEffort/svnPath/tortoisePath/nativeOpenExts，全部带默认值
+* （keybindings 自 2026-10 起废弃停写：键位持久化归官方 shortcuts 存储
+*   userData/keybindings.json / dsh.keybindings.v1；字段保留仅为旧档迁移读取与降级回滚，
+*   见 client/shortcutsOfficial.ts 的 migrateLegacyKeybindings。）
 * （Config 启动校验在 undefined/空配置下自动填充，rc/alpha 两代 cordis 均通过）。
 * options.volatile：DSH 0.1.7 线的 Config 导出专用——SettingsForms.describe 只下发
 * 含 volatile 字段的 entry（volatileForm 门槛），不标记则 ns 永不出现在 describe、
@@ -5429,7 +5434,7 @@ async function restoreFile(ctx, session, rec) {
 //#region src/rules.ts
 /**
 * dsh-vscode-mode host — 规则管理（Codebuddy/Cursor 式 .mdc 规则）。
-* - 存储：用户规则 ~/.dsh/rules/*.mdc；项目规则 <工作区>/.dsh/rules/*.mdc（随仓库共享）。
+* - 存储：用户规则 DSH_HOME/rules + ~/.dsh/rules（当前目录优先）；项目规则 <工作区>/.dsh/rules。
 * - 格式：frontmatter（description / alwaysApply / globs / enabled）+ markdown 正文；
 *   类型映射 总是=always / 自动=auto(globs) / 手动=manual(仅索引)；enabled 为本插件扩展字段，缺省 true。
 * - 生效：host 注册 systemPrompt.section（order 400），每次装配同步读取（mtime 缓存），
@@ -5452,7 +5457,7 @@ const SECTION_NAME = "dsh-vscode-mode:rules";
 /** section 顺序：persona(0) 与 PLAN_POLICY(500) 之间，规则先于计划策略被读到。 */
 const SECTION_ORDER = 400;
 /**
-* 用户规则目录（~/.dsh/rules）。
+* 当前用户规则目录（DSH_HOME/rules）。
 * @author ddj 2026年09月03号
 * @param home DSH home（缺省自动解析）
 * @returns 绝对路径
@@ -5460,6 +5465,27 @@ const SECTION_ORDER = 400;
 function userRulesDir(home = dshHome()) {
 	return join(home, "rules");
 }
+/** DSH_HOME 改变时仍读取系统用户目录的旧规则；相同路径不重复加载。 */
+function userRuleDirs(activeHome = dshHome(), systemHome = homedir()) {
+	const current = resolve(userRulesDir(activeHome));
+	const legacy = resolve(userRulesDir(join(systemHome, ".dsh")));
+	const key = (path) => process.platform === "win32" ? path.toLowerCase() : path;
+	return key(current) === key(legacy) ? { current } : {
+		current,
+		legacy
+	};
+}
+function userDirOf(origin, dirs) {
+	if (origin === void 0 || origin === "current") return dirs.current;
+	if (origin === "legacy" && dirs.legacy) return dirs.legacy;
+	throw new Error("无效的用户规则来源");
+}
+/** 同名时当前目录优先；禁用的当前规则也应遮蔽旧目录规则。 */
+function mergeUserRules(current, legacy, fileOf) {
+	const key = (rule) => process.platform === "win32" ? fileOf(rule).toLowerCase() : fileOf(rule);
+	const seen = new Set(current.map(key));
+	return [...current, ...legacy.filter((rule) => !seen.has(key(rule)))].sort((a, b) => fileOf(a).localeCompare(fileOf(b)));
+}
 /**
 * 项目规则目录（<工作区>/.dsh/rules）。
 * @author ddj 2026年09月03号
@@ -5663,18 +5689,28 @@ function renderRulesSection(user, project, workspacePath) {
 	return [renderScope("用户规则（用户配置，必须遵守）", user), workspacePath ? renderScope("项目规则（工作区 " + workspacePath + "，必须遵守）", project) : ""].filter(Boolean).join("\n");
 }
 /** 单目录规则元信息列表（仅 *.mdc，最多 RULE_DIR_CAP 个；目录缺失返回空）。 */
-async function listRulesDir(dir, scope) {
-	const mdcs = (await readdir(dir).catch(() => [])).filter((name) => name.endsWith(".mdc")).sort().slice(0, RULE_DIR_CAP);
+async function listRulesDir(dir, scope, origin) {
+	const mdcs = (await readdir(dir).catch((error) => {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	})).filter((name) => name.endsWith(".mdc")).sort().slice(0, RULE_DIR_CAP);
 	const out = [];
 	for (const file of mdcs) {
 		const absPath = join(dir, file);
-		const info = await stat(absPath).catch(() => null);
+		const info = await stat(absPath).catch((error) => {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		});
 		if (!info || !info.isFile()) continue;
-		const parsed = parseRuleMdc(await readFile(absPath, "utf8").catch(() => ""));
-		out.push(toRuleInfo(scope, file, absPath, parsed, info.size, info.mtimeMs));
+		const parsed = parseRuleMdc(await readFile(absPath, "utf8"));
+		out.push(toRuleInfo(scope, file, absPath, parsed, info.size, info.mtimeMs, origin));
 	}
 	return out;
 }
+/** 列表与注入共用当前目录优先的合并约定。 */
+async function listUserRules(dirs = userRuleDirs()) {
+	return mergeUserRules(await listRulesDir(dirs.current, "user", "current"), dirs.legacy ? await listRulesDir(dirs.legacy, "user", "legacy") : [], (rule) => rule.file);
+}
 /** 已注册 workspace 列表（项目 Tab 与写入校验共用）。 */
 function workspaceList$1(ctx) {
 	return (ctx.get("workspaceRegistry")?.list?.() ?? []).filter((item) => Boolean(item) && typeof item.path === "string" && item.path !== "");
@@ -5691,10 +5727,16 @@ function requireWorkspace$2(ctx, workspacePath) {
 	if (!workspace) throw new Error("项目未注册为 DSH workspace，不能管理项目规则");
 	return workspace;
 }
-/** 按作用域解析规则目录（project 先过 requireWorkspace）。 */
-function dirOf$1(ctx, scope, workspacePath) {
-	if (scope === "project") return projectRulesDir(requireWorkspace$2(ctx, workspacePath).path);
-	return userRulesDir();
+/** 按作用域解析规则目录；客户端路径和未识别的来源均不作为目标使用。 */
+function dirOf$1(ctx, ref, dirs) {
+	const invalid = validateRuleFile(ref.file);
+	if (invalid) throw new Error(invalid);
+	if (ref.scope === "project") {
+		if (ref.origin !== void 0) throw new Error("项目规则不能指定用户规则来源");
+		return projectRulesDir(requireWorkspace$2(ctx, ref.workspacePath).path);
+	}
+	if (ref.scope !== "user") throw new Error("无效的规则作用域");
+	return userDirOf(ref.origin, dirs);
 }
 /**
 * 规则总列表：用户规则 + 各已注册工作区的项目规则。
@@ -5702,8 +5744,8 @@ function dirOf$1(ctx, scope, workspacePath) {
 * @param ctx DSH 上下文
 * @returns rules.list 载荷
 */
-async function rulesList(ctx) {
-	const user = await listRulesDir(userRulesDir(), "user");
+async function rulesList(ctx, dirs = userRuleDirs()) {
+	const user = await listUserRules(dirs);
 	const projects = [];
 	for (const workspace of workspaceList$1(ctx)) {
 		const dir = projectRulesDir(workspace.path);
@@ -5728,8 +5770,8 @@ async function rulesList(ctx) {
 * @param ref 作用域 + 文件名（+ 项目工作区）
 * @returns 文件全文
 */
-async function rulesRead(ctx, ref) {
-	const dir = dirOf$1(ctx, ref.scope, ref.workspacePath);
+async function rulesRead(ctx, ref, dirs = userRuleDirs()) {
+	const dir = dirOf$1(ctx, ref, dirs);
 	return readFile(join(dir, ref.file), "utf8");
 }
 /**
@@ -5743,12 +5785,13 @@ async function rulesRead(ctx, ref) {
 * @param mtime 修改时间毫秒
 * @returns 规则元信息
 */
-function toRuleInfo(scope, file, absPath, parsed, size, mtime) {
+function toRuleInfo(scope, file, absPath, parsed, size, mtime, origin) {
 	return {
 		scope,
 		file,
 		absPath,
-		relHint: scope === "project" ? ".dsh/rules/" : "rules/",
+		...scope === "user" ? { origin: origin ?? "current" } : {},
+		relHint: scope === "project" ? ".dsh/rules/" : origin === "legacy" ? "~/.dsh/rules/" : "rules/",
 		description: parsed.description,
 		type: ruleTypeOf(parsed),
 		globs: parsed.globs,
@@ -5765,10 +5808,8 @@ function toRuleInfo(scope, file, absPath, parsed, size, mtime) {
 * @param input 保存入参
 * @returns 保存后的规则元信息
 */
-async function rulesSave(ctx, input) {
-	const invalid = validateRuleFile(input.file);
-	if (invalid) throw new Error(invalid);
-	const dir = dirOf$1(ctx, input.scope, input.workspacePath);
+async function rulesSave(ctx, input, dirs = userRuleDirs()) {
+	const dir = dirOf$1(ctx, input, dirs);
 	await mkdir(dir, { recursive: true });
 	const absPath = join(dir, input.file);
 	const content = String(input.content ?? "");
@@ -5779,15 +5820,15 @@ async function rulesSave(ctx, input) {
 		await fs.writeText(target, content, void 0, void 0, fullPolicy$2(ctx));
 	} else await writeFile(absPath, content, "utf8");
 	const info = await stat(absPath).catch(() => null);
-	return toRuleInfo(input.scope, input.file, absPath, parseRuleMdc(content), info?.size ?? Buffer$1.byteLength(content), info?.mtimeMs ?? Date.now());
+	return toRuleInfo(input.scope, input.file, absPath, parseRuleMdc(content), info?.size ?? Buffer$1.byteLength(content), info?.mtimeMs ?? Date.now(), input.origin);
 }
 /**
 * 删除一条规则文件（project 作用域同样先过 workspace 注册校验）。
 * @author ddj 2026年09月03号
 * @param ref 作用域 + 文件名（+ 项目工作区）
 */
-async function rulesRemove(ctx, ref) {
-	const dir = dirOf$1(ctx, ref.scope, ref.workspacePath);
+async function rulesRemove(ctx, ref, dirs = userRuleDirs()) {
+	const dir = dirOf$1(ctx, ref, dirs);
 	await rm(join(dir, ref.file), { force: true });
 }
 /**
@@ -5797,8 +5838,8 @@ async function rulesRemove(ctx, ref) {
 * @param enabled 目标状态
 * @returns 更新后的规则元信息
 */
-async function rulesToggle(ctx, ref, enabled) {
-	const dir = dirOf$1(ctx, ref.scope, ref.workspacePath);
+async function rulesToggle(ctx, ref, enabled, dirs = userRuleDirs()) {
+	const dir = dirOf$1(ctx, ref, dirs);
 	const absPath = join(dir, ref.file);
 	const text = await readRuleText(ctx, ref, absPath);
 	if (text === null) throw new Error("规则文件不存在：" + ref.file);
@@ -5809,7 +5850,10 @@ async function rulesToggle(ctx, ref, enabled) {
 }
 /** 按作用域读规则全文：project 与写盘同通道走 ctx fs，user 走 node fs；缺失返回 null。 */
 async function readRuleText(ctx, ref, absPath) {
-	if (ref.scope !== "project") return readFile(absPath, "utf8").catch(() => null);
+	if (ref.scope !== "project") return readFile(absPath, "utf8").catch((error) => {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	});
 	const fs = ctx.get("fs");
 	if (!fs) throw new Error("缺少 fs 服务");
 	const target = await fs.resolve(".dsh/rules/" + ref.file, { cwd: requireWorkspace$2(ctx, ref.workspacePath).path });
@@ -5833,24 +5877,24 @@ async function rulesSaveContent(ctx, ref, absPath, content) {
 /** 重建单条规则元信息（toggle 后回传 UI；stat 失败时用内容长度 + 当前时间兜底）。 */
 async function ruleInfoOf(ref, absPath, content) {
 	const info = await stat(absPath).catch(() => null);
-	return toRuleInfo(ref.scope, ref.file, absPath, parseRuleMdc(content), info?.size ?? Buffer$1.byteLength(content), info?.mtimeMs ?? Date.now());
+	return toRuleInfo(ref.scope, ref.file, absPath, parseRuleMdc(content), info?.size ?? Buffer$1.byteLength(content), info?.mtimeMs ?? Date.now(), ref.origin);
 }
 const injCache = /* @__PURE__ */ new Map();
 /**
-* 同步读取一个规则目录（装配 provider 内专用）：仅 *.mdc，mtime 缓存，异常静默为空。
+* 同步读取一个规则目录（装配 provider 内专用）：仅 *.mdc，mtime 缓存；缺失视为空。
 * @author ddj 2026年09月03号
 * @param dir 规则目录
 * @param scope 作用域
-* @param relHint 相对提示
+* @param origin 用户规则来源
 * @returns 已加载规则列表
 */
-function readRulesSync(dir, scope) {
-	if (!existsSync(dir)) return [];
+function readRulesSync(dir, scope, origin) {
 	let names;
 	try {
 		names = readdirSync(dir);
-	} catch {
-		return [];
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
 	}
 	const out = [];
 	for (const file of names.filter((name) => name.endsWith(".mdc")).sort().slice(0, RULE_DIR_CAP)) {
@@ -5858,8 +5902,9 @@ function readRulesSync(dir, scope) {
 		let info;
 		try {
 			info = statSync(absPath);
-		} catch {
-			continue;
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			throw error;
 		}
 		if (!info.isFile()) continue;
 		const cached = injCache.get(absPath);
@@ -5868,8 +5913,9 @@ function readRulesSync(dir, scope) {
 		else {
 			try {
 				parsed = parseRuleMdc(readFileSync(absPath, "utf8"));
-			} catch {
-				continue;
+			} catch (error) {
+				if (error.code === "ENOENT") continue;
+				throw error;
 			}
 			injCache.set(absPath, {
 				mtimeMs: info.mtimeMs,
@@ -5878,12 +5924,16 @@ function readRulesSync(dir, scope) {
 			});
 		}
 		out.push({
-			info: toRuleInfo(scope, file, absPath, parsed, info.size, info.mtimeMs),
+			info: toRuleInfo(scope, file, absPath, parsed, info.size, info.mtimeMs, origin),
 			body: parsed.body
 		});
 	}
 	return out;
 }
+/** 同步装配与列表同名遮蔽策略一致。 */
+function readUserRulesSync(dirs = userRuleDirs()) {
+	return mergeUserRules(readRulesSync(dirs.current, "user", "current"), dirs.legacy ? readRulesSync(dirs.legacy, "user", "legacy") : [], (rule) => rule.info.file);
+}
 /** 从装配上下文解析会话工作区 cwd（agent.id → sessions → header.cwd；缺链返回 null）。 */
 function cwdFromAssemble(ctx, asm) {
 	const id = asm?.agent?.id;
@@ -5897,12 +5947,12 @@ function cwdFromAssemble(ctx, asm) {
 * @param ctx DSH host 上下文
 * @returns 是否成功注册
 */
-function installRulesSection(ctx) {
+function installRulesSection(ctx, dirs = userRuleDirs()) {
 	const sp = ctx.get("systemPrompt");
 	if (!sp || typeof sp.section !== "function") return false;
 	const provider = (asm) => {
 		try {
-			const user = readRulesSync(userRulesDir(), "user");
+			const user = readUserRulesSync(dirs);
 			const cwd = cwdFromAssemble(ctx, asm);
 			return renderRulesSection(user, cwd ? readRulesSync(projectRulesDir(cwd), "project") : [], cwd ?? void 0);
 		} catch {
@@ -8335,6 +8385,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 +8460,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 +8838,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 +8944,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 +9041,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 +9754,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 +11089,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 +11288,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 +11304,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 +11816,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 +11833,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 +11856,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 +11882,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 +11931,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 +13186,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 +13818,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 +14719,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 +14761,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,126 +15048,771 @@ 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 = [
+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"
@@ -15100,6 +16096,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 +16121,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 +16130,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 +16142,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 +16211,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 +16668,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 +19414,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 +19449,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 ? "装配中" : "未装配") + "）");