dsh-vscode-mode 0.14.2 → 0.14.3

package/lib/index.js

@@ -5,6 +5,7 @@ import { chmodSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync,
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createHash, randomUUID } from "node:crypto";
 import { homedir, tmpdir } from "node:os";
+import { DatabaseSync } from "node:sqlite";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { execFile, spawn, spawnSync } from "node:child_process";
 import z from "@deepseek-ai/schemastery";
@@ -2241,8 +2242,6 @@ const DSH_HOME_ENV = "DSH_HOME";
 const CACHE_TOTAL_CAP = 209715200;
 /** 工作区根侧车：审查记录（用户数据，随项目走，不迁移）。 */
 const SIDECAR = ".dsh-edit-review.json";
-/** 工作区根侧车：归档（用户数据）。 */
-const SIDECAR_ARCHIVE = ".dsh-edit-review-archive.json";
 /** 旧 debug 日志文件名（工作区，迁移后由插件清理）。 */
 const DEBUG_LOG = ".dsh-edit-review-debug.log";
 /** 旧树缓存 sidecar 名（工作区，迁移后由插件清理；缓存可重建，删除无损）。 */
@@ -2376,6 +2375,16 @@ function uiGlobalsFile(home = dshHome(), schema = 1) {
 function debugLogFile(cwd, home = dshHome()) {
 	return join(pluginLogRoot(home), "debug." + hashOf(cwd) + ".log");
 }
+/**
+* 每工作区归档数据库（用户数据，不受缓存清理预算约束）。
+* @author ddj 2026年09月30号
+* @param cwd 工作区绝对路径
+* @param home DSH home
+* @returns 归档数据库绝对路径
+*/
+function archiveDbFile(cwd, home = dshHome()) {
+	return join(home, PLUGIN_ID, "data", "archive", hashOf(cwd) + ".sqlite");
+}
 /** 插件包 assets 目录（import.meta.url 派生；config.imageDir 可覆盖，见 imageDirOf）。 */
 function assetsDirOf(moduleUrl) {
 	return join(dirname(fileURLToPath(moduleUrl)), "..", "assets");
@@ -3735,21 +3744,42 @@ function commonSuffix(left, right, prefix) {
 	while (i < limit && left.charCodeAt(left.length - 1 - i) === right.charCodeAt(right.length - 1 - i)) i++;
 	return i;
 }
-/** 找出文本的全部非重叠出现位置。 */
-function allMatches(content, needle) {
-	if (!needle.length) return [];
-	const out = [];
-	let from = 0;
-	while (from <= content.length - needle.length) {
-		const at = content.indexOf(needle, from);
-		if (at < 0) break;
-		out.push({
+/**
+* 懒扫描候选：先找 cursor 后未占用项，找不到再回退至首个未占用项。
+* @author ddj 2026年09月29号
+* @param content 当前内容
+* @param needle 搜索串
+* @param cursor 前一块的结束位置
+* @param occupied 已选区间
+* @param state 此搜索串已扫描的候选
+* @returns 与完整候选列表双轮查找相同的匹配
+*/
+function findCandidate(content, needle, cursor, occupied, state) {
+	if (!needle.length) return void 0;
+	let fallback;
+	for (let i = 0; i < state.ranges.length; i++) {
+		const range = state.ranges[i];
+		if (occupied.some((used) => overlaps(range, used))) continue;
+		if (range.start >= cursor) return range;
+		if (!fallback) fallback = range;
+	}
+	while (!state.done) {
+		const at = content.indexOf(needle, state.next);
+		if (at < 0) {
+			state.done = true;
+			break;
+		}
+		const range = {
 			start: at,
 			end: at + needle.length
-		});
-		from = at + Math.max(1, needle.length);
+		};
+		state.ranges.push(range);
+		state.next = range.end;
+		if (occupied.some((used) => overlaps(range, used))) continue;
+		if (range.start >= cursor) return range;
+		if (!fallback) fallback = range;
 	}
-	return out;
+	return fallback;
 }
 /**
 * 从 after 快照定位所有 hunk，按 hunk 顺序优先选未占用且靠近前一块的候选。
@@ -3763,6 +3793,7 @@ function locateHunks(content, hunks) {
 	const locations = [];
 	let cursor = 0;
 	const occupied = [];
+	const matches = /* @__PURE__ */ new Map();
 	for (let idx = 0; idx < hunks.length; idx++) {
 		const hunk = hunks[idx];
 		const newText = hunk.newText;
@@ -3771,8 +3802,21 @@ function locateHunks(content, hunks) {
 			end: hunk.afterEnd
 		} : null;
 		const snapshotMatches = snapshot && snapshot.start >= 0 && snapshot.end >= snapshot.start && (newText.length === 0 || content.slice(snapshot.start, snapshot.end) === newText) ? snapshot : null;
-		const candidates = snapshotMatches ? [snapshotMatches] : allMatches(content, newText);
-		const candidate = candidates.find((range) => range.start >= cursor && !occupied.some((used) => overlaps(range, used))) ?? candidates.find((range) => !occupied.some((used) => overlaps(range, used)));
+		let candidate;
+		if (snapshotMatches) {
+			if (!occupied.some((used) => overlaps(snapshotMatches, used))) candidate = snapshotMatches;
+		} else if (newText.length) {
+			let state = matches.get(newText);
+			if (!state) {
+				state = {
+					ranges: [],
+					next: 0,
+					done: false
+				};
+				matches.set(newText, state);
+			}
+			candidate = findCandidate(content, newText, cursor, occupied, state);
+		}
 		if (candidate) {
 			locations.push({
 				idx,
@@ -3832,82 +3876,43 @@ function replaceRange(content, location, reverse = false) {
 	const replacement = reverse ? location.hunk.oldText ?? "" : location.hunk.newText;
 	return content.slice(0, location.start) + replacement + content.slice(location.end);
 }
-/** 按当前内容中出现的位置从后向前应用 hunk，避免前块长度变化影响后块。 */
+/**
+* 按位置倒序收集片段，最后一次拼接；非互斥区间退回原替换语义。
+* @author ddj 2026年09月29号
+* @param content 当前文件内容
+* @param locations 已定位区间
+* @param reverse 是否反向应用
+* @returns 合成内容及失效块索引
+*/
 function applyLocations(content, locations, reverse = false) {
 	const stale = locations.filter((location) => !location.matched).map((location) => location.idx);
-	let out = content;
 	const matched = locations.filter((location) => location.matched).sort((a, b) => b.start - a.start);
+	const parts = [];
+	let end = content.length;
 	for (const location of matched) {
-		const next = replaceRange(out, location, reverse);
-		if (next === null) stale.push(location.idx);
-		else out = next;
+		if (location.start < 0 || location.end > end) {
+			let out = content;
+			for (const item of matched) {
+				const next = replaceRange(out, item, reverse);
+				if (next === null) stale.push(item.idx);
+				else out = next;
+			}
+			return {
+				content: out,
+				stale: stale.sort((a, b) => a - b)
+			};
+		}
+		parts.push(content.slice(location.end, end), reverse ? location.hunk.oldText ?? "" : location.hunk.newText);
+		end = location.start;
 	}
+	parts.push(content.slice(0, end));
+	parts.reverse();
 	return {
-		content: out,
+		content: parts.join(""),
 		stale: stale.sort((a, b) => a - b)
 	};
 }
 /**
-* 归一化一条持久化记录（容忍旧版/损坏字段）。
-* @author ddj 2026年08月20号
-* @param raw 反序列化的原始记录
-* @returns 合法记录或 null
-*/
-function normalizeRecord(raw) {
-	if (!raw || typeof raw !== "object") return null;
-	const r = raw;
-	if (typeof r.callId !== "string" || typeof r.path !== "string") return null;
-	const hunks = Array.isArray(r.hunks) ? r.hunks.filter((h) => h && typeof h.newText === "string").map((h) => {
-		const item = h;
-		return {
-			oldText: typeof item.oldText === "string" ? item.oldText : null,
-			newText: item.newText,
-			...Number.isInteger(item.afterStart) ? { afterStart: item.afterStart } : {},
-			...Number.isInteger(item.afterEnd) ? { afterEnd: item.afterEnd } : {},
-			...Number.isInteger(item.beforeStart) ? { beforeStart: item.beforeStart } : {},
-			...Number.isInteger(item.beforeEnd) ? { beforeEnd: item.beforeEnd } : {}
-		};
-	}) : [];
-	const toolName = r.toolName === "write" || r.toolName === "remote_ssh_write" ? r.toolName : "edit";
-	const rawDecisions = r.decisions && typeof r.decisions === "object" ? r.decisions : {};
-	const call = rawDecisions.call === "accepted" || rawDecisions.call === "rejected" ? rawDecisions.call : "pending";
-	const rawPerHunk = Array.isArray(rawDecisions.perHunk) ? rawDecisions.perHunk : [];
-	const perHunk = hunks.map((_, i) => {
-		const value = rawPerHunk[i];
-		if (value === "accepted" || value === "rejected") return value;
-		return call === "accepted" || call === "rejected" ? call : "pending";
-	});
-	const before = typeof r.before === "string" ? r.before : null;
-	const hasAfter = Object.prototype.hasOwnProperty.call(r, "after");
-	const after = typeof r.after === "string" ? r.after : null;
-	return {
-		callId: r.callId,
-		toolName,
-		path: r.path,
-		before,
-		after,
-		baseFingerprint: typeof r.baseFingerprint === "string" ? r.baseFingerprint : fingerprint(before),
-		afterFingerprint: typeof r.afterFingerprint === "string" ? r.afterFingerprint : fingerprint(after),
-		legacy: !hasAfter,
-		conflict: r.conflict === true,
-		create: r.create === true,
-		callHunk: r.callHunk && typeof r.callHunk.oldText === "string" && typeof r.callHunk.newText === "string" ? {
-			oldText: r.callHunk.oldText,
-			newText: r.callHunk.newText
-		} : null,
-		hunks,
-		decisions: {
-			call,
-			perHunk
-		},
-		note: typeof r.note === "string" ? r.note : null,
-		superseded: r.superseded === true,
-		archived: r.archived === true,
-		batch: Number.isInteger(r.batch) ? r.batch : 0,
-		at: typeof r.at === "string" ? r.at : (/* @__PURE__ */ new Date()).toISOString()
-	};
-}
-/**
 * 写决策到记录（scope=call 整体 / hunk 单个块）。
 * @author ddj 2026年08月20号
 * @param record 记录
@@ -4012,16 +4017,6 @@ function prune(map, max = 200) {
 	const sorted = [...map.values()].sort((a, b) => a.at < b.at ? -1 : 1);
 	for (let i = 0; i < sorted.length - max; i++) map.delete(sorted[i].callId);
 }
-/** 按批次分组记录。 */
-function groupByBatch(recs) {
-	const map = /* @__PURE__ */ new Map();
-	for (const r of recs) {
-		const k = Number.isInteger(r.batch) ? r.batch : null;
-		if (!map.has(k)) map.set(k, []);
-		map.get(k).push(r);
-	}
-	return map;
-}
 /**
 * 归档条目构造（一条批次一条）。
 * @author ddj 2026年08月20号
@@ -4060,105 +4055,742 @@ function archiveEntryFor(recs, cwd, reason) {
 	};
 }
 //#endregion
-//#region src/store.ts
-const READ_CAP$1 = 8388608;
-/** 二进制预览/写回上限（PDF 等整文件 base64 传输；文本侧仍用 READ_CAP）。 */
-const BINARY_READ_CAP = 33554432;
-/** 会话沙箱策略（policyOf）：可能不存在，调用方需容忍 undefined。 */
-function policyOf(ctx, session) {
-	const svc = ctx.get("sandboxPolicy");
-	if (!svc) return void 0;
-	return session ? svc.resolve({ session }) : svc.resolve();
+//#region src/debugLog.ts
+/**
+* dsh-vscode-mode host — 诊断文件通道（client 上报 → 缓冲批量落盘）+ 日志文件管理。
+* 通道：edrv.debug RPC → 内存缓冲（满/空闲触发）→ 串行读改写
+*       `~/.dsh/dsh-vscode-mode/logs/debug.<cwdHash>.log`（512KB 上限截断保留尾部）。
+* 设计：console 不一定落盘，文件可靠；写失败静默忽略（调试日志不阻塞业务）。
+* 管理：edrv.dlog.* RPC 用的清单/尾部读取/清空三能力；file 参数一律先过
+*       isDebugLogName 白名单（纯文件名、无路径分隔），杜绝穿越出日志根。
+* 作者 ddj 2026-09-08 / 2026-09-17
+*/
+/** cwd → 内存缓冲：行数组 + 累计字节数 + 待触发 flush 定时器（攒批落盘，避免每条日志全文件读改写）。 */
+const debugBuffers = /* @__PURE__ */ new Map();
+/** cwd → Promise 链：串行化 debug 日志落盘（fs read+write 非原子，避免并发丢行）。 */
+const debugWriteQueues = /* @__PURE__ */ new Map();
+/** debug 日志单文件上限：超限截断保留尾部，防文件无限增长拖慢每次追加。 */
+const DEBUG_LOG_CAP = 524288;
+/** debug 日志批量缓冲上限：攒满即落盘（一次读改写），上限内不逐条写文件。 */
+const DEBUG_BUF_CAP = 32768;
+/** debug 日志空闲 flush 延迟：缓冲未满时，静默一段时间后落盘一次。 */
+const DEBUG_FLUSH_IDLE_MS = 1e3;
+/** cwd → 已清理旧工作区 debug 日志标记（一次性）。 */
+const debugLegacyCleaned = /* @__PURE__ */ new Set();
+/** 诊断回显日志器（终端回显统一带 `[dsh-vscode-mode:debug]` 前缀，级别跟随上报级别）。 */
+const debugLog = log.child("debug");
+/** 诊断日志文件名白名单（cwd hash 命名；请求回传的 file 参数必须整名匹配，防路径穿越）。 */
+const DEBUG_LOG_NAME = /^debug\.[0-9a-f]{16}\.log$/;
+/**
+* 文件名是否为合法诊断日志名（白名单整名匹配，杜绝路径穿越）。
+* @author ddj 2026年09月17号
+* @param name 请求回传的文件名（可为空）
+* @returns 是否合法
+*/
+function isDebugLogName(name) {
+	return typeof name === "string" && DEBUG_LOG_NAME.test(name);
 }
-/** 按会话 cwd 解析目标路径。 */
-async function resolveTarget(ctx, session, path) {
-	const fs = ctx.get("fs");
-	const cwd = session?.header?.cwd;
-	return fs.resolve(path, cwd ? { cwd } : {});
+/**
+* 批量落盘一条 debug 日志缓冲：读旧文件 → 追加 → 超上限截断保留尾部 → 一次写回。
+* 串行链保证同一 cwd 的读改写不交错丢行；写失败静默忽略（调试日志不阻塞业务）。
+* @author ddj 2026年09月08号
+* @param cwd 工作区（日志落 ~/.dsh/dsh-vscode-mode/logs/debug.<cwdHash>.log）
+* @param batch 本批日志行
+*/
+function flushDebug(cwd, batch) {
+	const task = (debugWriteQueues.get(cwd) ?? Promise.resolve()).then(async () => {
+		try {
+			await mkdir(pluginLogRoot(), { recursive: true });
+			const target = debugLogFile(cwd);
+			const appended = await readFile(target, "utf8").catch(() => "") + batch.map((l) => (/* @__PURE__ */ new Date()).toISOString() + " " + l + "\n").join("");
+			const next = appended.length > DEBUG_LOG_CAP ? appended.slice(-Math.floor(DEBUG_LOG_CAP / 2)) : appended;
+			await writeFile(target, next, "utf8");
+			if (!debugLegacyCleaned.has(cwd)) {
+				debugLegacyCleaned.add(cwd);
+				await rm(join(cwd, DEBUG_LOG), { force: true }).catch(() => {});
+			}
+		} catch (e) {}
+	});
+	debugWriteQueues.set(cwd, task);
+	return task;
 }
-/** 读取工作区主 sidecar 文本（缺失/失败 → null）。 */
-async function readSidecarText(ctx, cwd) {
-	const fs = ctx.get("fs");
-	if (!fs || !cwd) return null;
-	try {
-		return await fs.readText(await fs.resolve(SIDECAR, { cwd }));
-	} catch (error) {
-		return null;
+/**
+* 记录一条 client 上报的诊断日志：入队缓冲批量落盘 + 终端回显（级别跟随，缺省 debug）。
+* 落盘行格式 `<iso> [level] text`；级别标记在入队时补齐，flush 侧无感。
+* @author ddj 2026年09月08号 / 2026年09月17号
+* @param _ctx DSH 上下文（入参保留：诊断通道按 cwd 隔离，当前不需要 ctx，未来过滤用）
+* @param cwd 工作区（日志文件按 cwd hash 隔离）
+* @param text 单条日志文本（不含换行）
+* @param level 日志级别（缺省 debug；落盘行与终端回显均带此级别）
+*/
+function debugRecord(_ctx, cwd, text, level = "debug") {
+	const tagged = "[" + level + "] " + text;
+	const st = debugBuffers.get(cwd) ?? {
+		lines: [],
+		len: 0,
+		timer: null
+	};
+	st.lines.push(tagged);
+	st.len += tagged.length;
+	const flush = () => {
+		st.timer = null;
+		const batch = st.lines;
+		st.lines = [];
+		st.len = 0;
+		flushDebug(cwd, batch);
+	};
+	if (st.len >= DEBUG_BUF_CAP) {
+		if (st.timer) clearTimeout(st.timer);
+		flush();
+	} else if (!st.timer) st.timer = setTimeout(flush, DEBUG_FLUSH_IDLE_MS);
+	debugBuffers.set(cwd, st);
+	debugLog[level](text);
+}
+/**
+* 清单：日志根下全部诊断日志文件（名字/字节/mtime；非法名跳过），mtime 新的在前。
+* @author ddj 2026年09月17号
+* @param home DSH home（测试可注入；缺省按环境解析）
+* @returns 清单项数组
+*/
+async function listDebugLogs(home = dshHome()) {
+	const names = await readdir(pluginLogRoot(home)).catch(() => []);
+	const items = [];
+	for (const name of names) {
+		if (!isDebugLogName(name)) continue;
+		const info = await stat(join(pluginLogRoot(home), name)).catch(() => null);
+		if (!info?.isFile()) continue;
+		items.push({
+			name,
+			bytes: info.size,
+			mtimeMs: info.mtimeMs
+		});
 	}
+	items.sort((a, b) => b.mtimeMs - a.mtimeMs);
+	return items;
 }
 /**
-* 解析主 sidecar：v2 直接返回；v1 迁移为 v2 结构（按会话 cwd 分桶）。
-* @author ddj 2026年08月20号
-* @param text sidecar 文本
-* @returns v2 数据或 null
+* 尾部读取一份诊断日志：保留文件尾 maxBytes 字节（缺省 256KB），truncated 标记截头。
+* 单文件本体受 DEBUG_LOG_CAP=512KB 约束，整读为字符串的成本可接受。
+* @author ddj 2026年09月17号
+* @param name 日志文件名（isDebugLogName 白名单校验，非法直接 null）
+* @param maxBytes 尾部保留字节数（缺省 256KB）
+* @param home DSH home（测试可注入）
+* @returns 读取结果；文件不存在或名字非法返回 null
 */
-function parseSidecar(text) {
-	if (!text) return null;
+async function readDebugLog(name, maxBytes = 262144, home = dshHome()) {
+	if (!isDebugLogName(name)) return null;
+	const target = join(pluginLogRoot(home), name);
+	const info = await stat(target).catch(() => null);
+	if (!info?.isFile()) return null;
+	const text = await readFile(target, "utf8").catch(() => null);
+	if (text === null) return null;
+	const cut = Math.max(0, text.length - maxBytes);
+	return {
+		name,
+		path: target,
+		content: cut > 0 ? text.slice(cut) : text,
+		size: info.size,
+		truncated: cut > 0
+	};
+}
+/**
+* 清空一份诊断日志（truncate 到 0，保留文件本身）。
+* @author ddj 2026年09月17号
+* @param name 日志文件名（isDebugLogName 白名单校验）
+* @param home DSH home（测试可注入）
+* @returns 是否清空成功（文件不存在视为未成功，文案由调用方给）
+*/
+async function clearDebugLog(name, home = dshHome()) {
+	if (!isDebugLogName(name)) return false;
+	return await truncate(join(pluginLogRoot(home), name)).then(() => true).catch(() => false);
+}
+//#endregion
+//#region src/archiveDb.ts
+/**
+* 工作区差异归档 V2：SQLite 事务追加与按需读取；旧 JSON 只读留存，不参与热路径。
+* 数据库位于 DSH home 的 data/，不会被缓存清理器删除。
+* 作者 ddj 2026-09-30
+*/
+/**
+* 数据库行中 null 批次用独立字符串键，避免 SQLite UNIQUE 对 NULL 不去重。
+* @author ddj 2026年09月30号
+* @param batch 原始批次
+* @returns 可用于唯一约束的字符串键
+*/
+const batchKey = (batch) => batch === null ? "null" : "n" + batch;
+/** 仅由本插件打开的工作区连接；插件卸载时 closeArchiveDbs 关闭。 */
+const connections = /* @__PURE__ */ new Map();
+/**
+* 打开且核验单工作区数据库；已有异常库绝不重置成空库。
+* @author ddj 2026年09月30号
+* @param cwd 工作区绝对路径
+* @returns 已缓存连接
+*/
+function dbFor(cwd) {
+	const existing = connections.get(cwd);
+	if (existing) return existing;
+	const file = archiveDbFile(cwd);
+	mkdirSync(dirname(file), {
+		recursive: true,
+		mode: 448
+	});
+	const db = new DatabaseSync(file, { timeout: 2e3 });
 	try {
-		const data = JSON.parse(text);
-		if (data && typeof data === "object" && data.version === 2 && data.workspaces && typeof data.workspaces === "object") return data;
-		if (data && data.version === 1 && data.sessions && typeof data.sessions === "object") {
-			const workspaces = {};
-			for (const bucket of Object.values(data.sessions)) {
-				const b = bucket;
-				if (typeof b.cwd === "string" && b.records) workspaces[b.cwd] = {
-					at: typeof b.at === "number" ? b.at : Date.now(),
-					records: b.records
-				};
+		db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA busy_timeout=2000");
+		db.exec("CREATE TABLE IF NOT EXISTS metadata (name TEXT PRIMARY KEY, value TEXT NOT NULL)");
+		const version = db.prepare("SELECT value FROM metadata WHERE name='schema'").get();
+		const workspace = db.prepare("SELECT value FROM metadata WHERE name='cwd'").get();
+		if (version && version.value !== "2" && version.value !== "3" || workspace && workspace.value !== cwd) throw new Error("归档数据库 schema/工作区不匹配");
+		if (!!version !== !!workspace) throw new Error("归档数据库元数据不完整");
+		if (!version) {
+			if (db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name<>'metadata' LIMIT 1").get()) throw new Error("归档数据库缺失元数据且已有数据表");
+		}
+		db.exec(`CREATE TABLE IF NOT EXISTS batches (
+        id INTEGER PRIMARY KEY, cwd TEXT NOT NULL, path TEXT NOT NULL, batch_key TEXT NOT NULL,
+        batch INTEGER, at TEXT NOT NULL, last_at TEXT, reason TEXT,
+        accepted INTEGER NOT NULL DEFAULT 0, rejected INTEGER NOT NULL DEFAULT 0,
+        pending INTEGER NOT NULL DEFAULT 0, superseded INTEGER NOT NULL DEFAULT 0,
+        n_records INTEGER NOT NULL DEFAULT 0, UNIQUE(cwd,path,batch_key)
+      );
+      CREATE TABLE IF NOT EXISTS records (
+        batch_id INTEGER NOT NULL REFERENCES batches(id), call_id TEXT NOT NULL,
+        payload TEXT NOT NULL, accepted INTEGER NOT NULL, rejected INTEGER NOT NULL,
+        pending INTEGER NOT NULL, superseded INTEGER NOT NULL,
+        PRIMARY KEY(batch_id,call_id)
+      );
+      CREATE INDEX IF NOT EXISTS archive_by_path ON batches(cwd,path,batch);
+      CREATE INDEX IF NOT EXISTS archive_by_call ON records(call_id);
+      CREATE TABLE IF NOT EXISTS revert_intents (
+        call_id TEXT NOT NULL, scope TEXT NOT NULL, hunk_index INTEGER NOT NULL,
+        state TEXT NOT NULL CHECK(state IN ('started','applied')),
+        PRIMARY KEY(call_id,scope,hunk_index)
+      )`);
+		if (!version) {
+			db.exec("BEGIN IMMEDIATE");
+			try {
+				db.prepare("INSERT INTO metadata(name,value) VALUES('schema','2')").run();
+				db.prepare("INSERT INTO metadata(name,value) VALUES('cwd',?)").run(cwd);
+				db.exec("COMMIT");
+			} catch (error) {
+				if (db.isTransaction) db.exec("ROLLBACK");
+				throw error;
 			}
-			return {
-				version: 2,
-				updatedAt: typeof data.updatedAt === "string" ? data.updatedAt : (/* @__PURE__ */ new Date()).toISOString(),
-				workspaces
-			};
 		}
-		return null;
+		if (version?.value === "3") {
+			const active = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='active_records'").get();
+			const source = db.prepare("SELECT value FROM metadata WHERE name='active_source'").get();
+			if (!active || !source) throw new Error("活跃记录数据库元数据不完整");
+		}
+		connections.set(cwd, db);
+		return db;
 	} catch (error) {
-		return null;
-	}
-}
-/** 加载某工作区的记录桶（内存 Map；缺失 → 空）。 */
-async function loadBucket(ctx, cwd) {
-	const data = parseSidecar(await readSidecarText(ctx, cwd));
-	const map = /* @__PURE__ */ new Map();
-	if (data && data.workspaces[cwd] && typeof data.workspaces[cwd].records === "object") for (const rec of Object.values(data.workspaces[cwd].records)) {
-		const n = normalizeRecord(rec);
-		if (n) map.set(n.callId, n);
+		db.close();
+		throw error;
 	}
-	return map;
 }
-/** 保存某工作区的记录桶（写前合并，不覆盖其他工作区）。 */
-async function saveBucket(ctx, cwd, recsMap, session) {
-	const fs = ctx.get("fs");
-	if (!fs || !cwd) return;
+/**
+* 只在隔离的切换窗口导入旧 sidecar；不接受模糊空库或解析损坏的输入。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param source 旧文件原文（null 仅表示明确不存在）
+* @param confirm 再读源文件原文，防止迁移途中旧 Host 改写
+* @returns 活跃记录 Map
+*/
+async function migrateActive(cwd, source, confirm) {
+	const db = dbFor(cwd);
+	if (String(db.prepare("SELECT value FROM metadata WHERE name='schema'").get().value) === "3") return readActive(cwd);
+	const digest = source === null ? "absent" : createHash("sha256").update(source).digest("hex");
+	let recs = {};
+	if (source !== null) {
+		let parsed;
+		try {
+			parsed = JSON.parse(source);
+		} catch {
+			throw new Error("旧活跃 sidecar 损坏，停止迁移");
+		}
+		if (parsed?.version !== 2 || !parsed.workspaces || typeof parsed.workspaces !== "object" || Array.isArray(parsed.workspaces)) throw new Error("旧活跃 sidecar 格式无效");
+		const workspace = parsed.workspaces[cwd];
+		if (workspace && (!workspace.records || typeof workspace.records !== "object" || Array.isArray(workspace.records))) throw new Error("旧工作区记录格式无效");
+		recs = workspace?.records ?? {};
+		for (const [key, rec] of Object.entries(recs)) if (!rec || rec.callId !== key || typeof rec.path !== "string" || !Array.isArray(rec.hunks) || !rec.decisions || !Array.isArray(rec.decisions.perHunk) || !Number.isInteger(rec.batch) || typeof rec.at !== "string") throw new Error("旧活跃记录损坏：" + key);
+	}
+	if (await confirm() !== source) throw new Error("迁移期间旧活跃 sidecar 被修改");
+	if (activeReady(cwd)) return readActive(cwd);
+	db.exec("BEGIN IMMEDIATE");
 	try {
-		const target = await fs.resolve(SIDECAR, { cwd });
-		const existing = parseSidecar(await readSidecarText(ctx, cwd)) ?? {
-			version: 2,
-			updatedAt: "",
-			workspaces: {}
-		};
-		existing.workspaces[cwd] = {
-			at: Date.now(),
-			records: Object.fromEntries(recsMap)
-		};
-		existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		await fs.writeText(target, JSON.stringify(existing), void 0, void 0, policyOf(ctx, session));
+		db.exec(`CREATE TABLE active_records(call_id TEXT PRIMARY KEY, payload TEXT NOT NULL,
+      path TEXT NOT NULL, archived INTEGER NOT NULL, pending INTEGER NOT NULL, at TEXT NOT NULL);
+      CREATE INDEX active_by_path ON active_records(path,archived)`);
+		const add = db.prepare("INSERT INTO active_records(call_id,payload,path,archived,pending,at) VALUES(?,?,?,?,?,?)");
+		for (const rec of Object.values(recs)) add.run(rec.callId, JSON.stringify(rec), rec.path, rec.archived ? 1 : 0, rec.decisions?.perHunk?.filter((d) => d === "pending").length ?? 0, rec.at);
+		if (await confirm() !== source) throw new Error("迁移期间旧活跃 sidecar 被修改");
+		db.prepare("INSERT INTO metadata(name,value) VALUES('active_source',?)").run(digest);
+		db.prepare("UPDATE metadata SET value='3' WHERE name='schema'").run();
+		db.exec("COMMIT");
+		return new Map(Object.values(recs).map((rec) => [rec.callId, rec]));
 	} catch (error) {
-		log.error("saveBucket failed: " + String(error));
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
 	}
 }
 /**
-* 读取记录目标文件内容（按 path 缓存一次；缺失/过大/失败 → null/'' 占位）。
-* @author ddj 2026年08月20号
-* @param cache path → 内容（null=缺失/读取失败，''=过大跳过）
+* 判断已核验的工作区是否完成活跃表迁移，不写入工作区记录。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @returns 迁移完成返回 true
 */
-async function readForCache(ctx, session, cache, path) {
-	const cached = cache.get(path);
-	if (cached) return cached;
-	const fs = ctx.get("fs");
-	if (!fs) {
-		const state = { kind: "unavailable" };
+function activeReady(cwd) {
+	return dbFor(cwd).prepare("SELECT value FROM metadata WHERE name='schema'").get().value === "3";
+}
+/**
+* 对旧文件原文核对迁移标记，旧 Host 若继续写旧 sidecar 则拒绝启用新活跃库。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param source 当前遗留文件原文
+*/
+function checkActiveSource(cwd, source) {
+	const row = dbFor(cwd).prepare("SELECT value FROM metadata WHERE name='active_source'").get();
+	if (!row) throw new Error("活跃记录缺少迁移标记");
+	const digest = source === null ? "absent" : createHash("sha256").update(source).digest("hex");
+	if (row.value !== digest) throw new Error("旧活跃 sidecar 在迁移后发生变化，请停止操作并人工核对");
+}
+/**
+* 只读当前工作区活跃表；未迁移时禁止回退到空库。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @returns 完整有限记录桶
+*/
+function readActive(cwd) {
+	const db = dbFor(cwd);
+	if (db.prepare("SELECT value FROM metadata WHERE name='schema'").get().value !== "3") throw new Error("工作区活跃记录未迁移");
+	const recs = db.prepare("SELECT payload FROM active_records ORDER BY rowid").all().map((row) => JSON.parse(String(row.payload)));
+	return new Map(recs.map((rec) => [rec.callId, rec]));
+}
+/**
+* 单次 SQLite 事务提交活跃行变化及可选归档，绝不重写整个记录桶。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param changes 明确新增、更新和移除的记录
+* @param entries 可选本次归档批次
+* @returns 新增归档批次数
+*/
+function commitActive(cwd, changes, entries = []) {
+	const db = dbFor(cwd);
+	if (db.prepare("SELECT value FROM metadata WHERE name='schema'").get().value !== "3") throw new Error("工作区活跃记录未迁移");
+	const upsert = db.prepare(`INSERT INTO active_records(call_id,payload,path,archived,pending,at) VALUES(?,?,?,?,?,?)
+    ON CONFLICT(call_id) DO UPDATE SET payload=excluded.payload,path=excluded.path,
+      archived=excluded.archived,pending=excluded.pending,at=excluded.at`);
+	const remove = db.prepare("DELETE FROM active_records WHERE call_id=?");
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		const added = entries.length ? insertArchive(db, cwd, entries) : 0;
+		for (const rec of changes.upserts) {
+			const pending = rec.decisions?.perHunk?.filter((decision) => decision === "pending").length ?? 0;
+			upsert.run(rec.callId, JSON.stringify(rec), rec.path, rec.archived ? 1 : 0, pending, rec.at);
+		}
+		for (const callId of changes.removed) remove.run(callId);
+		db.exec("COMMIT");
+		return added;
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+}
+/**
+* 轻量活跃摘要；旧 JSON 保留为迁移前快照而不参与统计。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @returns 活跃条数和每文件待处理计数
+*/
+function activeSummary(cwd) {
+	const db = dbFor(cwd);
+	if (db.prepare("SELECT value FROM metadata WHERE name='schema'").get().value !== "3") throw new Error("工作区活跃记录未迁移");
+	return {
+		active: Number(db.prepare("SELECT count(*) AS n FROM active_records WHERE archived=0").get().n),
+		pendingByFile: db.prepare("SELECT path, sum(pending) AS pending FROM active_records WHERE archived=0 AND pending>0 GROUP BY path ORDER BY pending DESC").all().map((row) => ({
+			path: String(row.path),
+			pending: Number(row.pending)
+		}))
+	};
+}
+/**
+* 对一批同路径记录做事务内去重追加，返回成功插入的批次数。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param entries 已按旧语义构造的归档批次
+* @returns 新增批次数
+*/
+function appendArchive(cwd, entries) {
+	if (!entries.length) return 0;
+	const db = dbFor(cwd);
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		const added = insertArchive(db, cwd, entries);
+		db.exec("COMMIT");
+		return added;
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+}
+/**
+* 在调用方事务内追加归档批次；归档与活跃行可共用一次提交。
+* @author ddj 2026年09月30号
+* @param db 当前工作区连接
+* @param cwd 工作区
+* @param entries 待归档条目
+* @returns 新增批次数
+*/
+function insertArchive(db, cwd, entries) {
+	const get = db.prepare("SELECT id FROM batches WHERE cwd=? AND path=? AND batch_key=?");
+	const add = db.prepare("INSERT INTO batches(cwd,path,batch_key,batch,at,last_at,reason) VALUES(?,?,?,?,?,?,?)");
+	const update = db.prepare("UPDATE batches SET last_at=?, reason=? WHERE id=?");
+	const insert = db.prepare("INSERT OR IGNORE INTO records(batch_id,call_id,payload,accepted,rejected,pending,superseded) VALUES(?,?,?,?,?,?,?)");
+	const tally = db.prepare(`UPDATE batches SET n_records=n_records+1, accepted=accepted+?, rejected=rejected+?,
+    pending=pending+?, superseded=superseded+? WHERE id=?`);
+	let added = 0;
+	for (const entry of entries) {
+		if (entry.cwd !== cwd) throw new Error("归档批次工作区不匹配");
+		const key = batchKey(entry.batch);
+		const found = get.get(cwd, entry.path, key);
+		const id = found ? Number(found.id) : Number(add.run(cwd, entry.path, key, entry.batch, entry.at, entry.lastAt ?? null, entry.reason).lastInsertRowid);
+		if (found) update.run(entry.at, entry.reason, id);
+		else added++;
+		for (const record of entry.records) {
+			const sum = record.summary;
+			if (insert.run(id, record.callId, JSON.stringify(record), sum.accepted, sum.rejected, sum.pending, sum.superseded ? 1 : 0).changes) tally.run(sum.accepted, sum.rejected, sum.pending, sum.superseded ? 1 : 0, id);
+		}
+	}
+	const clear = db.prepare("DELETE FROM revert_intents WHERE call_id=?");
+	for (const entry of entries) for (const record of entry.records) clear.run(record.callId);
+	return added;
+}
+/**
+* 返回某工作区所有归档批次的轻量摘要，不取记录 JSON。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @returns 归档列表
+*/
+function listArchives(cwd) {
+	return dbFor(cwd).prepare(`SELECT path,batch,at,last_at,reason,n_records,accepted,rejected,pending,superseded
+    FROM batches WHERE cwd=? ORDER BY COALESCE(batch,-1) DESC, at DESC`).all(cwd).map((row) => ({
+		path: String(row.path),
+		batch: row.batch === null ? null : Number(row.batch),
+		at: String(row.at),
+		lastAt: String(row.last_at ?? row.at),
+		reason: row.reason === null ? null : String(row.reason),
+		nRecords: Number(row.n_records),
+		summary: {
+			accepted: Number(row.accepted),
+			rejected: Number(row.rejected),
+			pending: Number(row.pending),
+			superseded: Number(row.superseded)
+		}
+	}));
+}
+/**
+* 固定快照上界的 keyset 分页，新增批次不挤动后续页面。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param cursor 上页返回的不透明游标
+* @param limit 每页条数，缺省 50，最多 100
+* @returns 摘要页和下一页游标
+*/
+function pageArchives(cwd, cursor, limit = 50) {
+	if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new Error("归档分页大小不合法");
+	const db = dbFor(cwd);
+	const newest = Number(db.prepare("SELECT COALESCE(MAX(id),0) AS id FROM batches WHERE cwd=?").get(cwd).id);
+	let snapshot = newest;
+	let last = null;
+	if (cursor) try {
+		const value = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+		if (value.cwd !== cwd || !Number.isSafeInteger(value.snapshot) || value.snapshot < 0 || value.snapshot > newest || !Array.isArray(value.last) || value.last.length !== 3 || !Number.isSafeInteger(value.last[0]) || typeof value.last[1] !== "string" || !Number.isSafeInteger(value.last[2]) || value.last[2] > value.snapshot) throw new Error("invalid");
+		snapshot = value.snapshot;
+		last = value.last;
+	} catch {
+		throw new Error("归档分页游标无效");
+	}
+	const args = [cwd, snapshot];
+	let where = "WHERE cwd=? AND id<=?";
+	if (last) {
+		where += " AND (COALESCE(batch,-1),at,id) < (?,?,?)";
+		args.push(...last);
+	}
+	const rows = db.prepare(`SELECT id,path,batch,at,last_at,reason,n_records,accepted,rejected,pending,superseded
+    FROM batches ${where} ORDER BY COALESCE(batch,-1) DESC, at DESC, id DESC LIMIT ?`).all(...args, limit + 1);
+	const entries = rows.slice(0, limit).map((row) => ({
+		path: String(row.path),
+		batch: row.batch === null ? null : Number(row.batch),
+		at: String(row.at),
+		lastAt: String(row.last_at ?? row.at),
+		reason: row.reason === null ? null : String(row.reason),
+		nRecords: Number(row.n_records),
+		summary: {
+			accepted: Number(row.accepted),
+			rejected: Number(row.rejected),
+			pending: Number(row.pending),
+			superseded: Number(row.superseded)
+		}
+	}));
+	const tail = rows[limit - 1];
+	return {
+		entries,
+		nextCursor: rows.length > limit && tail ? Buffer.from(JSON.stringify({
+			cwd,
+			snapshot,
+			last: [
+				tail.batch === null ? -1 : Number(tail.batch),
+				tail.at,
+				tail.id
+			]
+		})).toString("base64url") : null
+	};
+}
+/**
+* 仅查询需要展开的路径/批次（无 path 时维持 RPC 返回全库语义）。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param path 可选目标路径
+* @param batch 可选批次
+* @returns 原有 ArchiveBatch 格式
+*/
+function readArchives(cwd, path, batch) {
+	const db = dbFor(cwd);
+	let where = "WHERE cwd=?";
+	const args = [cwd];
+	if (path) {
+		where += " AND path=?";
+		args.push(path);
+	}
+	if (batch !== void 0) {
+		where += " AND batch_key=?";
+		args.push(batchKey(batch));
+	}
+	const rows = db.prepare(`SELECT id,cwd,path,batch,at,last_at,reason FROM batches ${where} ORDER BY id`).all(...args);
+	const records = db.prepare("SELECT payload FROM records WHERE batch_id=? ORDER BY rowid");
+	return rows.map((row) => ({
+		cwd: String(row.cwd),
+		path: String(row.path),
+		batch: row.batch === null ? null : Number(row.batch),
+		at: String(row.at),
+		...row.last_at === null ? {} : { lastAt: String(row.last_at) },
+		reason: String(row.reason ?? ""),
+		records: records.all(row.id).map((record) => JSON.parse(String(record.payload)))
+	}));
+}
+/**
+* 查询已提交的归档记录，用于数据库成功但活跃 sidecar 写入失败后的幂等补偿。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param callId 调用标识
+* @param path 目标文件路径
+* @param batch 对应文件批次
+* @returns 已归档快照或 null
+*/
+function committedRecord(cwd, callId, path, batch) {
+	const row = dbFor(cwd).prepare(`SELECT r.payload FROM records r JOIN batches b ON b.id=r.batch_id
+    WHERE b.cwd=? AND b.path=? AND b.batch_key=? AND r.call_id=? LIMIT 1`).get(cwd, path, batchKey(batch), callId);
+	return row ? JSON.parse(String(row.payload)) : null;
+}
+/**
+* 查询一次 Undo 的持久化阶段；started 表示写入结果无法仅凭 sidecar 判断。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param callId 记录标识
+* @param scope 决策范围
+* @param hunkIndex 块索引（整调用为 -1）
+* @returns 阶段或 null
+*/
+function revertState(cwd, callId, scope, hunkIndex) {
+	const row = dbFor(cwd).prepare("SELECT state FROM revert_intents WHERE call_id=? AND scope=? AND hunk_index=?").get(callId, scope, hunkIndex);
+	return row ? String(row.state) : null;
+}
+/**
+* 持久化 Undo 阶段（started 在写文件前，applied 在写文件后）。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param callId 记录标识
+* @param scope 决策范围
+* @param hunkIndex 块索引
+* @param state 阶段
+*/
+function setRevertState(cwd, callId, scope, hunkIndex, state) {
+	dbFor(cwd).prepare(`INSERT INTO revert_intents(call_id,scope,hunk_index,state) VALUES(?,?,?,?)
+    ON CONFLICT(call_id,scope,hunk_index) DO UPDATE SET state=excluded.state`).run(callId, scope, hunkIndex, state);
+}
+/**
+* 一次事务登记同记录的所有批量 Undo 意图，登记不完整时不写任何文件。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param callId 记录标识
+* @param indices 块索引
+*/
+function startReverts(cwd, callId, indices) {
+	const db = dbFor(cwd);
+	const insert = db.prepare(`INSERT INTO revert_intents(call_id,scope,hunk_index,state) VALUES(?,'hunk',?,'started')`);
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		for (const index of indices) insert.run(callId, index);
+		db.exec("COMMIT");
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+}
+/**
+* 撤销尚未执行成功的 Undo 意图，保留成功写入后的阶段供补偿。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param callId 记录标识
+* @param scope 决策范围
+* @param hunkIndex 块索引
+*/
+function clearRevertState(cwd, callId, scope, hunkIndex) {
+	dbFor(cwd).prepare("DELETE FROM revert_intents WHERE call_id=? AND scope=? AND hunk_index=?").run(callId, scope, hunkIndex);
+}
+/**
+* 已执行但 sidecar 未更新的 Undo，从磁盘恢复决定而不重写文件。
+* @author ddj 2026年09月30号
+* @param cwd 工作区
+* @param record 活跃记录
+* @returns 是否应用了持久化决定
+*/
+function restoreReverts(cwd, record) {
+	const rows = dbFor(cwd).prepare("SELECT scope,hunk_index,state FROM revert_intents WHERE call_id=?").all(record.callId);
+	let changed = false;
+	for (const row of rows) {
+		if (row.state !== "applied") continue;
+		if (row.scope === "call") {
+			record.decisions.call = "rejected";
+			record.decisions.perHunk = record.decisions.perHunk.map(() => "rejected");
+		} else if (row.scope === "hunk" && Number(row.hunk_index) >= 0 && Number(row.hunk_index) < record.hunks.length) record.decisions.perHunk[Number(row.hunk_index)] = "rejected";
+		else continue;
+		changed = true;
+	}
+	return changed;
+}
+/**
+* 关闭所有工作区连接，供 Host 卸载以及测试释放 SQLite 句柄。
+* @author ddj 2026年09月30号
+*/
+function closeArchiveDbs() {
+	for (const db of connections.values()) db.close();
+	connections.clear();
+}
+//#endregion
+//#region src/store.ts
+const READ_CAP$1 = 8388608;
+/** 二进制预览/写回上限（PDF 等整文件 base64 传输；文本侧仍用 READ_CAP）。 */
+const BINARY_READ_CAP = 33554432;
+/** 旧文件首次全量指纹核验后，每次操作优先检查 DSH fs stat 身份。 */
+const sourceStats = /* @__PURE__ */ new Map();
+/** 会话沙箱策略（policyOf）：可能不存在，调用方需容忍 undefined。 */
+function policyOf(ctx, session) {
+	const svc = ctx.get("sandboxPolicy");
+	if (!svc) return void 0;
+	return session ? svc.resolve({ session }) : svc.resolve();
+}
+/** 按会话 cwd 解析目标路径。 */
+async function resolveTarget(ctx, session, path) {
+	const fs = ctx.get("fs");
+	const cwd = session?.header?.cwd;
+	return fs.resolve(path, cwd ? { cwd } : {});
+}
+/**
+* 严格读取旧 sidecar：仅确认确实不存在时才允许从空记录迁移。
+* @author ddj 2026年09月30号
+* @param ctx DSH 上下文
+* @param cwd 工作区
+* @returns 旧文件内容或确认缺失
+*/
+async function migrationText(ctx, cwd) {
+	const fs = ctx.get("fs");
+	if (!fs) throw new Error("无法迁移差异记录：缺少 fs");
+	const target = await fs.resolve(SIDECAR, { cwd });
+	const info = await fs.stat(target);
+	if (!info) return null;
+	if (info.type !== "file") throw new Error("旧活跃 sidecar 非文件");
+	return fs.readText(target);
+}
+/**
+* 读取旧 sidecar 文件的版本身份；缺少可靠版本令牌时返回 null 走全文核验。
+* @author ddj 2026年09月30号
+* @param ctx DSH 上下文
+* @param cwd 工作区
+* @returns 文件身份或 null
+*/
+async function sourceStat(ctx, cwd) {
+	const fs = ctx.get("fs");
+	if (!fs) throw new Error("无法核验旧 sidecar：缺少 fs");
+	const info = await fs.stat(await fs.resolve(SIDECAR, { cwd }));
+	if (!info) return "absent";
+	const version = info.version ?? info.rev;
+	return typeof version === "string" && version.length ? version : null;
+}
+/**
+* 首次读取旧文件全文确认数据库来源，后续只在 stat 版本变动时重新核验。
+* @author ddj 2026年09月30号
+* @param ctx DSH 上下文
+* @param cwd 工作区
+*/
+async function checkSource(ctx, cwd) {
+	const now = await sourceStat(ctx, cwd);
+	if (now !== null && sourceStats.get(cwd) === now) return;
+	checkActiveSource(cwd, await migrationText(ctx, cwd));
+	if (now !== null) sourceStats.set(cwd, now);
+}
+/** 加载某工作区的记录桶（内存 Map；首次在隔离切换窗口严格迁移）。 */
+async function loadBucket(ctx, cwd) {
+	const map = await migrateActive(cwd, await migrationText(ctx, cwd), () => migrationText(ctx, cwd));
+	await checkSource(ctx, cwd);
+	for (const rec of map.values()) {
+		if (rec.archived) continue;
+		const previous = JSON.stringify(rec);
+		restoreReverts(cwd, rec);
+		const committed = committedRecord(cwd, rec.callId, rec.path, rec.batch ?? null);
+		if (committed) {
+			rec.decisions = committed.decisions;
+			rec.superseded = committed.superseded;
+			rec.archived = true;
+		}
+		if (JSON.stringify(rec) !== previous) commitActive(cwd, {
+			upserts: [rec],
+			removed: []
+		});
+	}
+	return map;
+}
+/**
+* 仅把明确变动的记录行写入 SQLite；旧 sidecar 不再写入。
+* @author ddj 2026年09月30号
+* @param ctx DSH 上下文
+* @param cwd 工作区
+* @param recsMap 供当前调用点核对的记录桶
+* @param session 会话（保留旧 API）
+* @param changes 明确的更新和删除集合
+*/
+async function saveBucket(ctx, cwd, recsMap, session, changes) {
+	if (!changes) throw new Error("增量保存缺少变更集合");
+	for (const rec of changes.upserts) if (recsMap.get(rec.callId) !== rec) throw new Error("增量记录不在工作区桶内");
+	try {
+		await checkSource(ctx, cwd);
+		commitActive(cwd, changes);
+	} catch (error) {
+		log.error("saveBucket failed: " + String(error));
+		throw error;
+	}
+}
+/**
+* 读取记录目标文件内容（按 path 缓存一次；缺失/过大/失败 → null/'' 占位）。
+* @author ddj 2026年08月20号
+* @param cache path → 内容（null=缺失/读取失败，''=过大跳过）
+*/
+async function readForCache(ctx, session, cache, path) {
+	const cached = cache.get(path);
+	if (cached) return cached;
+	const fs = ctx.get("fs");
+	if (!fs) {
+		const state = { kind: "unavailable" };
 		cache.set(path, state);
 		return state;
 	}
@@ -4237,74 +4869,96 @@ async function autoArchiveStale(ctx, session, cwd, bucket) {
 		if (await recordIsStale(ctx, session, cache, rec)) stale.push(rec);
 	}
 	if (!stale.length) return 0;
+	const original = stale.map((rec) => ({
+		rec,
+		at: rec.at,
+		superseded: rec.superseded
+	}));
 	for (const r of stale) {
 		r.superseded = true;
 		r.at = (/* @__PURE__ */ new Date()).toISOString();
 	}
-	await archiveRecords(ctx, session, cwd, bucket, stale, "差异无法定位（已被后续修改覆盖），自动归档");
-	return stale.length;
-}
-/** 读取归档 sidecar 文本（缺失/失败 → null）。 */
-async function readArchiveText(ctx, cwd) {
-	const fs = ctx.get("fs");
-	if (!fs || !cwd) return null;
 	try {
-		return await fs.readText(await fs.resolve(SIDECAR_ARCHIVE, { cwd }));
+		await archiveRecords(ctx, session, cwd, bucket, stale, "差异无法定位（已被后续修改覆盖），自动归档");
 	} catch (error) {
-		return null;
+		for (const item of original) {
+			if (item.rec.archived) continue;
+			item.rec.superseded = item.superseded;
+			item.rec.at = item.at;
+		}
+		throw error;
 	}
+	return stale.length;
 }
-/** 解析归档 sidecar（损坏 → 空数组）。 */
-function parseArchive(text) {
-	if (!text) return [];
-	try {
-		const data = JSON.parse(text);
-		if (data && typeof data === "object" && Array.isArray(data.batches)) return data.batches;
-	} catch (error) {}
-	return [];
-}
-/** 追加归档条目（按 cwd+path+batch 合并，同 callId 去重）。 */
-async function appendArchiveEntries(ctx, cwd, entries, session) {
-	const fs = ctx.get("fs");
-	if (!fs || !cwd) return;
+/**
+* 追加归档条目（按 cwd+path+batch 合并，同 callId 去重）。
+* @author ddj 2026年09月30号
+* @param ctx DSH 上下文
+* @param cwd 工作区
+* @param entries 待归档批次
+* @param session 会话
+* @param traceId 可选诊断追踪标识；有值时输出分段耗时
+*/
+async function appendArchiveEntries(ctx, cwd, entries, session, traceId) {
+	if (!cwd || !entries.length) return;
+	const started = traceId ? performance.now() : 0;
 	try {
-		const target = await fs.resolve(SIDECAR_ARCHIVE, { cwd });
-		const existing = parseArchive(await readArchiveText(ctx, cwd));
-		for (const e of entries) {
-			const idx = existing.findIndex((x) => x.cwd === e.cwd && x.path === e.path && x.batch === e.batch);
-			if (idx >= 0) {
-				const exist = existing[idx];
-				const seen = new Set((exist.records || []).map((r) => r.callId));
-				for (const rec of e.records) if (!seen.has(String(rec.callId))) {
-					exist.records.push(rec);
-					seen.add(String(rec.callId));
-				}
-				exist.lastAt = e.at;
-				exist.reason = e.reason;
-			} else existing.push(e);
-		}
-		const data = {
-			version: 1,
-			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			batches: existing
-		};
-		await fs.writeText(target, JSON.stringify(data), void 0, void 0, policyOf(ctx, session));
+		await checkSource(ctx, cwd);
+		const added = appendArchive(cwd, entries);
+		try {
+			if (traceId) debugRecord(ctx, cwd, `[DEBUG diffArchive] trace=${traceId} stage=done mode=sqlite entries=${entries.length} insertedBatches=${added} dbMs=${(performance.now() - started).toFixed(1)} totalMs=${(performance.now() - started).toFixed(1)}`);
+		} catch {}
 	} catch (error) {
+		try {
+			if (traceId) debugRecord(ctx, cwd, `[DEBUG diffArchive] trace=${traceId} stage=error mode=sqlite totalMs=${(performance.now() - started).toFixed(1)}`);
+		} catch {}
 		log.error("appendArchiveEntries failed: " + String(error));
+		throw error;
 	}
 }
 /**
 * 归档记录：标记 archived、按批次写入归档、落盘工作区桶。
-* @param opts.deferSave 为 true 时只写归档、不落盘桶（由批量调用方统一 saveBucket 一次）
+* @author ddj 2026年09月30号
+* @param ctx DSH 上下文
+* @param session 会话
+* @param cwd 工作区
+* @param bucket 当前工作区记录桶
+* @param recs 待归档记录
+* @param reason 归档原因
+* @param opts deferSave 为 true 时只写归档、不落盘桶；traceId 用于可选分段计时
 */
 async function archiveRecords(ctx, session, cwd, bucket, recs, reason, opts) {
 	if (!recs.length) return;
 	const fresh = recs.filter((r) => !r.archived);
-	for (const r of recs) r.archived = true;
-	const entries = [];
-	for (const list of groupByBatch(recs).values()) entries.push(archiveEntryFor(list, cwd, reason));
-	await appendArchiveEntries(ctx, cwd, entries, session);
-	if (fresh.length && !opts?.deferSave) await saveBucket(ctx, cwd, bucket, session);
+	const byFile = /* @__PURE__ */ new Map();
+	for (const rec of recs) {
+		const key = JSON.stringify([rec.path, Number.isInteger(rec.batch) ? rec.batch : null]);
+		const list = byFile.get(key) ?? [];
+		list.push(rec);
+		byFile.set(key, list);
+	}
+	const entries = [...byFile.values()].map((list) => archiveEntryFor(list, cwd, reason));
+	const changed = new Map((opts?.changed ?? []).map((rec) => [rec.callId, rec]));
+	for (const rec of recs) changed.set(rec.callId, rec);
+	const start = opts?.traceId ? performance.now() : 0;
+	await checkSource(ctx, cwd);
+	const original = recs.map((rec) => rec.archived);
+	for (const rec of recs) rec.archived = true;
+	try {
+		const added = commitActive(cwd, {
+			upserts: [...changed.values()],
+			removed: []
+		}, entries);
+		try {
+			if (opts?.traceId) debugRecord(ctx, cwd, `[DEBUG diffArchive] trace=${opts.traceId} stage=done mode=sqlite entries=${entries.length} insertedBatches=${added} dbMs=${(performance.now() - start).toFixed(1)} totalMs=${(performance.now() - start).toFixed(1)}`);
+		} catch {}
+	} catch (error) {
+		recs.forEach((rec, idx) => {
+			rec.archived = original[idx];
+		});
+		throw error;
+	}
+	if (fresh.length && !opts?.deferSave) return;
 }
 //#endregion
 //#region src/httpGuard.ts
@@ -5480,10 +6134,21 @@ async function persistRecord(ctx, registry, session, cwd, record) {
 		bucket = await loadBucket(ctx, cwd);
 		registry.set(cwd, bucket);
 	}
+	const prior = new Map(bucket);
 	record.batch = fileMaxBatch(bucket, record.path) + 1;
 	bucket.set(record.callId, record);
 	prune(bucket);
-	await saveBucket(ctx, cwd, bucket, session);
+	const removed = [...prior.keys()].filter((callId) => !bucket.has(callId));
+	try {
+		await saveBucket(ctx, cwd, bucket, session, {
+			upserts: [record],
+			removed
+		});
+	} catch (error) {
+		bucket.clear();
+		for (const [callId, rec] of prior) bucket.set(callId, rec);
+		throw error;
+	}
 }
 /**
 * 捕获一次工具执行结果（tools/result）：edit/write/remote_ssh_write 成功时
@@ -6761,7 +7426,7 @@ async function revertCall(ctx, session, record) {
 	}
 }
 /** 单 hunk 回滚：用 callHunk（edit 单 hunk 精确串）经 fs.editText 反替换。 */
-async function revertHunk(ctx, session, record, idx) {
+async function revertHunk(ctx, session, record, idx, traceId) {
 	const fs = ctx.get("fs");
 	if (!fs) return {
 		ok: false,
@@ -6772,8 +7437,13 @@ async function revertHunk(ctx, session, record, idx) {
 		ok: false,
 		error: "找不到该差异块"
 	};
+	const started = traceId ? performance.now() : 0;
+	let readMs = 0;
+	let locateMs = 0;
+	let stage = "resolve";
 	try {
 		const target = await resolveTarget(ctx, session, record.path);
+		stage = "stat";
 		const info = await fs.stat(target);
 		if (!info || info.type !== "file") return {
 			ok: false,
@@ -6783,14 +7453,20 @@ async function revertHunk(ctx, session, record, idx) {
 			ok: false,
 			error: "回滚失败：文件过大，无法安全定位"
 		};
+		stage = "read";
 		const content = await fs.readText(target);
+		if (traceId) readMs = performance.now() - started;
+		const locateStart = traceId ? performance.now() : 0;
+		stage = "locate";
 		const location = locateHunks(content, [precise])[0];
+		if (traceId) locateMs = performance.now() - locateStart;
 		if (!location?.matched) return {
 			ok: false,
 			stale: true,
 			error: "回滚失败：该区域在文件中已不存在（可能已被后续修改覆盖）"
 		};
 		const result = applyLocations(content, [location], true);
+		stage = "write";
 		await fs.writeText(target, result.content, void 0, void 0, policyOf(ctx, session));
 		return { ok: true };
 	} catch (error) {
@@ -6798,6 +7474,88 @@ async function revertHunk(ctx, session, record, idx) {
 			ok: false,
 			error: "回滚失败：该区域可能已被后续修改影响（" + String(error) + "）"
 		};
+	} finally {
+		if (traceId) try {
+			debugRecord(ctx, session.header?.cwd ?? "", `[DEBUG diffRevert] trace=${traceId} mode=single stage=${stage} readMs=${readMs.toFixed(1)} locateMs=${locateMs.toFixed(1)} totalMs=${(performance.now() - started).toFixed(1)}`);
+		} catch {}
+	}
+}
+/**
+* 同一记录的连续 hunk 在内存里逐项回滚，只对文件读写各一次。
+* 不替代单条回滚；调用方只传确定同路径且非远端的连续项。
+* @author ddj 2026年09月29号
+* @param ctx DSH 上下文
+* @param session 会话
+* @param record 差异记录
+* @param indices 按决策顺序排列的 hunk 索引
+* @param traceId 可选的诊断追踪号，仅开启诊断时传入
+* @returns 每个 hunk 对应的独立执行结果
+*/
+async function revertHunks(ctx, session, record, indices, traceId) {
+	const fs = ctx.get("fs");
+	if (!fs) return indices.map(() => ({
+		ok: false,
+		error: "回滚不可用：缺少 fs"
+	}));
+	const failAll = (error) => indices.map((idx) => preciseHunk(record, idx) ? {
+		ok: false,
+		error
+	} : {
+		ok: false,
+		error: "找不到该差异块"
+	});
+	try {
+		const started = traceId ? performance.now() : 0;
+		const target = await resolveTarget(ctx, session, record.path);
+		const info = await fs.stat(target);
+		if (!info || info.type !== "file") return failAll("回滚失败：文件不存在");
+		if ((info.size ?? 0) > 8388608) return failAll("回滚失败：文件过大，无法安全定位");
+		let content = await fs.readText(target);
+		const readMs = traceId ? performance.now() - started : 0;
+		const locateStart = traceId ? performance.now() : 0;
+		let size = info.size ?? Buffer.byteLength(content);
+		const results = [];
+		for (const idx of indices) {
+			const hunk = preciseHunk(record, idx);
+			if (!hunk) {
+				results.push({
+					ok: false,
+					error: "找不到该差异块"
+				});
+				continue;
+			}
+			if (size > 8388608) {
+				results.push({
+					ok: false,
+					error: "回滚失败：文件过大，无法安全定位"
+				});
+				continue;
+			}
+			const location = locateHunks(content, [hunk])[0];
+			if (!location?.matched) {
+				results.push({
+					ok: false,
+					stale: true,
+					error: "回滚失败：该区域在文件中已不存在（可能已被后续修改覆盖）"
+				});
+				continue;
+			}
+			size += Buffer.byteLength(hunk.oldText ?? "") - Buffer.byteLength(content.slice(location.start, location.end));
+			content = applyLocations(content, [location], true).content;
+			results.push({ ok: true });
+		}
+		const locateMs = traceId ? performance.now() - locateStart : 0;
+		const writeStart = traceId ? performance.now() : 0;
+		if (results.some((result) => result.ok)) await fs.writeText(target, content, void 0, void 0, policyOf(ctx, session));
+		try {
+			if (traceId) {
+				const totalMs = performance.now() - started;
+				debugRecord(ctx, session.header?.cwd ?? "", `[DEBUG diffRevert] trace=${traceId} mode=batch hunks=${indices.length} bytes=${info.size ?? 0} readMs=${readMs.toFixed(1)} locateMs=${locateMs.toFixed(1)} writeMs=${(performance.now() - writeStart).toFixed(1)} totalMs=${totalMs.toFixed(1)}`);
+			}
+		} catch {}
+		return results;
+	} catch (error) {
+		return failAll("回滚失败：该区域可能已被后续修改影响（" + String(error) + "）");
 	}
 }
 /**
@@ -9386,166 +10144,16 @@ async function writeUiState(file, patch) {
 	});
 }
 //#endregion
-//#region src/debugLog.ts
+//#region src/perf.ts
 /**
-* dsh-vscode-mode host — 诊断文件通道（client 上报 → 缓冲批量落盘）+ 日志文件管理。
-* 通道：edrv.debug RPC → 内存缓冲（满/空闲触发）→ 串行读改写
-*       `~/.dsh/dsh-vscode-mode/logs/debug.<cwdHash>.log`（512KB 上限截断保留尾部）。
-* 设计：console 不一定落盘，文件可靠；写失败静默忽略（调试日志不阻塞业务）。
-* 管理：edrv.dlog.* RPC 用的清单/尾部读取/清空三能力；file 参数一律先过
-*       isDebugLogName 白名单（纯文件名、无路径分隔），杜绝穿越出日志根。
-* 作者 ddj 2026-09-08 / 2026-09-17
-*/
-/** cwd → 内存缓冲：行数组 + 累计字节数 + 待触发 flush 定时器（攒批落盘，避免每条日志全文件读改写）。 */
-const debugBuffers = /* @__PURE__ */ new Map();
-/** cwd → Promise 链：串行化 debug 日志落盘（fs read+write 非原子，避免并发丢行）。 */
-const debugWriteQueues = /* @__PURE__ */ new Map();
-/** debug 日志单文件上限：超限截断保留尾部，防文件无限增长拖慢每次追加。 */
-const DEBUG_LOG_CAP = 524288;
-/** debug 日志批量缓冲上限：攒满即落盘（一次读改写），上限内不逐条写文件。 */
-const DEBUG_BUF_CAP = 32768;
-/** debug 日志空闲 flush 延迟：缓冲未满时，静默一段时间后落盘一次。 */
-const DEBUG_FLUSH_IDLE_MS = 1e3;
-/** cwd → 已清理旧工作区 debug 日志标记（一次性）。 */
-const debugLegacyCleaned = /* @__PURE__ */ new Set();
-/** 诊断回显日志器（终端回显统一带 `[dsh-vscode-mode:debug]` 前缀，级别跟随上报级别）。 */
-const debugLog = log.child("debug");
-/** 诊断日志文件名白名单（cwd hash 命名；请求回传的 file 参数必须整名匹配，防路径穿越）。 */
-const DEBUG_LOG_NAME = /^debug\.[0-9a-f]{16}\.log$/;
-/**
-* 文件名是否为合法诊断日志名（白名单整名匹配，杜绝路径穿越）。
-* @author ddj 2026年09月17号
-* @param name 请求回传的文件名（可为空）
-* @returns 是否合法
-*/
-function isDebugLogName(name) {
-	return typeof name === "string" && DEBUG_LOG_NAME.test(name);
-}
-/**
-* 批量落盘一条 debug 日志缓冲：读旧文件 → 追加 → 超上限截断保留尾部 → 一次写回。
-* 串行链保证同一 cwd 的读改写不交错丢行；写失败静默忽略（调试日志不阻塞业务）。
-* @author ddj 2026年09月08号
-* @param cwd 工作区（日志落 ~/.dsh/dsh-vscode-mode/logs/debug.<cwdHash>.log）
-* @param batch 本批日志行
-*/
-function flushDebug(cwd, batch) {
-	const task = (debugWriteQueues.get(cwd) ?? Promise.resolve()).then(async () => {
-		try {
-			await mkdir(pluginLogRoot(), { recursive: true });
-			const target = debugLogFile(cwd);
-			const appended = await readFile(target, "utf8").catch(() => "") + batch.map((l) => (/* @__PURE__ */ new Date()).toISOString() + " " + l + "\n").join("");
-			const next = appended.length > DEBUG_LOG_CAP ? appended.slice(-Math.floor(DEBUG_LOG_CAP / 2)) : appended;
-			await writeFile(target, next, "utf8");
-			if (!debugLegacyCleaned.has(cwd)) {
-				debugLegacyCleaned.add(cwd);
-				await rm(join(cwd, DEBUG_LOG), { force: true }).catch(() => {});
-			}
-		} catch (e) {}
-	});
-	debugWriteQueues.set(cwd, task);
-	return task;
-}
-/**
-* 记录一条 client 上报的诊断日志：入队缓冲批量落盘 + 终端回显（级别跟随，缺省 debug）。
-* 落盘行格式 `<iso> [level] text`；级别标记在入队时补齐，flush 侧无感。
-* @author ddj 2026年09月08号 / 2026年09月17号
-* @param _ctx DSH 上下文（入参保留：诊断通道按 cwd 隔离，当前不需要 ctx，未来过滤用）
-* @param cwd 工作区（日志文件按 cwd hash 隔离）
-* @param text 单条日志文本（不含换行）
-* @param level 日志级别（缺省 debug；落盘行与终端回显均带此级别）
-*/
-function debugRecord(_ctx, cwd, text, level = "debug") {
-	const tagged = "[" + level + "] " + text;
-	const st = debugBuffers.get(cwd) ?? {
-		lines: [],
-		len: 0,
-		timer: null
-	};
-	st.lines.push(tagged);
-	st.len += tagged.length;
-	const flush = () => {
-		st.timer = null;
-		const batch = st.lines;
-		st.lines = [];
-		st.len = 0;
-		flushDebug(cwd, batch);
-	};
-	if (st.len >= DEBUG_BUF_CAP) {
-		if (st.timer) clearTimeout(st.timer);
-		flush();
-	} else if (!st.timer) st.timer = setTimeout(flush, DEBUG_FLUSH_IDLE_MS);
-	debugBuffers.set(cwd, st);
-	debugLog[level](text);
-}
-/**
-* 清单：日志根下全部诊断日志文件（名字/字节/mtime；非法名跳过），mtime 新的在前。
-* @author ddj 2026年09月17号
-* @param home DSH home（测试可注入；缺省按环境解析）
-* @returns 清单项数组
-*/
-async function listDebugLogs(home = dshHome()) {
-	const names = await readdir(pluginLogRoot(home)).catch(() => []);
-	const items = [];
-	for (const name of names) {
-		if (!isDebugLogName(name)) continue;
-		const info = await stat(join(pluginLogRoot(home), name)).catch(() => null);
-		if (!info?.isFile()) continue;
-		items.push({
-			name,
-			bytes: info.size,
-			mtimeMs: info.mtimeMs
-		});
-	}
-	items.sort((a, b) => b.mtimeMs - a.mtimeMs);
-	return items;
-}
-/**
-* 尾部读取一份诊断日志：保留文件尾 maxBytes 字节（缺省 256KB），truncated 标记截头。
-* 单文件本体受 DEBUG_LOG_CAP=512KB 约束，整读为字符串的成本可接受。
-* @author ddj 2026年09月17号
-* @param name 日志文件名（isDebugLogName 白名单校验，非法直接 null）
-* @param maxBytes 尾部保留字节数（缺省 256KB）
-* @param home DSH home（测试可注入）
-* @returns 读取结果；文件不存在或名字非法返回 null
-*/
-async function readDebugLog(name, maxBytes = 262144, home = dshHome()) {
-	if (!isDebugLogName(name)) return null;
-	const target = join(pluginLogRoot(home), name);
-	const info = await stat(target).catch(() => null);
-	if (!info?.isFile()) return null;
-	const text = await readFile(target, "utf8").catch(() => null);
-	if (text === null) return null;
-	const cut = Math.max(0, text.length - maxBytes);
-	return {
-		name,
-		path: target,
-		content: cut > 0 ? text.slice(cut) : text,
-		size: info.size,
-		truncated: cut > 0
-	};
-}
-/**
-* 清空一份诊断日志（truncate 到 0，保留文件本身）。
-* @author ddj 2026年09月17号
-* @param name 日志文件名（isDebugLogName 白名单校验）
-* @param home DSH home（测试可注入）
-* @returns 是否清空成功（文件不存在视为未成功，文案由调用方给）
-*/
-async function clearDebugLog(name, home = dshHome()) {
-	if (!isDebugLogName(name)) return false;
-	return await truncate(join(pluginLogRoot(home), name)).then(() => true).catch(() => false);
-}
-//#endregion
-//#region src/perf.ts
-/**
-* dsh-vscode-mode host — DSH 会话性能管理（会话卫生 + 体积 stat + 侧车摘要）。
-* 职责：
-* - 盘点 ~/.dsh/sessions 全部工作区会话（每会话仅 stat 日志文件，不解压，轻量）；
-* - 移出/恢复/清除：会话目录在 ~/.dsh/sessions 与 ~/.dsh/sessions-archive 间可逆搬迁；
-* - 当前会话体积 stat（对话头部指示器用，纯 stat）；
-* - 侧车摘要：agent/脚本取关键字段，避免整份读 .dsh-edit-review.json 进对话。
-* 纯函数可单测（路径编码/移出规划）；fs 操作 best-effort 返回逐项结果不抛。
-* 作者 ddj 2026-09-02
+* dsh-vscode-mode host — DSH 会话性能管理（会话卫生 + 体积 stat + 侧车摘要）。
+* 职责：
+* - 盘点 ~/.dsh/sessions 全部工作区会话（每会话仅 stat 日志文件，不解压，轻量）；
+* - 移出/恢复/清除：会话目录在 ~/.dsh/sessions 与 ~/.dsh/sessions-archive 间可逆搬迁；
+* - 当前会话体积 stat（对话头部指示器用，纯 stat）；
+* - 侧车摘要：agent/脚本取关键字段，避免整份读 .dsh-edit-review.json 进对话。
+* 纯函数可单测（路径编码/移出规划）；fs 操作 best-effort 返回逐项结果不抛。
+* 作者 ddj 2026-09-02
 */
 /** 会话日志文件名（zstd 优先，降级纯 jsonl）。 */
 const LOG_NAMES = ["session.jsonl.zstd", "session.jsonl"];
@@ -9940,30 +10548,28 @@ async function sidecarSummaryOf(ctx, cwd) {
 	const summary = {
 		active: 0,
 		pendingByFile: [],
-		archiveBytes: 0
+		archiveBytes: 0,
+		legacyArchiveBytes: 0,
+		legacyActiveBytes: 0
 	};
 	if (!fs || !cwd) return summary;
+	const current = activeSummary(cwd);
+	summary.active = current.active;
+	summary.pendingByFile = current.pendingByFile;
 	try {
-		const recs = parseSidecar(await fs.readText(await fs.resolve(SIDECAR, { cwd })))?.workspaces?.[cwd]?.records;
-		if (recs) {
-			const byFile = /* @__PURE__ */ new Map();
-			let active = 0;
-			for (const rec of Object.values(recs)) {
-				if (rec.archived) continue;
-				active += 1;
-				const sm = recSummary(rec);
-				if (sm.pending > 0 && rec.path) byFile.set(rec.path, (byFile.get(rec.path) ?? 0) + sm.pending);
-			}
-			summary.active = active;
-			summary.pendingByFile = [...byFile.entries()].map(([path, pending]) => ({
-				path,
-				pending
-			})).sort((a, b) => b.pending - a.pending);
-		}
-		try {
-			summary.archiveBytes = (await fs.stat(await fs.resolve(".dsh-edit-review-archive.json", { cwd })))?.size ?? 0;
-		} catch (error) {}
-	} catch (error) {}
+		summary.legacyArchiveBytes = (await fs.stat(await fs.resolve(".dsh-edit-review-archive.json", { cwd })))?.size ?? 0;
+	} catch {}
+	try {
+		summary.legacyActiveBytes = (await fs.stat(await fs.resolve(".dsh-edit-review.json", { cwd })))?.size ?? 0;
+	} catch {}
+	const dbPath = archiveDbFile(cwd);
+	for (const file of [
+		dbPath,
+		dbPath + "-wal",
+		dbPath + "-shm"
+	]) try {
+		summary.archiveBytes += (await stat(file)).size;
+	} catch {}
 	return summary;
 }
 /** 解析归档 manifest（损坏/缺失 → 空）。 */
@@ -10102,6 +10708,8 @@ function settingsDocPath(configuredPath, requestedPath, platform = process.platf
 const staleCheckedAt = /* @__PURE__ */ new Map();
 /** stale 自动清理最小间隔。 */
 const STALE_CHECK_MIN_MS = 1e4;
+/** 诊断由 client 的 edrv.debug 激活，过期后不再产生 Host 耗时日志。 */
+const diffTraceUntil = /* @__PURE__ */ new Map();
 /**
 * 无会话期诊断的伪 cwd：冷启动早期本插件客户端就会上报界面状态镜像事件
 * （此时 `sessions` 可能尚未就绪，`requireSession` 会失败），退回本固定值落盘
@@ -10256,7 +10864,10 @@ async function afterManualSave(ctx, registry, sc, path) {
 		const done = [];
 		for (const rec of bucket.values()) if (rec.path === path && rec.superseded) done.push(rec);
 		if (done.length) await archiveRecords(ctx, sc.session, sc.cwd, bucket, done, "被手动编辑覆盖");
-		else await saveBucket(ctx, sc.cwd, bucket, sc.session);
+		else await saveBucket(ctx, sc.cwd, bucket, sc.session, {
+			upserts: [...bucket.values()].filter((rec) => rec.path === path),
+			removed: []
+		});
 	}
 }
 /**
@@ -10271,9 +10882,17 @@ async function afterManualSave(ctx, registry, sc, path) {
 async function applyDecisions(ctx, session, cwd, bucket, items) {
 	const results = [];
 	const resolved = [];
+	const touched = /* @__PURE__ */ new Map();
 	const ws = findRemoteWs(cwd);
 	let changed = false;
-	for (const item of items) {
+	const grouped = /* @__PURE__ */ new Map();
+	const trace = diffTraceUntil.get(cwd);
+	const traceId = trace && trace.until > Date.now() ? trace.id : null;
+	const started = traceId ? performance.now() : 0;
+	let revertMs = 0;
+	let revertGroups = 0;
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index];
 		const record = bucket.get(item.callId);
 		if (!record) {
 			results.push({
@@ -10283,10 +10902,100 @@ async function applyDecisions(ctx, session, cwd, bucket, items) {
 			});
 			continue;
 		}
+		if (record.archived) {
+			results.push({
+				callId: item.callId,
+				ok: false,
+				error: "记录已归档，无法重复决策"
+			});
+			continue;
+		}
+		const alreadyDone = (item.scope === "hunk" ? record.decisions.perHunk[item.hunkIndex ?? -1] : record.decisions.call) === item.decision;
+		if (alreadyDone) {
+			if (recordResolved(record) && !record.archived) resolved.push(record);
+			changed = true;
+			touched.set(record.callId, record);
+			results.push({
+				callId: item.callId,
+				ok: true,
+				record: recView(record, ws)
+			});
+			continue;
+		}
 		let revertedStale = false;
-		if (item.decision === "rejected") {
+		if (item.decision === "rejected" && !alreadyDone) {
 			const scope = item.scope ?? "call";
-			const outcome = scope === "hunk" ? await revertHunk(ctx, session, record, item.hunkIndex ?? -1) : await revertCall(ctx, session, record);
+			const hunkIndex = scope === "hunk" ? item.hunkIndex ?? -1 : -1;
+			let existingIntent;
+			try {
+				existingIntent = grouped.has(index) ? null : revertState(cwd, record.callId, scope, hunkIndex);
+			} catch (error) {
+				results.push({
+					callId: item.callId,
+					ok: false,
+					error: "回滚状态读取失败，未修改文件：" + String(error)
+				});
+				continue;
+			}
+			if (existingIntent === "started") {
+				results.push({
+					callId: item.callId,
+					ok: false,
+					error: "回滚结果不确定，请人工核对文件后处理；已阻止再次修改文件"
+				});
+				continue;
+			}
+			if (existingIntent === "applied") {
+				markDecision(record, scope, item.hunkIndex, item.decision);
+				changed = true;
+				touched.set(record.callId, record);
+				if (recordResolved(record)) resolved.push(record);
+				results.push({
+					callId: item.callId,
+					ok: true,
+					record: recView(record, ws)
+				});
+				continue;
+			}
+			if (!grouped.has(index)) {
+				let last = index + 1;
+				if (scope === "hunk" && !ws && record.toolName !== "remote_ssh_write") while (last < items.length && items[last].callId === item.callId && items[last].decision === "rejected" && items[last].scope === "hunk") last++;
+				let groupReady = false;
+				try {
+					groupReady = last > index + 1 && items.slice(index + 1, last).every((next) => revertState(cwd, record.callId, "hunk", next.hunkIndex ?? -1) === null);
+					if (groupReady) startReverts(cwd, record.callId, items.slice(index, last).map((next) => next.hunkIndex ?? -1));
+					else setRevertState(cwd, record.callId, scope, hunkIndex, "started");
+				} catch (error) {
+					results.push({
+						callId: item.callId,
+						ok: false,
+						error: "回滚状态无法登记，未修改文件：" + String(error)
+					});
+					continue;
+				}
+				if (groupReady) {
+					const revertStart = traceId ? performance.now() : 0;
+					const outcomes = await revertHunks(ctx, session, record, items.slice(index, last).map((next) => next.hunkIndex ?? -1), traceId ?? void 0);
+					if (traceId) revertMs += performance.now() - revertStart;
+					revertGroups++;
+					outcomes.forEach((outcome, offset) => grouped.set(index + offset, outcome));
+				}
+			}
+			const revertStart = traceId ? performance.now() : 0;
+			const outcome = grouped.get(index) ?? (scope === "hunk" ? await revertHunk(ctx, session, record, item.hunkIndex ?? -1, traceId ?? void 0) : await revertCall(ctx, session, record));
+			if (traceId && !grouped.has(index)) revertMs += performance.now() - revertStart;
+			grouped.delete(index);
+			try {
+				if (outcome.ok || outcome.stale === true) setRevertState(cwd, record.callId, scope, hunkIndex, "applied");
+				else if (outcome.error === "找不到该差异块" || outcome.error === "回滚失败：文件不存在" || outcome.error === "回滚失败：文件过大，无法安全定位") clearRevertState(cwd, record.callId, scope, hunkIndex);
+			} catch (error) {
+				results.push({
+					callId: item.callId,
+					ok: false,
+					error: "回滚状态保存失败，请人工核对文件：" + String(error)
+				});
+				continue;
+			}
 			if (!outcome.ok) {
 				if (scope !== "hunk" || outcome.stale !== true) {
 					results.push({
@@ -10302,6 +11011,7 @@ async function applyDecisions(ctx, session, cwd, bucket, items) {
 		const wasResolved = recordResolved(record);
 		markDecision(record, item.scope ?? "call", item.hunkIndex, item.decision);
 		changed = true;
+		touched.set(record.callId, record);
 		if (!wasResolved && recordResolved(record)) resolved.push(record);
 		const result = {
 			callId: item.callId,
@@ -10311,8 +11021,58 @@ async function applyDecisions(ctx, session, cwd, bucket, items) {
 		if (revertedStale) result.stale = true;
 		results.push(result);
 	}
-	if (resolved.length) await archiveRecords(ctx, session, cwd, bucket, resolved, items.some((item) => item.decision === "rejected") ? "已处理（回滚）" : "已处理", { deferSave: true });
-	if (changed) await saveBucket(ctx, cwd, bucket, session);
+	const decisionMs = traceId ? performance.now() - started : 0;
+	const archiveStart = traceId ? performance.now() : 0;
+	if (resolved.length) {
+		const reason = items.some((item) => item.decision === "rejected") ? "已处理（回滚）" : "已处理";
+		try {
+			await archiveRecords(ctx, session, cwd, bucket, resolved, reason, {
+				deferSave: true,
+				traceId: traceId ?? void 0,
+				changed: [...touched.values()]
+			});
+		} catch (error) {
+			const failed = new Set(resolved.map((record) => record.callId));
+			for (const result of results) {
+				if (!failed.has(result.callId) || !result.ok) continue;
+				result.ok = false;
+				result.error = "归档失败：" + String(error);
+				delete result.record;
+			}
+			if (changed) try {
+				await saveBucket(ctx, cwd, bucket, session, {
+					upserts: [...touched.values()],
+					removed: []
+				});
+			} catch (saveError) {
+				log.error("归档失败后的 SQLite 补写失败：" + String(saveError));
+			}
+			return results;
+		}
+	}
+	const archiveMs = traceId ? performance.now() - archiveStart : 0;
+	const saveStart = traceId ? performance.now() : 0;
+	if (changed && !resolved.length) try {
+		await saveBucket(ctx, cwd, bucket, session, {
+			upserts: [...touched.values()],
+			removed: []
+		});
+	} catch (error) {
+		for (const result of results) {
+			if (!result.ok) continue;
+			result.ok = false;
+			result.error = "决策记录保存失败：" + String(error);
+			delete result.record;
+		}
+		return results;
+	}
+	try {
+		if (traceId) {
+			const saveMs = performance.now() - saveStart;
+			const totalMs = performance.now() - started;
+			debugRecord(ctx, cwd, `[DEBUG diffDecision] trace=${traceId} items=${items.length} rejected=${items.filter((item) => item.decision === "rejected").length} ok=${results.filter((result) => result.ok).length} stale=${results.filter((result) => result.stale === true).length} grouped=${revertGroups} loopMs=${decisionMs.toFixed(1)} revertMs=${revertMs.toFixed(1)} archiveMs=${archiveMs.toFixed(1)} saveMs=${saveMs.toFixed(1)} totalMs=${totalMs.toFixed(1)}`);
+		}
+	} catch {}
 	return results;
 }
 /** 当前活跃会话 id 集合（live sessions，用于移出/恢复护栏）。 */
@@ -10446,18 +11206,25 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 		...svnHandlers ?? {},
 		...dapHandlers ?? {},
 		"edrv.list": async (args) => {
+			const start = performance.now();
+			let staleMs = 0;
+			let staleChecked = false;
 			const sc = await requireSession(ctx, args.sessionId);
 			if ("err" in sc) return {
 				ok: false,
 				error: sc.err
 			};
 			const bucket = await bucketOf(registry, ctx, sc.cwd);
+			const loadMs = performance.now() - start;
 			const want = Array.isArray(args.callIds) ? new Set(args.callIds) : null;
 			if (!want && args.skipStale !== true) {
 				const now = Date.now();
 				if (now - (staleCheckedAt.get(sc.cwd) ?? 0) > STALE_CHECK_MIN_MS) {
 					staleCheckedAt.set(sc.cwd, now);
+					staleChecked = true;
+					const staleStart = performance.now();
 					await autoArchiveStale(ctx, sc.session, sc.cwd, bucket);
+					staleMs = performance.now() - staleStart;
 				}
 			}
 			const out = [];
@@ -10468,6 +11235,11 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				out.push(recView(rec, ws));
 			}
 			out.sort((a, b) => a.at < b.at ? -1 : 1);
+			try {
+				const totalMs = performance.now() - start;
+				const trace = diffTraceUntil.get(sc.cwd);
+				if (trace && trace.until > Date.now() && (totalMs >= 20 || staleMs >= 10)) debugRecord(ctx, sc.cwd, `[DEBUG diffListHost] trace=${trace.id} count=${out.length} bucket=${bucket.size} checked=${staleChecked} loadMs=${loadMs.toFixed(1)} staleMs=${staleMs.toFixed(1)} totalMs=${totalMs.toFixed(1)}`);
+			} catch {}
 			return {
 				ok: true,
 				records: out
@@ -10898,44 +11670,45 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				ok: false,
 				error: sc.err
 			};
-			const batches = parseArchive(await readArchiveText(ctx, sc.cwd)).filter((b) => b.cwd === sc.cwd);
-			const ws = findRemoteWs(sc.cwd);
-			const entries = batches.map((b) => {
-				const recs = Array.isArray(b.records) ? b.records : [];
-				const sum = recs.reduce((s, r) => {
-					const sm = r.summary || {
-						accepted: 0,
-						rejected: 0,
-						pending: 0,
-						superseded: false
-					};
-					s.accepted += sm.accepted || 0;
-					s.rejected += sm.rejected || 0;
-					s.pending += sm.pending || 0;
-					if (sm.superseded) s.superseded++;
-					return s;
-				}, {
-					accepted: 0,
-					rejected: 0,
-					pending: 0,
-					superseded: 0
-				});
+			try {
+				const ws = findRemoteWs(sc.cwd);
 				return {
-					at: b.at,
-					lastAt: b.lastAt || b.at,
-					path: b.path,
-					...ws ? { displayPath: remoteDisplayOf(b.path, ws) ?? void 0 } : {},
-					batch: b.batch ?? null,
-					reason: b.reason ?? null,
-					nRecords: recs.length,
-					summary: sum
+					ok: true,
+					entries: listArchives(sc.cwd).map((item) => ({
+						...item,
+						...ws ? { displayPath: remoteDisplayOf(item.path, ws) ?? void 0 } : {}
+					}))
 				};
-			});
-			entries.sort((a, b) => Number(b.batch ?? -1) - Number(a.batch ?? -1) || (a.at < b.at ? 1 : -1));
-			return {
-				ok: true,
-				entries
+			} catch (error) {
+				return {
+					ok: false,
+					error: "归档列表读取失败：" + String(error)
+				};
+			}
+		},
+		"edrv.archivePage": async (args) => {
+			const sc = await requireSession(ctx, args.sessionId);
+			if ("err" in sc) return {
+				ok: false,
+				error: sc.err
 			};
+			try {
+				const ws = findRemoteWs(sc.cwd);
+				const page = pageArchives(sc.cwd, args.cursor, args.limit);
+				return {
+					ok: true,
+					entries: page.entries.map((item) => ({
+						...item,
+						...ws ? { displayPath: remoteDisplayOf(item.path, ws) ?? void 0 } : {}
+					})),
+					nextCursor: page.nextCursor
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "归档分页读取失败：" + String(error)
+				};
+			}
 		},
 		"edrv.archiveRead": async (args) => {
 			const sc = await requireSession(ctx, args.sessionId);
@@ -10943,11 +11716,21 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				ok: false,
 				error: sc.err
 			};
-			const batchPath = args.path;
-			return {
-				ok: true,
-				batches: parseArchive(await readArchiveText(ctx, sc.cwd)).filter((b) => b.cwd === sc.cwd && (!batchPath || b.path === batchPath))
-			};
+			try {
+				if (args.batch !== void 0 && (!args.path || args.batch !== null && !Number.isInteger(args.batch))) return {
+					ok: false,
+					error: "归档批次参数无效"
+				};
+				return {
+					ok: true,
+					batches: readArchives(sc.cwd, args.path, args.batch)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: "归档详情读取失败：" + String(error)
+				};
+			}
 		},
 		"edrv.rollback": async (args) => {
 			const sc = await requireSession(ctx, args.sessionId);
@@ -10961,47 +11744,54 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 			};
 			const batch = args.batch;
 			const bucket = await bucketOf(registry, ctx, sc.cwd);
-			let affected = [];
-			let beforeRec = null;
-			if (batch !== void 0) {
-				const all = parseArchive(await readArchiveText(ctx, sc.cwd)).filter((b) => b.cwd === sc.cwd && b.path === args.path);
-				const recs = [];
-				for (const b of all) if (b.batch === batch) for (const r of b.records || []) recs.push(r);
-				if (!recs.length) return {
+			try {
+				let affected = [];
+				let beforeRec = null;
+				if (batch !== void 0) {
+					const all = readArchives(sc.cwd, args.path, batch);
+					const recs = [];
+					for (const b of all) if (b.batch === batch) for (const r of b.records || []) recs.push(r);
+					if (!recs.length) return {
+						ok: false,
+						error: "归档中找不到该批次"
+					};
+					recs.sort((a, b2) => a.at < b2.at ? -1 : 1);
+					beforeRec = recs[0];
+					affected = recs;
+				} else {
+					for (const r of bucket.values()) if (r.path === args.path && !r.archived) affected.push(r);
+					if (!affected.length) return {
+						ok: false,
+						error: "该文件没有可回滚的差异"
+					};
+					affected.sort((a, b2) => a.at < b2.at ? -1 : 1);
+					beforeRec = affected[0];
+				}
+				const rerr = await restoreFile(ctx, sc.session, beforeRec);
+				if (rerr) return {
 					ok: false,
-					error: "归档中找不到该批次"
+					error: rerr
 				};
-				recs.sort((a, b2) => a.at < b2.at ? -1 : 1);
-				beforeRec = recs[0];
-				affected = recs;
-			} else {
-				for (const r of bucket.values()) if (r.path === args.path && !r.archived) affected.push(r);
-				if (!affected.length) return {
+				if (batch === void 0) await archiveRecords(ctx, sc.session, sc.cwd, bucket, affected, "已回滚");
+				else {
+					const sumRecs = readArchives(sc.cwd, args.path, batch).reduce((s, b) => s + (b.records || []).length, 0);
+					const logRec = Object.assign({}, affected[0], { note: (affected[0].note ? affected[0].note + "；" : "") + "回滚至本批次前（批次 " + batch + "）" });
+					await appendArchiveEntries(ctx, sc.cwd, [archiveEntryFor([logRec], sc.cwd, "已回滚（批次 " + batch + "，" + sumRecs + " 条）")], sc.session);
+					const activeRecs = [];
+					for (const r of bucket.values()) if (r.path === args.path && !r.archived) activeRecs.push(r);
+					if (activeRecs.length) await archiveRecords(ctx, sc.session, sc.cwd, bucket, activeRecs, "已回滚（批次回滚覆盖）");
+				}
+				return {
+					ok: true,
+					path: args.path,
+					batch: batch ?? null
+				};
+			} catch (error) {
+				return {
 					ok: false,
-					error: "该文件没有可回滚的差异"
+					error: "回滚/归档失败：" + String(error)
 				};
-				affected.sort((a, b2) => a.at < b2.at ? -1 : 1);
-				beforeRec = affected[0];
 			}
-			const rerr = await restoreFile(ctx, sc.session, beforeRec);
-			if (rerr) return {
-				ok: false,
-				error: rerr
-			};
-			if (batch === void 0) await archiveRecords(ctx, sc.session, sc.cwd, bucket, affected, "已回滚");
-			else {
-				const sumRecs = parseArchive(await readArchiveText(ctx, sc.cwd)).filter((b) => b.cwd === sc.cwd && b.path === args.path && b.batch === batch).reduce((s, b) => s + (b.records || []).length, 0);
-				const logRec = Object.assign({}, affected[0], { note: (affected[0].note ? affected[0].note + "；" : "") + "回滚至本批次前（批次 " + batch + "）" });
-				await appendArchiveEntries(ctx, sc.cwd, [archiveEntryFor([logRec], sc.cwd, "已回滚（批次 " + batch + "，" + sumRecs + " 条）")], sc.session);
-				const activeRecs = [];
-				for (const r of bucket.values()) if (r.path === args.path && !r.archived) activeRecs.push(r);
-				if (activeRecs.length) await archiveRecords(ctx, sc.session, sc.cwd, bucket, activeRecs, "已回滚（批次回滚覆盖）");
-			}
-			return {
-				ok: true,
-				path: args.path,
-				batch: batch ?? null
-			};
 		},
 		"edrv.debug": async (args) => {
 			const text = String(args.text ?? "");
@@ -11010,6 +11800,13 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				debugRecord(ctx, UI_AUDIT_CWD, text, args.level);
 				return { ok: true };
 			}
+			try {
+				const match = /^\[DEBUG diffAction\] stage=start trace=(\d+-\d+) /.exec(text);
+				if (match) diffTraceUntil.set(sc.cwd, {
+					until: Date.now() + 15e3,
+					id: match[1]
+				});
+			} catch {}
 			debugRecord(ctx, sc.cwd, text, args.level);
 			return { ok: true };
 		},
@@ -21162,6 +21959,7 @@ function attachRuntime(ctx, runtime) {
 	/** @author ddj 2026年09月28号 Release every manager even if another cleanup rejects. */
 	async function cleanup() {
 		runtime.fileVersions.dispose();
+		closeArchiveDbs();
 		disposeAllServers();
 		await Promise.allSettled([
 			() => runtime.lspManager.disposeAll(),