dsh-vscode-mode 0.25.1 → 0.27.0

package/lib/index.js

@@ -2445,6 +2445,568 @@ function closeArchiveDbs() {
 	connections.clear();
 }
 //#endregion
+//#region src/shared/pathKey.ts
+/**
+* 路径比较口径：Host 与客户端共用同一套「远端 / 盘符 / 相对路径」判定，只在平台折叠上分工。
+* @author ddj 2026年10月30号
+*/
+/** 远端仓库身份：`scheme://...` 区分大小写，绝不能折叠。 */
+const REMOTE = /^[a-z]+:\/\//i;
+/** 盘符绝对路径：大小写不敏感与宿主平台无关，两边都必须折叠。 */
+const DRIVE = /^[a-z]:\//i;
+/**
+* @author ddj 2026年10月30号
+* @description: 统一分隔符为 `/`，其余字符原样保留。
+* @param path 原始路径
+* @returns 反斜杠已归一化的路径
+*/
+function unifiedPath(path) {
+	return path.replace(/\\/g, "/");
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 生成路径比较键。盘符路径恒折叠大小写；其余路径是否折叠由调用方按运行平台决定
+* （Host 在 Windows 上折叠，客户端不在宿主进程里，取 false）。
+* @param path 原始路径
+* @param foldCase 非盘符路径是否折叠大小写
+* @returns 比较键
+*/
+function pathKeyFor(path, foldCase) {
+	const unified = unifiedPath(path);
+	if (REMOTE.test(unified)) return unified;
+	if (DRIVE.test(unified)) return unified.toLowerCase();
+	return foldCase ? unified.toLowerCase() : unified;
+}
+//#endregion
+//#region src/shared/pendingReview.ts
+/** 待审条目在面板列表里的 id 前缀；客户端与 Host 共用这一份口径。 */
+const PENDING_PREFIX = "pending:";
+//#endregion
+//#region src/pendingCompat.ts
+/**
+* 进程内"已被待审接管"的路径集合；旧写入口守卫只读它，绝不碰数据库。
+* 按工作区登记，来源会话仅作追溯；任一对话重建或注销都会更新同一份集合。
+*/
+const coveredWorkspace = /* @__PURE__ */ new Map();
+/**
+* @author ddj 2026年10月29号
+* @description: 由条目 id 派生稳定序号，保证轮询期间面板锚点不跳。
+* @param id 待审条目身份
+* @returns 正整数序号
+*/
+function stableSeq(id) {
+	let hash = 2166136261;
+	for (let index = 0; index < id.length; index++) {
+		hash ^= id.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return Math.abs(hash) % 2147483647 + 1;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: Host 侧的路径比较口径：远端身份保留大小写，其余按运行平台折叠。
+* @param path 路径
+* @returns 比较键
+*/
+function pathKey$1(path) {
+	return pathKeyFor(path, process.platform === "win32");
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 判断两个路径是否指同一文件：比较键相同，或一方是另一方的工作区相对写法。
+* 面板传下来的路径可能是相对路径，而条目里存的是绝对路径。
+* @param left 路径
+* @param right 路径
+* @returns 是否同一文件
+*/
+function pendingSamePath(left, right) {
+	const a = pathKey$1(left);
+	const b = pathKey$1(right);
+	if (!a || !b) return false;
+	return a === b || a.endsWith("/" + b) || b.endsWith("/" + a);
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 列表里的条目 id 带待审前缀用于区分通道，内核按原始身份存取，这里统一还原。
+* @param id 请求里的条目 id
+* @returns 待审内核使用的原始 id
+*/
+function pendingRawId(id) {
+	return id.startsWith("pending:") ? id.slice(8) : id;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 列表显示用的短路径：工作区内显示相对路径，区外保留原文。
+* @param cwd 工作区
+* @param path 条目路径
+* @returns 显示用路径
+*/
+function pendingDisplay(cwd, path) {
+	const root = cwd.replace(/[\\/]+$/, "");
+	const unified = path.replace(/\\/g, "/");
+	const base = root.replace(/\\/g, "/");
+	if (base && (unified === base || unified.toLowerCase().startsWith(base.toLowerCase() + "/"))) return unified.slice(base.length + 1);
+	return path;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 待审条目转面板列表项。
+* @param item 待审条目
+* @param cwd 工作区，用于显示相对路径；缺省显示原始路径
+* @returns 面板列表项
+*/
+function pendingItemOf(item, cwd) {
+	return {
+		id: PENDING_PREFIX + item.id,
+		sessionId: item.sessionId,
+		turn: 0,
+		seq: stableSeq(item.id),
+		path: item.path,
+		currentPath: item.path,
+		display: cwd ? pendingDisplay(cwd, item.path) : item.path,
+		added: item.added,
+		deleted: item.deleted,
+		kind: item.oversized ? "oversized" : "text",
+		decision: item.settled ? "accepted" : "pending",
+		revision: item.revision,
+		current: true
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 待审详情转面板详情；Revert 映射到面板的 Undo 能力位。
+* @param detail 待审详情
+* @param capturedAt 采集时间文案
+* @returns 面板详情
+*/
+function pendingDetailOf(detail, capturedAt, cwd) {
+	return {
+		item: pendingItemOf(detail.item, cwd),
+		diff: detail.diff,
+		capturedAt,
+		blocks: detail.blocks,
+		capability: {
+			keep: detail.capability.keep,
+			undo: detail.capability.revert,
+			reason: detail.capability.reason
+		}
+	};
+}
+/**
+* @author ddj 2026年11月3号
+* @description: 覆盖登记键：工作区与路径各自归一化后再拼接，避免同一文件多种写法登记成两条。
+* @param cwd 工作区
+* @param path 路径
+* @returns 覆盖登记键
+*/
+function coverKey(cwd, path) {
+	return `${pathKey$1(cwd)}|${pathKey$1(path)}`;
+}
+/**
+* @private
+* @author ddj 2026年11月04号
+* @description: 取工作区唯一接管集合；来源对话仅保留为诊断信息。
+* @param cwd 工作区路径
+* @returns 路径到登记来源的映射
+*/
+function workspaceCovers(cwd) {
+	const workspaceKey = pathKey$1(cwd);
+	const existing = coveredWorkspace.get(workspaceKey);
+	if (existing) return existing;
+	const created = /* @__PURE__ */ new Map();
+	coveredWorkspace.set(workspaceKey, created);
+	return created;
+}
+/**
+* @author ddj 2026年11月3号
+* @description: 记住/忘记"该路径由待审投影接管"。进程内集合，绝不在旧写入口上查库（避免撞上写事务锁）。
+* @param cwd 工作区
+* @param path 路径
+* @param covered 是否接管
+* @param sessionId 会话 id；缺省落到无归属的工作区集合
+* @returns 无
+*/
+function trackPendingCover(cwd, path, covered, sessionId) {
+	const key = coverKey(cwd, path);
+	const target = workspaceCovers(cwd);
+	if (covered) target.set(key, sessionId ?? null);
+	else target.delete(key);
+}
+/**
+* @author ddj 2026年11月3号
+* @description: 用完整列表重建工作区接管集合，清除任何对话留下的过期登记。
+* @param cwd 工作区
+* @param sessionId 会话 id
+* @param paths 本会话当前可见的待审条目路径
+* @returns 无
+*/
+function setPendingCovers(cwd, sessionId, paths) {
+	const next = /* @__PURE__ */ new Map();
+	for (const path of paths) if (path) next.set(coverKey(cwd, path), sessionId);
+	coveredWorkspace.set(pathKey$1(cwd), next);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 判断某路径是否已由待审投影接管；仅读进程内集合，不产生任何 IO。
+* 所有对话按同一工作区集合判定，兼容参数不影响可见范围。
+* @param cwd 工作区
+* @param path 请求路径
+* @param sessionId 会话 id；缺省按并集判定
+* @returns 是否已被接管
+*/
+function pendingCovers(cwd, path, sessionId) {
+	const key = coverKey(cwd, path);
+	return coveredWorkspace.get(pathKey$1(cwd))?.has(key) === true;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 合并官方页与待审页：待审覆盖的路径从官方结果中剔除，其余原样保留。
+* @param official 官方页
+* @param pending 待审页
+* @param cwd 工作区，用于把待审行显示成相对路径
+* @returns 合并后的页
+*/
+function mergedPage(official, pending, cwd) {
+	const covered = /* @__PURE__ */ new Set();
+	for (const item of pending.items) {
+		covered.add(pathKey$1(item.path));
+		covered.add(pathKey$1(item.id));
+	}
+	const kept = official.items.filter((item) => !covered.has(pathKey$1(item.currentPath)) && !covered.has(pathKey$1(item.path)));
+	return {
+		items: [...pending.items.map((item) => pendingItemOf(item, cwd)), ...kept],
+		pending: pending.pending + kept.filter((item) => item.decision === "pending").length,
+		nextCursor: official.nextCursor,
+		gaps: official.gaps,
+		...official.overview ? { overview: official.overview } : {}
+	};
+}
+//#endregion
+//#region src/pending/persist.ts
+/** 待审库版本号，写进 metadata 便于日后迁移。v3 给评论表加了引文与上下文列。 */
+const SCHEMA_VERSION = "3";
+/**
+* @author ddj 2026年10月29号
+* @description: 打开工作区库并确保待审表存在；DDL 与版本标记在同一事务里提交。
+* @param cwd 已迁移工作区
+* @returns 可读写的连接
+* @throws 未完成活跃库迁移时拒绝
+*/
+function pendingDb(cwd) {
+	if (!activeReady(cwd)) throw new Error("待审投影要求先完成活跃库迁移");
+	const db = dbFor(cwd);
+	if (db.prepare("SELECT value FROM metadata WHERE name='pending_schema'").get()?.value === SCHEMA_VERSION) return db;
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		db.exec(DDL);
+		migrateHistory(db);
+		db.prepare("INSERT INTO metadata(name,value) VALUES('pending_schema',?) ON CONFLICT(name) DO UPDATE SET value=excluded.value").run(SCHEMA_VERSION);
+		db.exec("COMMIT");
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+	return db;
+}
+/** 待审表结构：条目、块决定、幂等操作、撤销栈。 */
+const DDL = `
+CREATE TABLE IF NOT EXISTS pending_entries (
+  id TEXT PRIMARY KEY, path TEXT NOT NULL, earlier TEXT NOT NULL,
+  old_text TEXT NOT NULL, new_text TEXT NOT NULL, updated_at INTEGER NOT NULL,
+  unseen INTEGER NOT NULL DEFAULT 0, missing INTEGER NOT NULL DEFAULT 0,
+  diverged INTEGER NOT NULL DEFAULT 0, oversized INTEGER NOT NULL DEFAULT 0,
+  revision INTEGER NOT NULL DEFAULT 0, session_id TEXT NOT NULL,
+  session_ids TEXT NOT NULL, lineage TEXT);
+CREATE TABLE IF NOT EXISTS pending_blocks (
+  entry_id TEXT NOT NULL, block_id TEXT NOT NULL, decision TEXT NOT NULL,
+  PRIMARY KEY(entry_id,block_id));
+CREATE TABLE IF NOT EXISTS pending_ops (
+  operation_id TEXT PRIMARY KEY, request TEXT NOT NULL, state TEXT NOT NULL,
+  result TEXT, undo TEXT);
+CREATE TABLE IF NOT EXISTS pending_history (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, kind TEXT NOT NULL, entry_id TEXT,
+  snapshot TEXT NOT NULL, created_at INTEGER NOT NULL,
+  state TEXT NOT NULL DEFAULT 'applied');
+`;
+/**
+* @author ddj 2026年10月29号
+* @description: v1 历史表补 state 列（rebuild 成本高于一次 ALTER）。
+* @param db 已打开的工作区库
+* @returns 无
+*/
+function migrateHistory(db) {
+	if (db.prepare("PRAGMA table_info(pending_history)").all().some((column) => column.name === "state")) return;
+	db.exec("ALTER TABLE pending_history ADD COLUMN state TEXT NOT NULL DEFAULT 'applied'");
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 读出全部待审条目，按更新时间升序。
+* @param cwd 工作区
+* @returns 条目与标记
+*/
+function loadEntries(cwd) {
+	return pendingDb(cwd).prepare("SELECT * FROM pending_entries ORDER BY updated_at ASC").all().map((row) => ({
+		entry: entryOfRow(row),
+		flags: flagsOfRow(row)
+	}));
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 写入或更新一条条目（含标记），单条原子完成。
+* @param cwd 工作区
+* @param stored 条目与标记
+* @returns 无
+*/
+function saveEntry(cwd, stored) {
+	upsertEntry(pendingDb(cwd), stored);
+}
+/**
+* @private
+* @author ddj 2026年11月03号
+* @description: 在给定连接上写入或更新一条条目（含标记），供单条与批量两个入口复用。
+* @param db 已迁移连接（可能已在事务中）
+* @param stored 条目与标记
+* @returns 无
+*/
+function upsertEntry(db, stored) {
+	const { entry, flags } = stored;
+	db.prepare(`INSERT INTO pending_entries
+    (id,path,earlier,old_text,new_text,updated_at,unseen,missing,diverged,oversized,revision,session_id,session_ids,lineage)
+    VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+    ON CONFLICT(id) DO UPDATE SET path=excluded.path,earlier=excluded.earlier,old_text=excluded.old_text,
+      new_text=excluded.new_text,updated_at=excluded.updated_at,unseen=excluded.unseen,missing=excluded.missing,
+      diverged=excluded.diverged,oversized=excluded.oversized,revision=excluded.revision,
+      session_id=excluded.session_id,session_ids=excluded.session_ids,lineage=excluded.lineage`).run(entry.id, entry.path, entry.earlierVersion, entry.oldText, entry.newText, entry.updatedAt, entry.unseen === true ? 1 : 0, flags.missing ? 1 : 0, flags.diverged ? 1 : 0, flags.oversized ? 1 : 0, flags.revision, entry.sessionId, JSON.stringify(entry.sessionIds), entry.lineage ? JSON.stringify(entry.lineage) : null);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 删除条目及其块决定，用于"已解决条目移除"。
+* @param cwd 工作区
+* @param id 条目身份
+* @returns 无
+*/
+function dropEntry(cwd, id) {
+	const db = pendingDb(cwd);
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		db.prepare("DELETE FROM pending_entries WHERE id=?").run(id);
+		db.prepare("DELETE FROM pending_blocks WHERE entry_id=?").run(id);
+		db.exec("COMMIT");
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 覆盖某条目的块决定集合。
+* @param cwd 工作区
+* @param entryId 条目身份
+* @param blocks 块决定
+* @returns 无
+*/
+function saveBlocks(cwd, entryId, blocks) {
+	const db = pendingDb(cwd);
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		writeBlocks(db, entryId, blocks);
+		db.exec("COMMIT");
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+}
+/**
+* @private
+* @author ddj 2026年11月03号
+* @description: 在给定连接上覆盖某条目的块决定集合，供单条与批量两个入口复用。
+* @param db 已迁移连接（可能已在事务中）
+* @param entryId 条目身份
+* @param blocks 块决定
+* @returns 无
+*/
+function writeBlocks(db, entryId, blocks) {
+	db.prepare("DELETE FROM pending_blocks WHERE entry_id=?").run(entryId);
+	const insert = db.prepare("INSERT INTO pending_blocks VALUES(?,?,?)");
+	for (const block of blocks) insert.run(entryId, block.id, block.decision);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 读取幂等操作记录；同 operationId 的重复请求必须复用结果。
+* @param cwd 工作区
+* @param operationId 操作身份
+* @returns 请求原文、状态与结果
+*/
+function readOp(cwd, operationId) {
+	const row = pendingDb(cwd).prepare("SELECT request,state,result FROM pending_ops WHERE operation_id=?").get(operationId);
+	return row ? {
+		request: String(row.request),
+		state: String(row.state),
+		result: row.result === null ? null : String(row.result)
+	} : void 0;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 记录一次操作的阶段与撤销快照。
+* @param cwd 工作区
+* @param operationId 操作身份
+* @param request 请求原文
+* @param state prepared / committed
+* @param payload 结果与撤销快照
+* @returns 无
+*/
+function writeOp(cwd, operationId, request, state, payload = {}) {
+	pendingDb(cwd).prepare(`INSERT INTO pending_ops VALUES(?,?,?,?,?)
+    ON CONFLICT(operation_id) DO UPDATE SET state=excluded.state,
+      result=COALESCE(excluded.result,pending_ops.result), undo=COALESCE(excluded.undo,pending_ops.undo)`).run(operationId, request, state, payload.result ?? null, payload.undo ?? null);
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 追加一条撤销栈记录，并截断重做分支（新决定之后旧的"已撤销"记录不能再重做）。
+* @param cwd 工作区
+* @param kind 操作种类
+* @param entryId 涉及的条目
+* @param snapshot 可重放快照
+* @param now 时间
+* @returns 无
+*/
+function pushHistory(cwd, kind, entryId, snapshot, now) {
+	insertHistory(pendingDb(cwd), kind, entryId, snapshot, now);
+}
+/**
+* @private
+* @author ddj 2026年11月03号
+* @description: 在给定连接上追加撤销栈记录并截断重做分支，供单条与批量两个入口复用。
+* @param db 已迁移连接（可能已在事务中）
+* @param kind 操作种类
+* @param entryId 涉及的条目
+* @param snapshot 可重放快照
+* @param now 时间
+* @returns 无
+*/
+function insertHistory(db, kind, entryId, snapshot, now) {
+	db.prepare("DELETE FROM pending_history WHERE state='undone'").run();
+	db.prepare("INSERT INTO pending_history(kind,entry_id,snapshot,created_at,state) VALUES(?,?,?,?,'applied')").run(kind, entryId, snapshot, now);
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 取最近一条仍生效的历史记录，撤销就作用在它上面。
+* @param cwd 工作区
+* @returns 记录或 undefined
+*/
+function latestApplied(cwd) {
+	const row = pendingDb(cwd).prepare("SELECT id,kind,entry_id,snapshot FROM pending_history WHERE state='applied' ORDER BY id DESC LIMIT 1").get();
+	return row ? rowOfHistory(row) : void 0;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 取最早一条被撤销的记录，重做按"撤销的逆序"重新生效。
+* @param cwd 工作区
+* @returns 记录或 undefined
+*/
+function earliestUndone(cwd) {
+	const row = pendingDb(cwd).prepare("SELECT id,kind,entry_id,snapshot FROM pending_history WHERE state='undone' ORDER BY id ASC LIMIT 1").get();
+	return row ? rowOfHistory(row) : void 0;
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 翻转一条历史记录的生效状态。
+* @param cwd 工作区
+* @param id 记录主键
+* @param state applied / undone
+* @returns 无
+*/
+function setHistoryState(cwd, id, state) {
+	pendingDb(cwd).prepare("UPDATE pending_history SET state=? WHERE id=?").run(state, id);
+}
+/**
+* @author ddj 2026年10月30号
+* @description: 把数据库行还原成历史记录。
+* @param row 数据库行
+* @returns 记录
+*/
+function rowOfHistory(row) {
+	return {
+		id: Number(row.id),
+		kind: String(row.kind),
+		entryId: String(row.entry_id),
+		snapshot: String(row.snapshot)
+	};
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 由数据库行还原条目。
+* @param row 数据库行
+* @returns 条目
+*/
+function entryOfRow(row) {
+	const lineage = row.lineage === null ? void 0 : JSON.parse(String(row.lineage));
+	const entry = {
+		id: String(row.id),
+		path: String(row.path),
+		earlierVersion: String(row.earlier) === "none" ? "none" : "file",
+		oldText: String(row.old_text),
+		newText: String(row.new_text),
+		updatedAt: Number(row.updated_at),
+		sessionId: String(row.session_id),
+		sessionIds: JSON.parse(String(row.session_ids))
+	};
+	if (Number(row.unseen) === 1) entry.unseen = true;
+	if (lineage !== void 0) entry.lineage = lineage;
+	return entry;
+}
+/**
+* @author ddj 2026年10月29号
+* @description: 由数据库行还原标记。
+* @param row 数据库行
+* @returns 标记
+*/
+function flagsOfRow(row) {
+	return {
+		missing: Number(row.missing) === 1,
+		diverged: Number(row.diverged) === 1,
+		oversized: Number(row.oversized) === 1,
+		revision: Number(row.revision)
+	};
+}
+/**
+* @public
+* @author ddj 2026年11月03号
+* @description: 在一次事务内批量推进多条待审条目（批量 Keep 用）。每条按 revision 做 CAS，
+* 只跳过冲突的那一条，不牵连整批；块决定与撤销快照与单条路径同口径。
+* @param cwd 工作区
+* @param records 待落库记录
+* @returns 因版本已变被跳过的条目
+* @throws 事务级异常（SQL/程序错误）整体回滚后抛出
+*/
+function saveDecisions(cwd, records) {
+	const db = pendingDb(cwd);
+	const skipped = [];
+	const advance = db.prepare(`UPDATE pending_entries SET path=?,earlier=?,old_text=?,new_text=?,updated_at=?,unseen=?,
+    missing=?,diverged=?,oversized=?,revision=?,session_id=?,session_ids=?,lineage=? WHERE id=? AND revision=?`);
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		for (const record of records) {
+			const { entry, flags } = record.next;
+			const expected = record.stored.flags.revision;
+			if (advance.run(entry.path, entry.earlierVersion, entry.oldText, entry.newText, entry.updatedAt, entry.unseen === true ? 1 : 0, flags.missing ? 1 : 0, flags.diverged ? 1 : 0, flags.oversized ? 1 : 0, flags.revision, entry.sessionId, JSON.stringify(entry.sessionIds), entry.lineage ? JSON.stringify(entry.lineage) : null, record.entryId, expected).changes !== 1) {
+				skipped.push({
+					id: record.entryId,
+					reason: "待审条目已变化，请重试"
+				});
+				continue;
+			}
+			writeBlocks(db, record.entryId, record.blocks);
+			insertHistory(db, "decide", record.entryId, record.snapshot, Date.now());
+		}
+		db.exec("COMMIT");
+		return skipped;
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+}
+//#endregion
 //#region src/store.ts
 const READ_CAP$1 = 8388608;
 /** 二进制预览/写回上限（PDF 等整文件 base64 传输；文本侧仍用 READ_CAP）。 */
@@ -2718,6 +3280,50 @@ async function autoArchiveStale(ctx, session, cwd, bucket) {
 }
 /**
 * @public
+* @author ddj 2026年11月3号
+* 待审累计基线接管某路径后，旧 sidecar 记录不再有独立决策价值：标记 superseded 并归档，
+* 连编辑器的行内 Keep/Undo 一起消失，彻底去掉"旧通道还能点、点了又被守卫拒绝"的双权威残留。
+* 接管是文件级事实，按工作区全部待审条目判定，不跟随"本会话能否看见"漂移。
+* @param ctx DSH 上下文
+* @param session 当前会话
+* @param cwd 工作区
+* @param bucket 活跃记录桶
+* @returns 本次结案记录数
+* @throws 归档失败时恢复内存标志并透传错误
+*/
+async function retireCovered(ctx, session, cwd, bucket) {
+	const covers = loadEntries(cwd).flatMap((stored) => [stored.entry.path, stored.entry.id]).filter((path) => !!path);
+	if (!covers.length) return 0;
+	const taken = [];
+	for (const rec of bucket.values()) {
+		if (rec.archived || rec.superseded === true) continue;
+		if (covers.some((cover) => pendingSamePath(cover, rec.path))) taken.push(rec);
+	}
+	if (!taken.length) return 0;
+	const original = taken.map((rec) => ({
+		rec,
+		at: rec.at,
+		superseded: rec.superseded
+	}));
+	const at = (/* @__PURE__ */ new Date()).toISOString();
+	for (const rec of taken) {
+		rec.superseded = true;
+		rec.at = at;
+	}
+	try {
+		await archiveRecords(ctx, session, cwd, bucket, taken, "已由待审累计基线接管，旧工具记录不再单独决策");
+	} catch (error) {
+		for (const item of original) {
+			if (item.rec.archived) continue;
+			item.rec.superseded = item.superseded;
+			item.rec.at = item.at;
+		}
+		throw error;
+	}
+	return taken.length;
+}
+/**
+* @public
 * @author ddj 2026年10月10号
 * 归档整记录精确抵消对；捕获时仅检查新记录，列表维护时检查整个桶。
 * @param ctx DSH 上下文
@@ -7720,17 +8326,41 @@ function reviewDetail(cwd, id) {
 		}
 	};
 }
+/**
+* @private
+* @author ddj 2026年11月03号
+* @description: 把一个文件的待处理差异块整体置为目标决策，块级判定仍走 changeBlocks 的 hunk 分支。
+* @param db 判定事务连接
+* @param id 文件身份
+* @param decision 目标决策
+* @returns 无
+*/
+function markBlocks(db, id, decision) {
+	db.prepare("UPDATE review_blocks SET decision=? WHERE file_id=? AND decision='pending'").run(decision, id);
+}
+/**
+* @private
+* @author ddj 2026年11月03号
+* @description: 按块决定聚合回写文件决定：仍含 pending 即 pending，多值即 mixed，单一值取该值。
+* @param db 判定事务连接
+* @param id 文件身份
+* @param fallback 没有任何块时的兜底决策
+* @returns 无
+*/
+function aggregateDecision(db, id, fallback) {
+	const decisions = db.prepare("SELECT DISTINCT decision FROM review_blocks WHERE file_id=?").all(id).map((row) => String(row.decision));
+	let aggregate = fallback;
+	if (decisions.includes("pending")) aggregate = "pending";
+	else if (decisions.length > 1) aggregate = "mixed";
+	else if (decisions.length === 1) aggregate = decisions[0];
+	db.prepare("UPDATE review_files SET decision=? WHERE id=?").run(aggregate, id);
+}
 /** @public @author ddj 2026年10月27号 @param db Active decision transaction. @param request File or block action. Updates aggregate without losing mixed decisions. @throws Invalid or already-decided block. */
 function changeBlocks(db, request) {
 	if (request.scope === "hunk") {
 		if (db.prepare("UPDATE review_blocks SET decision=? WHERE file_id=? AND block_id=? AND decision='pending'").run(request.decision, request.id, request.blockId ?? "").changes !== 1) throw new Error("差异块不存在或已处理");
-	} else db.prepare("UPDATE review_blocks SET decision=? WHERE file_id=? AND decision='pending'").run(request.decision, request.id);
-	const decisions = db.prepare("SELECT DISTINCT decision FROM review_blocks WHERE file_id=?").all(request.id).map((row) => String(row.decision));
-	let aggregate = request.decision;
-	if (decisions.includes("pending")) aggregate = "pending";
-	else if (decisions.length > 1) aggregate = "mixed";
-	else if (decisions.length === 1) aggregate = decisions[0];
-	db.prepare("UPDATE review_files SET decision=? WHERE id=?").run(aggregate, request.id);
+	} else markBlocks(db, request.id, request.decision);
+	aggregateDecision(db, request.id, request.decision);
 }
 /** @public @author ddj 2026年10月26号 @param cwd Workspace. @param request Frozen identity/revision. @returns Idempotent decision; rejection never guesses a target. */
 function decideReview(cwd, request) {
@@ -7760,6 +8390,87 @@ function decideReview(cwd, request) {
 		throw error;
 	}
 }
+/**
+* @private
+* @author ddj 2026年11月03号
+* @description: 取当前仍待审的官方记录摘要，作为批量写入的权威依据（不用客户端快照值）。
+* @param db 判定事务连接
+* @returns id → 库内 seq/revision/identity
+*/
+function pendingRows(db) {
+	const rows = db.prepare("SELECT id,seq,revision,identity FROM review_files WHERE current=1 AND decision='pending'").all();
+	const map = /* @__PURE__ */ new Map();
+	for (const row of rows) map.set(String(row.id), {
+		seq: Number(row.seq),
+		revision: Number(row.revision),
+		identity: String(row.identity)
+	});
+	return map;
+}
+/**
+* @public
+* @author ddj 2026年11月03号
+* @description: 一次事务内批量保留官方待审记录。写入条件取库内当前 revision，客户端的 seq/revision 只用于派生操作号，
+* 因此快照漂移不会让整批中止；已结案、有尚待核对 Undo、操作号冲突的条目只跳过自己。
+* @param cwd 工作区
+* @param items 待保留条目（含派生好的 operationId）
+* @returns 成功保留的 identity 列表与跳过明细
+* @throws 事务级异常（SQL/程序错误）整体回滚后抛出
+*/
+function keepOfficialAll(cwd, items) {
+	const db = reviewDb(cwd);
+	const rows = pendingRows(db);
+	const outcome = {
+		paths: [],
+		skipped: []
+	};
+	const keep = db.prepare(`UPDATE review_files SET decision='accepted',revision=revision+1
+    WHERE id=? AND seq=? AND revision=? AND current=1 AND decision='pending'`);
+	const prepared = db.prepare("SELECT 1 FROM review_ops WHERE state='prepared' AND json_extract(request,'$.id')=?");
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		for (const item of items) {
+			const encoded = JSON.stringify({
+				id: item.id,
+				seq: item.seq
+			});
+			const previous = db.prepare("SELECT request,result FROM review_ops WHERE operation_id=?").get(item.operationId);
+			if (previous) {
+				if (previous.request !== encoded || !previous.result) outcome.skipped.push({
+					id: item.id,
+					reason: "该条目已由其他操作处理"
+				});
+				else outcome.paths.push(String(JSON.parse(String(previous.result)).identity));
+				continue;
+			}
+			const row = rows.get(item.id);
+			if (!row || prepared.get(item.id)) {
+				outcome.skipped.push({
+					id: item.id,
+					reason: row ? "该文件有尚待核对的 Undo，暂不能 Keep" : "已结案或不再是待审记录"
+				});
+				continue;
+			}
+			if (keep.run(item.id, row.seq, row.revision).changes !== 1) {
+				outcome.skipped.push({
+					id: item.id,
+					reason: "审查版本冲突，请刷新后重试"
+				});
+				continue;
+			}
+			markBlocks(db, item.id, "accepted");
+			aggregateDecision(db, item.id, "accepted");
+			db.prepare("INSERT INTO review_ops VALUES(?,?,'committed',?,NULL)").run(item.operationId, encoded, JSON.stringify({ identity: row.identity }));
+			outcome.paths.push(row.identity);
+			rows.delete(item.id);
+		}
+		db.exec("COMMIT");
+		return outcome;
+	} catch (error) {
+		if (db.isTransaction) db.exec("ROLLBACK");
+		throw error;
+	}
+}
 //#endregion
 //#region src/officialCapture.ts
 /** Deferred official-event collection; no private snapshot access. @author ddj 2026年10月26号 */
@@ -8066,6 +8777,67 @@ function evidenceText(evidence) {
 	};
 }
 //#endregion
+//#region src/toolTargets.ts
+/** Optional Host patch target extraction; results never substitute raw preimages. @author ddj 2026年11月04号 */
+/** @public @author ddj 2026年11月04号 @param result Untrusted tool envelope. @returns Diagnostic-only status; never writable preimages. */
+function patchDiagnostics(result) {
+	const payload = result?.value ?? result;
+	if (payload?.phase !== "commit" || !Array.isArray(payload.operations)) return ["apply_patch result unavailable or malformed"];
+	const diagnostics = [];
+	for (const operation of payload.operations) {
+		if (!operation || typeof operation.path !== "string" || ![
+			"add",
+			"update",
+			"delete",
+			"move"
+		].includes(operation.kind) || ![
+			"completed",
+			"failed",
+			"unknown",
+			"skipped"
+		].includes(operation.status)) {
+			diagnostics.push("apply_patch operation malformed");
+			continue;
+		}
+		if (operation.status !== "completed") diagnostics.push(operation.path + ": " + operation.status);
+		if (operation.changes !== void 0 && (!Array.isArray(operation.changes) || operation.changes.some((change) => !change || typeof change.path !== "string" || !(change.before === null || typeof change.before === "string") || !(change.after === null || typeof change.after === "string")))) diagnostics.push(operation.path + ": changes malformed");
+	}
+	return diagnostics;
+}
+let parserLoad;
+/** @public @author ddj 2026年11月04号 @returns Optional official parser; missing capabilities remain retryable. */
+async function patchParser() {
+	if (!parserLoad) parserLoad = loadHostModule("@deepseek-ai/dsh-fs-patch").then((module) => {
+		const parser = module.parsePatch;
+		return typeof parser === "function" ? parser : null;
+	}).catch(() => null);
+	const parser = await parserLoad;
+	if (!parser) parserLoad = void 0;
+	return parser;
+}
+/** @public @author ddj 2026年11月04号 @param call Tool identity and arguments. @param parser Optional injectable official parser. @returns Unique unresolved source/destination paths. @throws Unsupported parser or malformed patch. */
+async function toolTargets(call, parser) {
+	if ([
+		"edit",
+		"write",
+		"str_replace_editor"
+	].includes(String(call.name))) {
+		const path = call.arguments?.file_path ?? call.arguments?.path;
+		return typeof path === "string" && path ? [path] : [];
+	}
+	if (call.name !== "apply_patch") return [];
+	if (typeof call.arguments?.input !== "string") throw new Error("apply_patch input unavailable");
+	const parse = parser === void 0 ? await patchParser() : parser;
+	if (!parse) throw new Error("Host patch parser unavailable");
+	const paths = /* @__PURE__ */ new Set();
+	for (const operation of parse(call.arguments.input)) {
+		if (typeof operation.path !== "string" || !operation.path) throw new Error("Invalid patch target");
+		paths.add(operation.path);
+		if (operation.moveTo) paths.add(operation.moveTo);
+	}
+	return [...paths];
+}
+//#endregion
 //#region src/reviewCapture.ts
 /** Independent byte evidence; official diff remains the only display authority. @author ddj 2026年10月27号 */
 /** @public @author ddj 2026年10月27号 @param ctx Host lifecycle owner. @returns Scoped byte recorder; failures disable undo evidence only, never tool execution. */
@@ -8073,12 +8845,15 @@ function installEvidence(ctx) {
 	const chains = /* @__PURE__ */ new Map();
 	const staged = /* @__PURE__ */ new Map();
 	let stopped = false;
+	const disposed = /* @__PURE__ */ new Set();
 	ctx.on("tools/execute", aroundTool);
 	ctx.on("session/event", onEvent);
 	ctx.on("session/disposed", onDisposed);
 	/** @private @author ddj 2026年10月27号 @param session Disposed owner. Drops optional in-memory evidence, never persisted official facts. */
 	function onDisposed(session) {
+		disposed.add(session.id);
 		chains.delete(session.id);
+		for (const key of staged.keys()) if (JSON.parse(key)[0] === session.id) staged.delete(key);
 	}
 	/** @private @author ddj 2026年10月27号 @returns Current bounded capture footprint, excluding transient filesystem reads. */
 	function footprint() {
@@ -8089,48 +8864,94 @@ function installEvidence(ctx) {
 	/** @private @author ddj 2026年10月27号 @param exec Allowed tool dispatch. @param next Original dispatch. @returns Original result unchanged, regardless of capture failure. */
 	async function aroundTool(exec, next) {
 		const session = exec.agent?.session;
-		const path = exec.arguments?.file_path;
-		if (stopped || !session?.id || !["edit", "write"].includes(exec.name) || typeof path !== "string") return next();
-		let fs;
-		let chain;
-		let target;
+		if (stopped || !session?.id) return next();
+		const captures = [];
 		try {
-			if (chains.size >= 16 && !chains.has(session.id) || footprint() >= 33554432) return next();
-			fs = ctx.get("fs");
-			target = await resolveTarget(ctx, session, path);
-			const identity = fs.processPath(target);
-			const before = await readRaw(fs, target, exec.signal);
-			let files = chains.get(session.id);
-			if (!files) {
-				files = /* @__PURE__ */ new Map();
-				chains.set(session.id, files);
-			}
-			if (files.size >= 64 && !files.has(identity)) return next();
-			chain = files.get(identity);
-			if (!chain) {
-				chain = {
-					before,
-					after: before,
-					busy: false,
-					invalid: false
-				};
-				files.set(identity, chain);
-			}
-			if (chain.busy || chain.after.hash !== before.hash) chain.invalid = true;
-			chain.busy = true;
+			const cwd = cwdOfSession(ctx, session);
+			const fs = ctx.get("fs");
+			const paths = await toolTargets(exec);
+			for (const path of paths) try {
+				const capture = await prepareRaw(fs, session.id, cwd ?? void 0, path, exec.signal);
+				if (capture) captures.push(capture);
+			} catch {}
 		} catch {}
 		try {
 			return await next();
 		} finally {
-			if (chain) {
+			for (const capture of captures) {
 				try {
-					chain.after = await readRaw(fs, target, exec.signal);
+					const after = await readRaw(capture.fs, capture.target, exec.signal);
+					if (!stopped && !disposed.has(session.id)) {
+						capture.chain.after = after;
+						if (footprint() > 33554432) {
+							capture.chain.invalid = true;
+							capture.chain.before = rawReviewFile(null);
+							capture.chain.after = rawReviewFile(null);
+						}
+					}
 				} catch {
-					chain.invalid = true;
+					capture.chain.invalid = true;
 				}
+				capture.chain.busy = false;
+			}
+		}
+	}
+	/** @private @author ddj 2026年11月04号 @param sessionId Frozen owner. @param cwd Frozen workspace. @param path Patch target. @param signal Tool cancellation. @returns Reserved raw capture or no evidence. */
+	async function prepareRaw(fs, sessionId, cwd, path, signal) {
+		if (stopped || disposed.has(sessionId) || !cwd || chains.size >= 16 && !chains.has(sessionId) || footprint() >= 33554432) return null;
+		const target = await fs.resolve(path, { cwd });
+		if (stopped || disposed.has(sessionId)) return null;
+		const identity = fs.processPath(target);
+		let files = chains.get(sessionId);
+		if (!files) {
+			files = /* @__PURE__ */ new Map();
+			chains.set(sessionId, files);
+		}
+		if (files.size >= 64 && !files.has(identity)) return null;
+		let chain = files.get(identity);
+		if (chain?.busy) {
+			chain.invalid = true;
+			return null;
+		}
+		const empty = rawReviewFile(null);
+		if (!chain) {
+			chain = {
+				before: empty,
+				after: empty,
+				busy: true,
+				invalid: false
+			};
+			files.set(identity, chain);
+			try {
+				chain.before = await readRaw(fs, target, signal);
+				chain.after = chain.before;
+			} catch (error) {
+				chain.invalid = true;
+				chain.busy = false;
+				throw error;
+			}
+		} else {
+			chain.busy = true;
+			try {
+				const before = await readRaw(fs, target, signal);
+				if (chain.after.hash !== before.hash) chain.invalid = true;
+			} catch (error) {
+				chain.invalid = true;
 				chain.busy = false;
+				throw error;
 			}
 		}
+		if (stopped || disposed.has(sessionId) || footprint() > 33554432) {
+			chain.invalid = true;
+			chain.busy = false;
+			files.delete(identity);
+			return null;
+		}
+		return {
+			fs,
+			target,
+			chain
+		};
 	}
 	/** @private @author ddj 2026年10月27号 @param session Source session. @param event Published official turn. Freezes the chain before the next turn can mutate it. */
 	function onEvent(session, event) {
@@ -8194,10 +9015,34 @@ async function readRaw(fs, target, signal) {
 const WRITE_TOOLS = [
 	"edit",
 	"write",
-	"str_replace_editor"
+	"str_replace_editor",
+	"apply_patch"
 ];
 /** 单文件文本上限：超过即标注 oversized，不静默截断。 */
 const MAX_TEXT = 1048576;
+const captureGaps = /* @__PURE__ */ new Map();
+/** @public @author ddj 2026年11月04号 @param cwd Workspace identity. @returns Bounded runtime-only capture diagnostics. */
+function pendingGaps(cwd) {
+	return [...captureGaps.values()].filter((gap) => gap.cwd === cwd).map((gap) => gap.message);
+}
+/** @private @author ddj 2026年11月04号 @param ctx Host scope. @param exec Original call. @param path Failed target. @param error Evidence failure. Records no writable state. */
+function recordGap(scope, exec, path, error) {
+	const { cwd, sessionId } = scope;
+	const key = JSON.stringify([
+		cwd,
+		sessionId,
+		exec.id,
+		path
+	]);
+	captureGaps.set(key, {
+		cwd,
+		sessionId,
+		message: path + ": " + String(error)
+	});
+	const local = [...captureGaps].filter(([, gap]) => gap.cwd === cwd);
+	while (local.length > 50) captureGaps.delete(local.shift()[0]);
+	while (captureGaps.size > 500) captureGaps.delete(captureGaps.keys().next().value);
+}
 /**
 * @author ddj 2026年10月30号
 * @description: 安装写文件采集；读写失败只影响待审来源，绝不影响用户工具本身。
@@ -8208,12 +9053,18 @@ const MAX_TEXT = 1048576;
 function installPending(ctx, sink) {
 	const state = {
 		busy: /* @__PURE__ */ new Set(),
-		stopped: false
+		stopped: false,
+		disposed: /* @__PURE__ */ new Set()
 	};
 	ctx.on("tools/execute", (exec, next) => aroundTool(ctx, state, sink, exec, next));
+	ctx.on("session/disposed", (session) => {
+		state.disposed.add(session.id);
+		for (const [key, gap] of captureGaps) if (gap.sessionId === session.id) captureGaps.delete(key);
+	});
 	return { dispose() {
 		state.stopped = true;
 		state.busy.clear();
+		captureGaps.clear();
 	} };
 }
 /**
@@ -8224,27 +9075,32 @@ function installPending(ctx, sink) {
 * @param exec 工具分发上下文
 * @returns 采集计划或 null
 */
-async function planOf(ctx, state, exec) {
-	const session = exec.agent?.session;
-	const requested = exec.arguments?.file_path ?? exec.arguments?.path;
-	if (state.stopped || !session?.id || typeof requested !== "string") return null;
-	if (!WRITE_TOOLS.includes(String(exec.name))) return null;
-	const cwd = cwdOf(session);
-	if (!cwd) return null;
-	const fs = ctx.get("fs");
-	const target = await resolveTarget(ctx, session, requested);
+async function planOf(scope, state, requested) {
+	const { cwd, sessionId, fs } = scope;
+	if (state.stopped || state.disposed.has(sessionId)) return null;
+	const target = await fs.resolve(requested, { cwd });
 	const identity = fs.processPath(target);
-	if (typeof identity !== "string" || !identity || state.busy.has(identity)) return null;
-	const before = await readText(fs, target);
-	if (before !== null && before.length > MAX_TEXT) return null;
-	return {
-		cwd: String(cwd),
-		sessionId: String(session.id),
-		path: requested,
-		identity,
-		before,
-		session
-	};
+	if (state.stopped || state.disposed.has(sessionId) || typeof identity !== "string" || !identity || state.busy.has(identity)) return null;
+	state.busy.add(identity);
+	try {
+		const before = await readText(fs, target);
+		if (state.stopped || state.disposed.has(sessionId) || before !== null && before.length > MAX_TEXT) {
+			state.busy.delete(identity);
+			return null;
+		}
+		return {
+			cwd: String(cwd),
+			sessionId,
+			path: requested,
+			identity,
+			before,
+			target,
+			fs
+		};
+	} catch (error) {
+		state.busy.delete(identity);
+		throw error;
+	}
 }
 /**
 * @author ddj 2026年10月30号
@@ -8257,63 +9113,87 @@ async function planOf(ctx, state, exec) {
 * @returns 原始工具结果
 */
 async function aroundTool(ctx, state, sink, exec, next) {
-	let plan = null;
+	if (state.stopped || !WRITE_TOOLS.includes(String(exec.name))) return next();
+	const session = exec.agent?.session;
+	const cwd = session ? cwdOfSession(ctx, session) : null;
+	if (!session?.id || !cwd) return next();
+	const scope = {
+		cwd,
+		sessionId: session.id,
+		fs: ctx.get("fs")
+	};
+	const plans = [];
 	try {
-		plan = await planOf(ctx, state, exec);
+		const paths = await toolTargets(exec);
+		for (const path of paths) try {
+			if (plans.length >= 16) throw new Error("capture target budget exceeded");
+			const plan = await planOf(scope, state, path);
+			if (plan) plans.push(plan);
+		} catch (error) {
+			if (!state.stopped && !state.disposed.has(scope.sessionId)) recordGap(scope, exec, path, error);
+			log.debug("待审采集跳过：" + path + ": " + String(error));
+		}
 	} catch (error) {
-		log.debug("待审采集跳过：" + String(error));
+		if (!state.stopped && !state.disposed.has(scope.sessionId)) recordGap(scope, exec, String(exec.name), error);
+		log.debug("待审目标不可用：" + String(error));
 	}
-	if (!plan) return next();
-	state.busy.add(plan.identity);
 	try {
-		return await next();
+		const result = await next();
+		if (exec.name === "apply_patch" && !state.stopped && !state.disposed.has(scope.sessionId)) for (const diagnostic of patchDiagnostics(result)) recordGap(scope, exec, "apply_patch", diagnostic);
+		return result;
 	} finally {
-		state.busy.delete(plan.identity);
-		try {
-			reportWrite(ctx, sink, plan);
+		for (const plan of plans) try {
+			await reportWrite(state, sink, plan);
 		} catch (error) {
+			if (!state.stopped && !state.disposed.has(scope.sessionId)) recordGap(scope, exec, plan.path, error);
 			log.debug("待审上报失败：" + String(error));
+		} finally {
+			state.busy.delete(plan.identity);
 		}
 	}
 }
 /**
-* @author ddj 2026年10月29号
-* @description: 写后读回并比较，内容一致视为无净变化不产生条目。
-* @param ctx Host 生命周期
+* @author ddj 2026年11月04号
+* @description: 固定目标写后读回；内容一致不产生条目，卸载后不再上报。
+* @param state 采集生命周期状态
 * @param sink 已确认写入的接收方
 * @param plan 采集计划
 * @returns 无；读回失败只记日志
 */
-function reportWrite(ctx, sink, plan) {
-	const fs = ctx.get("fs");
-	resolveTarget(ctx, plan.session, plan.path).then(async (target) => {
-		const after = await readText(fs, target);
-		if (after !== null && after.length > MAX_TEXT) return;
-		if (plan.before === after) return;
-		sink({
-			cwd: plan.cwd,
-			sessionId: plan.sessionId,
-			path: plan.path,
-			identity: plan.identity,
-			before: plan.before,
-			after,
-			now: Date.now()
-		});
-	}).catch((error) => log.debug("待审读回失败：" + String(error)));
+async function reportWrite(state, sink, plan) {
+	if (state.stopped || state.disposed.has(plan.sessionId)) return;
+	const after = await readText(plan.fs, plan.target);
+	if (state.stopped || state.disposed.has(plan.sessionId)) return;
+	if (after !== null && after.length > MAX_TEXT) throw new Error("capture text budget exceeded");
+	for (const [key, gap] of captureGaps) {
+		const identity = JSON.parse(key);
+		if (gap.cwd === plan.cwd && gap.sessionId === plan.sessionId && identity[3] === plan.path) captureGaps.delete(key);
+	}
+	if (plan.before === after) return;
+	sink({
+		cwd: plan.cwd,
+		sessionId: plan.sessionId,
+		path: plan.path,
+		identity: plan.identity,
+		before: plan.before,
+		after,
+		now: Date.now()
+	});
 }
 /**
 * @author ddj 2026年10月29号
-* @description: 读取全文；缺失或不可读按"无内容"处理，交由上层决定语义。
+* @description: 读取全文；只有明确缺失返回 null，不可读或超限错误保留失败语义。
 * @param fs 文件系统
 * @param target 目标
 * @returns 文本或 null
 */
-async function readText(fs, target) {
+async function readText(fs, target, signal) {
 	try {
-		return String(await fs.readText(target));
+		if (typeof fs.readBytes === "function") return rawText(rawReviewFile(await fs.readBytes(target, signal, MAX_TEXT)));
+		throw new Error("Raw byte capture unavailable");
 	} catch (error) {
 		const code = error.code;
-		if (code === "ENOENT" || code === "FS_NOT_FOUND" || code === "FS_TOO_LARGE") return null;
+		if (code === "ENOENT" || code === "FS_NOT_FOUND") return null;
 		throw error;
 	}
 }
@@ -9216,375 +10096,123 @@ async function revert(input, targets, whole) {
 			revision: input.flags.revision + 1,
 			missing: written.content === null
 		},
-		blocks: markAll(input.blocks, targets, "rejected")
-	};
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 整文件回退目标：基线为"文件不存在"时删除，否则写回基线全文。
-* @param entry 待审条目
-* @returns 目标内容，null 表示删除
-*/
-function wholeRevert(entry) {
-	return entry.earlierVersion === "none" ? null : entry.oldText;
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 块级回退：在最新内容里依次换回目标块，任一不可定位即整体放弃。
-* @param entry 待审条目
-* @param targets 目标块
-* @returns 新内容或 undefined
-*/
-function blockRevert(entry, targets) {
-	let newText = entry.newText;
-	for (const block of targets) {
-		const next = revertBlock(newText, block);
-		if (next === null) return void 0;
-		newText = next;
-	}
-	return newText;
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 按请求粒度挑出目标块；块不存在时返回 null 以区分"没有块"。
-* @param blocks 当前差异块
-* @param input 判定输入
-* @returns 目标块，未知块 ID 时为 null
-*/
-function pickBlocks(blocks, input) {
-	const scope = input.request.scope;
-	if (scope === "file" || scope === "all") return [];
-	if (scope === "block") {
-		const block = blocks.find((item) => item.id === input.request.blockId);
-		return block ? [block] : null;
-	}
-	const start = input.request.startLine ?? 0;
-	const end = input.request.endLine ?? start;
-	return blocks.filter((block) => block.newStart <= end && block.newStart + Math.max(block.newLines.length, 1) >= start);
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 把目标块标记为已决定；整文件时把全部块一起标记。
-* @param states 已存块决定
-* @param targets 目标块
-* @param decision 决定
-* @returns 新的块决定列表
-*/
-function markAll(states, targets, decision) {
-	const next = states.slice();
-	for (const block of targets) {
-		const at = next.findIndex((state) => state.id === block.id);
-		if (at >= 0) next[at] = {
-			id: block.id,
-			decision
-		};
-		else next.push({
-			id: block.id,
-			decision
-		});
-	}
-	return next;
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 能力口径：Keep 恒可；Revert 受超大/缺失/已解决限制，拒绝原因要能展示。
-* @param entry 待审条目
-* @param flags 持久标记
-* @returns 能力与原因
-*/
-function capabilityOf(entry, flags) {
-	if (isSettled(entry)) return {
-		keep: false,
-		revert: false,
-		reason: "settled"
-	};
-	if (flags.oversized) return {
-		keep: false,
-		revert: false,
-		reason: "oversized"
-	};
-	if (entry.earlierVersion === "none" && entry.newText.length === 0) return {
-		keep: true,
-		revert: false,
-		reason: "empty-create"
-	};
-	return {
-		keep: true,
-		revert: true,
-		reason: ""
-	};
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 供详情接口复用的差异构造。
-* @param entry 待审条目
-* @param baselineEmpty 基线置空：文件由本次会话新建，旧基线只是会话自己的中间产物
-* @returns 官方差异
-*/
-function diffOf(entry, baselineEmpty = false) {
-	if (!baselineEmpty) return textDiff(entry.path, entry.path, entry.oldText, entry.newText);
-	if (entry.newText === "") return textDiff(entry.path, entry.path, "", "");
-	const diff = textDiff(entry.path, entry.path, "", entry.newText);
-	if (diff.kind !== "text") return diff;
-	return {
-		...diff,
-		hunks: diff.hunks.map((hunk) => ({
-			...hunk,
-			oldLines: 0,
-			lines: hunk.lines.filter((line) => line !== "-")
-		}))
-	};
-}
-//#endregion
-//#region src/pending/persist.ts
-/** 待审库版本号，写进 metadata 便于日后迁移。v3 给评论表加了引文与上下文列。 */
-const SCHEMA_VERSION = "3";
-/**
-* @author ddj 2026年10月29号
-* @description: 打开工作区库并确保待审表存在；DDL 与版本标记在同一事务里提交。
-* @param cwd 已迁移工作区
-* @returns 可读写的连接
-* @throws 未完成活跃库迁移时拒绝
-*/
-function pendingDb(cwd) {
-	if (!activeReady(cwd)) throw new Error("待审投影要求先完成活跃库迁移");
-	const db = dbFor(cwd);
-	if (db.prepare("SELECT value FROM metadata WHERE name='pending_schema'").get()?.value === SCHEMA_VERSION) return db;
-	db.exec("BEGIN IMMEDIATE");
-	try {
-		db.exec(DDL);
-		migrateHistory(db);
-		db.prepare("INSERT INTO metadata(name,value) VALUES('pending_schema',?) ON CONFLICT(name) DO UPDATE SET value=excluded.value").run(SCHEMA_VERSION);
-		db.exec("COMMIT");
-	} catch (error) {
-		if (db.isTransaction) db.exec("ROLLBACK");
-		throw error;
-	}
-	return db;
-}
-/** 待审表结构：条目、块决定、幂等操作、撤销栈。 */
-const DDL = `
-CREATE TABLE IF NOT EXISTS pending_entries (
-  id TEXT PRIMARY KEY, path TEXT NOT NULL, earlier TEXT NOT NULL,
-  old_text TEXT NOT NULL, new_text TEXT NOT NULL, updated_at INTEGER NOT NULL,
-  unseen INTEGER NOT NULL DEFAULT 0, missing INTEGER NOT NULL DEFAULT 0,
-  diverged INTEGER NOT NULL DEFAULT 0, oversized INTEGER NOT NULL DEFAULT 0,
-  revision INTEGER NOT NULL DEFAULT 0, session_id TEXT NOT NULL,
-  session_ids TEXT NOT NULL, lineage TEXT);
-CREATE TABLE IF NOT EXISTS pending_blocks (
-  entry_id TEXT NOT NULL, block_id TEXT NOT NULL, decision TEXT NOT NULL,
-  PRIMARY KEY(entry_id,block_id));
-CREATE TABLE IF NOT EXISTS pending_ops (
-  operation_id TEXT PRIMARY KEY, request TEXT NOT NULL, state TEXT NOT NULL,
-  result TEXT, undo TEXT);
-CREATE TABLE IF NOT EXISTS pending_history (
-  id INTEGER PRIMARY KEY AUTOINCREMENT, kind TEXT NOT NULL, entry_id TEXT,
-  snapshot TEXT NOT NULL, created_at INTEGER NOT NULL,
-  state TEXT NOT NULL DEFAULT 'applied');
-`;
-/**
-* @author ddj 2026年10月29号
-* @description: v1 历史表补 state 列（rebuild 成本高于一次 ALTER）。
-* @param db 已打开的工作区库
-* @returns 无
-*/
-function migrateHistory(db) {
-	if (db.prepare("PRAGMA table_info(pending_history)").all().some((column) => column.name === "state")) return;
-	db.exec("ALTER TABLE pending_history ADD COLUMN state TEXT NOT NULL DEFAULT 'applied'");
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 读出全部待审条目，按更新时间升序。
-* @param cwd 工作区
-* @returns 条目与标记
-*/
-function loadEntries(cwd) {
-	return pendingDb(cwd).prepare("SELECT * FROM pending_entries ORDER BY updated_at ASC").all().map((row) => ({
-		entry: entryOfRow(row),
-		flags: flagsOfRow(row)
-	}));
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 写入或更新一条条目（含标记），单条原子完成。
-* @param cwd 工作区
-* @param stored 条目与标记
-* @returns 无
-*/
-function saveEntry(cwd, stored) {
-	const { entry, flags } = stored;
-	pendingDb(cwd).prepare(`INSERT INTO pending_entries
-    (id,path,earlier,old_text,new_text,updated_at,unseen,missing,diverged,oversized,revision,session_id,session_ids,lineage)
-    VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
-    ON CONFLICT(id) DO UPDATE SET path=excluded.path,earlier=excluded.earlier,old_text=excluded.old_text,
-      new_text=excluded.new_text,updated_at=excluded.updated_at,unseen=excluded.unseen,missing=excluded.missing,
-      diverged=excluded.diverged,oversized=excluded.oversized,revision=excluded.revision,
-      session_id=excluded.session_id,session_ids=excluded.session_ids,lineage=excluded.lineage`).run(entry.id, entry.path, entry.earlierVersion, entry.oldText, entry.newText, entry.updatedAt, entry.unseen === true ? 1 : 0, flags.missing ? 1 : 0, flags.diverged ? 1 : 0, flags.oversized ? 1 : 0, flags.revision, entry.sessionId, JSON.stringify(entry.sessionIds), entry.lineage ? JSON.stringify(entry.lineage) : null);
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 删除条目及其块决定，用于"已解决条目移除"。
-* @param cwd 工作区
-* @param id 条目身份
-* @returns 无
-*/
-function dropEntry(cwd, id) {
-	const db = pendingDb(cwd);
-	db.exec("BEGIN IMMEDIATE");
-	try {
-		db.prepare("DELETE FROM pending_entries WHERE id=?").run(id);
-		db.prepare("DELETE FROM pending_blocks WHERE entry_id=?").run(id);
-		db.exec("COMMIT");
-	} catch (error) {
-		if (db.isTransaction) db.exec("ROLLBACK");
-		throw error;
-	}
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 覆盖某条目的块决定集合。
-* @param cwd 工作区
-* @param entryId 条目身份
-* @param blocks 块决定
-* @returns 无
-*/
-function saveBlocks(cwd, entryId, blocks) {
-	const db = pendingDb(cwd);
-	db.exec("BEGIN IMMEDIATE");
-	try {
-		db.prepare("DELETE FROM pending_blocks WHERE entry_id=?").run(entryId);
-		const insert = db.prepare("INSERT INTO pending_blocks VALUES(?,?,?)");
-		for (const block of blocks) insert.run(entryId, block.id, block.decision);
-		db.exec("COMMIT");
-	} catch (error) {
-		if (db.isTransaction) db.exec("ROLLBACK");
-		throw error;
-	}
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 读取幂等操作记录；同 operationId 的重复请求必须复用结果。
-* @param cwd 工作区
-* @param operationId 操作身份
-* @returns 请求原文、状态与结果
-*/
-function readOp(cwd, operationId) {
-	const row = pendingDb(cwd).prepare("SELECT request,state,result FROM pending_ops WHERE operation_id=?").get(operationId);
-	return row ? {
-		request: String(row.request),
-		state: String(row.state),
-		result: row.result === null ? null : String(row.result)
-	} : void 0;
+		blocks: markAll(input.blocks, targets, "rejected")
+	};
 }
 /**
 * @author ddj 2026年10月29号
-* @description: 记录一次操作的阶段与撤销快照。
-* @param cwd 工作区
-* @param operationId 操作身份
-* @param request 请求原文
-* @param state prepared / committed
-* @param payload 结果与撤销快照
-* @returns 无
+* @description: 整文件回退目标：基线为"文件不存在"时删除，否则写回基线全文。
+* @param entry 待审条目
+* @returns 目标内容，null 表示删除
 */
-function writeOp(cwd, operationId, request, state, payload = {}) {
-	pendingDb(cwd).prepare(`INSERT INTO pending_ops VALUES(?,?,?,?,?)
-    ON CONFLICT(operation_id) DO UPDATE SET state=excluded.state,
-      result=COALESCE(excluded.result,pending_ops.result), undo=COALESCE(excluded.undo,pending_ops.undo)`).run(operationId, request, state, payload.result ?? null, payload.undo ?? null);
+function wholeRevert(entry) {
+	return entry.earlierVersion === "none" ? null : entry.oldText;
 }
 /**
 * @author ddj 2026年10月29号
-* @description: 追加一条撤销栈记录，并截断重做分支（新决定之后旧的"已撤销"记录不能再重做）。
-* @param cwd 工作区
-* @param kind 操作种类
-* @param entryId 涉及的条目
-* @param snapshot 可重放快照
-* @param now 时间
-* @returns 无
-*/
-function pushHistory(cwd, kind, entryId, snapshot, now) {
-	const db = pendingDb(cwd);
-	db.prepare("DELETE FROM pending_history WHERE state='undone'").run();
-	db.prepare("INSERT INTO pending_history(kind,entry_id,snapshot,created_at,state) VALUES(?,?,?,?,'applied')").run(kind, entryId, snapshot, now);
-}
-/**
-* @author ddj 2026年10月30号
-* @description: 取最近一条仍生效的历史记录，撤销就作用在它上面。
-* @param cwd 工作区
-* @returns 记录或 undefined
-*/
-function latestApplied(cwd) {
-	const row = pendingDb(cwd).prepare("SELECT id,kind,entry_id,snapshot FROM pending_history WHERE state='applied' ORDER BY id DESC LIMIT 1").get();
-	return row ? rowOfHistory(row) : void 0;
-}
-/**
-* @author ddj 2026年10月30号
-* @description: 取最早一条被撤销的记录，重做按"撤销的逆序"重新生效。
-* @param cwd 工作区
-* @returns 记录或 undefined
+* @description: 块级回退：在最新内容里依次换回目标块，任一不可定位即整体放弃。
+* @param entry 待审条目
+* @param targets 目标块
+* @returns 新内容或 undefined
 */
-function earliestUndone(cwd) {
-	const row = pendingDb(cwd).prepare("SELECT id,kind,entry_id,snapshot FROM pending_history WHERE state='undone' ORDER BY id ASC LIMIT 1").get();
-	return row ? rowOfHistory(row) : void 0;
+function blockRevert(entry, targets) {
+	let newText = entry.newText;
+	for (const block of targets) {
+		const next = revertBlock(newText, block);
+		if (next === null) return void 0;
+		newText = next;
+	}
+	return newText;
 }
 /**
-* @author ddj 2026年10月30号
-* @description: 翻转一条历史记录的生效状态。
-* @param cwd 工作区
-* @param id 记录主键
-* @param state applied / undone
-* @returns 无
+* @author ddj 2026年10月29号
+* @description: 按请求粒度挑出目标块；块不存在时返回 null 以区分"没有块"。
+* @param blocks 当前差异块
+* @param input 判定输入
+* @returns 目标块，未知块 ID 时为 null
 */
-function setHistoryState(cwd, id, state) {
-	pendingDb(cwd).prepare("UPDATE pending_history SET state=? WHERE id=?").run(state, id);
+function pickBlocks(blocks, input) {
+	const scope = input.request.scope;
+	if (scope === "file" || scope === "all") return [];
+	if (scope === "block") {
+		const block = blocks.find((item) => item.id === input.request.blockId);
+		return block ? [block] : null;
+	}
+	const start = input.request.startLine ?? 0;
+	const end = input.request.endLine ?? start;
+	return blocks.filter((block) => block.newStart <= end && block.newStart + Math.max(block.newLines.length, 1) >= start);
 }
 /**
-* @author ddj 2026年10月30号
-* @description: 把数据库行还原成历史记录。
-* @param row 数据库行
-* @returns 记录
+* @author ddj 2026年10月29号
+* @description: 把目标块标记为已决定；整文件时把全部块一起标记。
+* @param states 已存块决定
+* @param targets 目标块
+* @param decision 决定
+* @returns 新的块决定列表
 */
-function rowOfHistory(row) {
-	return {
-		id: Number(row.id),
-		kind: String(row.kind),
-		entryId: String(row.entry_id),
-		snapshot: String(row.snapshot)
-	};
+function markAll(states, targets, decision) {
+	const next = states.slice();
+	for (const block of targets) {
+		const at = next.findIndex((state) => state.id === block.id);
+		if (at >= 0) next[at] = {
+			id: block.id,
+			decision
+		};
+		else next.push({
+			id: block.id,
+			decision
+		});
+	}
+	return next;
 }
 /**
 * @author ddj 2026年10月29号
-* @description: 由数据库行还原条目。
-* @param row 数据库行
-* @returns 条目
+* @description: 能力口径：Keep 恒可；Revert 受超大/缺失/已解决限制，拒绝原因要能展示。
+* @param entry 待审条目
+* @param flags 持久标记
+* @returns 能力与原因
 */
-function entryOfRow(row) {
-	const lineage = row.lineage === null ? void 0 : JSON.parse(String(row.lineage));
-	const entry = {
-		id: String(row.id),
-		path: String(row.path),
-		earlierVersion: String(row.earlier) === "none" ? "none" : "file",
-		oldText: String(row.old_text),
-		newText: String(row.new_text),
-		updatedAt: Number(row.updated_at),
-		sessionId: String(row.session_id),
-		sessionIds: JSON.parse(String(row.session_ids))
+function capabilityOf(entry, flags) {
+	if (isSettled(entry)) return {
+		keep: false,
+		revert: false,
+		reason: "settled"
+	};
+	if (flags.oversized) return {
+		keep: false,
+		revert: false,
+		reason: "oversized"
+	};
+	if (entry.earlierVersion === "none" && entry.newText.length === 0) return {
+		keep: true,
+		revert: false,
+		reason: "empty-create"
+	};
+	return {
+		keep: true,
+		revert: true,
+		reason: ""
 	};
-	if (Number(row.unseen) === 1) entry.unseen = true;
-	if (lineage !== void 0) entry.lineage = lineage;
-	return entry;
 }
 /**
 * @author ddj 2026年10月29号
-* @description: 由数据库行还原标记。
-* @param row 数据库行
-* @returns 标记
+* @description: 供详情接口复用的差异构造。
+* @param entry 待审条目
+* @param baselineEmpty 基线置空：文件由本次会话新建，旧基线只是会话自己的中间产物
+* @returns 官方差异
 */
-function flagsOfRow(row) {
+function diffOf(entry, baselineEmpty = false) {
+	if (!baselineEmpty) return textDiff(entry.path, entry.path, entry.oldText, entry.newText);
+	if (entry.newText === "") return textDiff(entry.path, entry.path, "", "");
+	const diff = textDiff(entry.path, entry.path, "", entry.newText);
+	if (diff.kind !== "text") return diff;
 	return {
-		missing: Number(row.missing) === 1,
-		diverged: Number(row.diverged) === 1,
-		oversized: Number(row.oversized) === 1,
-		revision: Number(row.revision)
+		...diff,
+		hunks: diff.hunks.map((hunk) => ({
+			...hunk,
+			oldLines: 0,
+			lines: hunk.lines.filter((line) => line !== "-")
+		}))
 	};
 }
 //#endregion
@@ -9693,18 +10321,39 @@ function itemOf(stored, baselineEmpty = false) {
 	return item;
 }
 /**
+* @private
+* @author ddj 2026年11月04号
+* @description 从条目来源判断创建基线；任何决定历史都阻止展示层复活已推进的旧基线。
+* @param cwd 工作区
+* @param stored 累计条目
+* @param sourceAdds 单次读取内的来源创建集合缓存
+* @returns 是否将展示基线置空
+*/
+function emptyBaseOf(cwd, stored, sourceAdds = /* @__PURE__ */ new Map()) {
+	if (isSettled(stored.entry)) return false;
+	if (pendingDb(cwd).prepare("SELECT 1 FROM pending_history WHERE entry_id=? LIMIT 1").get(stored.entry.id)) return false;
+	for (const sourceId of stored.entry.sessionIds) {
+		let createdPaths = sourceAdds.get(sourceId);
+		if (!createdPaths) {
+			createdPaths = addedFiles(cwd, sourceId);
+			sourceAdds.set(sourceId, createdPaths);
+		}
+		if (createdPaths.has(stored.entry.id)) return true;
+	}
+	return false;
+}
+/**
 * @author ddj 2026年10月29号
-* @description: 读一页待审条目，按更新时间升序；会话过滤走血缘集合。
+* @description: 读工作区全部待审条目，按更新时间升序；来源会话仅用于追溯。
 * @param cwd 工作区
-* @param sessionId 当前会话
-* @param wholeAdd 本次会话新建的文件身份集合，命中时基线置空
+* @param _sessionId 兼容旧调用签名，不再用于可见性过滤
 * @returns 列表
 */
-function loadPage(cwd, sessionId, wholeAdd) {
-	const all = loadEntries(cwd);
-	const visible = sessionId ? all.filter((stored) => stored.entry.sessionIds.includes(sessionId)) : all;
-	const items = visible.map((stored) => itemOf(stored, wholeAdd?.has(stored.entry.id) === true));
-	const gaps = [];
+function loadPage(cwd, _sessionId) {
+	const visible = loadEntries(cwd);
+	const sourceAdds = /* @__PURE__ */ new Map();
+	const items = visible.map((stored) => itemOf(stored, emptyBaseOf(cwd, stored, sourceAdds)));
+	const gaps = pendingGaps(cwd);
 	for (const stored of visible) if (stored.flags.oversized) gaps.push(`${stored.entry.path}: 文本超出上限，仅保留标记`);
 	return {
 		items,
@@ -9724,9 +10373,10 @@ function loadPage(cwd, sessionId, wholeAdd) {
 function loadDetail(cwd, id, baselineEmpty = false) {
 	const stored = loadEntries(cwd).find((item) => item.entry.id === id);
 	if (!stored) return null;
-	const diff = diffOf(stored.entry, baselineEmpty);
+	const emptyBase = baselineEmpty || emptyBaseOf(cwd, stored);
+	const diff = diffOf(stored.entry, emptyBase);
 	return {
-		item: itemOf(stored, baselineEmpty),
+		item: itemOf(stored, emptyBase),
 		diff,
 		blocks: blockStatesOf(stored.entry),
 		capability: capabilityOf(stored.entry, stored.flags)
@@ -9826,23 +10476,25 @@ function writerFor(fs, cwd, identity, expected, signal, policy, allowCreate = fa
 				reason: "resolve-failed"
 			};
 		}
-		const current = await readText(fs, target).catch(() => void 0);
-		if (current === void 0) return {
+		const snapshot = await stableRead(fs, target, signal);
+		if (!snapshot.ok) return snapshot;
+		const recreate = allowCreate && snapshot.content === null;
+		if (!recreate && snapshot.content !== expected) return {
 			ok: false,
-			reason: "read-failed"
+			reason: "diverged"
 		};
-		if (!(allowCreate && current === null) && current !== expected) return {
+		if (snapshot.content === null && !recreate) return {
 			ok: false,
-			reason: "diverged"
+			reason: "missing"
+		};
+		const intent = recreate ? { kind: "createIfAbsent" } : {
+			kind: "replaceIfVersion",
+			version: snapshot.version
 		};
-		const currentStat = await fs.stat(target, signal).catch(() => void 0);
 		try {
-			await fs.writeText(target, content ?? "", currentStat ? {
-				kind: "replaceIfVersion",
-				version: currentStat.version
-			} : void 0, signal, policy);
+			await fs.writeText(target, content ?? "", intent, signal, policy);
 			const readBack = await readText(fs, target);
-			if ((content ?? "") !== (readBack ?? "")) return {
+			if (content !== readBack) return {
 				ok: false,
 				reason: "read-back-mismatch"
 			};
@@ -9885,7 +10537,7 @@ async function applyDecide(fs, cwd, request, signal, policy) {
 		blocks: beforeBlocks,
 		now: Date.now(),
 		write: (content) => {
-			if (content === null) return deleteTarget(fs, cwd, stored.entry.id, signal);
+			if (content === null) return deleteTarget(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy);
 			return writerFor(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy)(content);
 		}
 	});
@@ -9914,6 +10566,113 @@ async function applyDecide(fs, cwd, request, signal, policy) {
 	return outcome;
 }
 /**
+* @public
+* @author ddj 2026年11月03号
+* @description: 一次读取全表后批量保留待审条目（Keep 不写盘）。写入用刚读到的最新 revision，
+* 客户端快照漂移不会整批中止；单条 oversized、不存在或落库时被抢先推进只跳过自己。
+* @param cwd 工作区
+* @param items 待保留条目
+* @returns 保留成功与跳过的明细
+* @throws 待审库迁移未就绪等存储级异常
+*/
+async function keepAll(cwd, items) {
+	const stored = new Map(loadEntries(cwd).map((item) => [item.entry.id, item]));
+	const now = Date.now();
+	const outcome = {
+		kept: [],
+		skipped: []
+	};
+	const records = [];
+	for (const item of items) {
+		const before = stored.get(item.id);
+		if (!before) {
+			outcome.skipped.push({
+				id: item.id,
+				display: item.display,
+				reason: "待审条目不存在"
+			});
+			continue;
+		}
+		if (before.flags.oversized) {
+			outcome.skipped.push({
+				id: item.id,
+				display: item.display,
+				reason: "文本超出上限，不能整文件保留"
+			});
+			continue;
+		}
+		if (isSettled(before.entry)) {
+			outcome.kept.push({
+				id: item.id,
+				path: before.entry.path
+			});
+			continue;
+		}
+		const beforeBlocks = blockStatesOf(before.entry);
+		const outcomeOf = await decide({
+			request: {
+				sessionId: before.entry.sessionId,
+				id: item.id,
+				revision: before.flags.revision,
+				operationId: item.operationId,
+				decision: "accepted",
+				scope: "file"
+			},
+			entry: before.entry,
+			flags: before.flags,
+			blocks: beforeBlocks,
+			now,
+			write: () => {
+				throw new Error("批量 Keep 不写盘");
+			}
+		});
+		if (!outcomeOf.ok) {
+			outcome.skipped.push({
+				id: item.id,
+				display: item.display,
+				reason: outcomeOf.reason
+			});
+			continue;
+		}
+		outcome.kept.push({
+			id: item.id,
+			path: before.entry.path
+		});
+		records.push({
+			entryId: item.id,
+			stored: before,
+			next: {
+				entry: outcomeOf.entry,
+				flags: outcomeOf.flags
+			},
+			blocks: outcomeOf.blocks,
+			snapshot: JSON.stringify({
+				before: {
+					entry: before.entry,
+					flags: before.flags,
+					blocks: beforeBlocks
+				},
+				after: {
+					entry: outcomeOf.entry,
+					flags: outcomeOf.flags,
+					blocks: outcomeOf.blocks
+				},
+				wrote: outcomeOf.wrote
+			})
+		});
+	}
+	const displayOf = new Map(items.map((item) => [item.id, item.display]));
+	for (const conflict of saveDecisions(cwd, records)) {
+		outcome.kept = outcome.kept.filter((entry) => entry.id !== conflict.id);
+		outcome.skipped.push({
+			id: conflict.id,
+			display: displayOf.get(conflict.id) ?? conflict.id,
+			reason: conflict.reason
+		});
+	}
+	return outcome;
+}
+/**
 * @author ddj 2026年10月30号
 * @description: 版本库导入：把工作副本相对基线的改动折进待审条目，已存在条目按折叠规则并入。
 * @param shell shell 能力
@@ -10006,7 +10765,7 @@ async function undoDecide(fs, cwd, move, signal, policy) {
 * @returns 写盘结果
 */
 async function writeBack(fs, cwd, stored, target, signal, policy) {
-	if (target.flags.missing) return deleteTarget(fs, cwd, stored.entry.id, signal);
+	if (target.flags.missing) return deleteTarget(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy);
 	return writerFor(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy, true)(target.entry.newText);
 }
 /**
@@ -10025,65 +10784,93 @@ function parseSnapshot(text) {
 	}
 }
 /**
-* @author ddj 2026年10月29号
-* @description: Revert 的删除分支：FileSystem 抽象没有删除能力，只有确认仍在工作区内才用宿主 unlink。
-* @param fs 文件系统
-* @param cwd 工作区
-* @param identity 目标身份
+* @private
+* @author ddj 2026年11月04号
+* @description 版本—内容—版本读取，防止将新版本令牌与旧内容拼成写入依据。
+* @param fs 文件提供方
+* @param target 已解析目标
 * @param signal 取消信号
-* @returns 删除结果
+* @returns 稳定快照或拒绝原因
 */
-async function deleteTarget(fs, cwd, identity, signal) {
-	let target;
+async function stableRead(fs, target, signal) {
 	try {
-		target = await fs.resolve(identity, {
-			cwd,
-			signal
-		});
-	} catch {
+		const before = await fs.stat(target, signal);
+		if (!before) return {
+			ok: true,
+			content: null
+		};
+		if (before.type !== "file" || !before.version) return {
+			ok: false,
+			reason: "unguarded-file"
+		};
+		const content = await readText(fs, target, signal);
+		if (content === null) return {
+			ok: false,
+			reason: "revision-mismatch"
+		};
+		const after = await fs.stat(target, signal);
+		if (after?.type !== "file" || after.version !== before.version) return {
+			ok: false,
+			reason: "revision-mismatch"
+		};
+		return {
+			ok: true,
+			content,
+			version: before.version
+		};
+	} catch (error) {
 		return {
 			ok: false,
-			reason: "resolve-failed"
+			reason: reasonOf(error)
 		};
 	}
-	if (!await fs.stat(target, signal).catch(() => void 0)) return {
-		ok: true,
-		content: null
-	};
-	const absolute = String(fs.processPath(target));
-	if (!insideWorkspace(cwd, absolute)) return {
+}
+/**
+* @private
+* @author ddj 2026年11月04号
+* @description 通过 provider 受控删除，保留会话策略与原子版本校验；旧 Host 不回落直删。
+* @param fs 文件提供方
+* @param cwd 工作目录
+* @param identity 目标身份
+* @param expected 应有内容
+* @param signal 取消信号
+* @param policy 会话沙箱策略
+* @returns 删除结果；结果不明不提交决定
+*/
+async function deleteTarget(fs, cwd, identity, expected, signal, policy) {
+	if (typeof fs.deleteFile !== "function") return {
 		ok: false,
-		reason: "outside-workspace"
+		reason: "delete-unavailable"
 	};
 	try {
-		await unlink(absolute);
+		const target = await fs.resolve(identity, {
+			cwd,
+			signal
+		});
+		const snapshot = await stableRead(fs, target, signal);
+		if (!snapshot.ok) return snapshot;
+		if (snapshot.content === null) return {
+			ok: true,
+			content: null
+		};
+		if (snapshot.content !== expected) return {
+			ok: false,
+			reason: "diverged"
+		};
+		await fs.deleteFile(target, { version: snapshot.version }, signal, policy);
+		return await fs.stat(target, signal) ? {
+			ok: false,
+			reason: "delete-failed"
+		} : {
+			ok: true,
+			content: null
+		};
 	} catch (error) {
 		return {
 			ok: false,
 			reason: reasonOf(error)
 		};
 	}
-	return await fs.stat(target, signal).catch(() => void 0) ? {
-		ok: false,
-		reason: "delete-failed"
-	} : {
-		ok: true,
-		content: null
-	};
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 判断宿主路径是否位于工作区内，Windows 下按大小写不敏感比较。
-* @param cwd 工作区
-* @param absolute 目标绝对路径
-* @returns 是否在工作区内
-*/
-function insideWorkspace(cwd, absolute) {
-	const root = resolve(cwd);
-	const candidate = resolve(absolute);
-	const normalize = (value) => process.platform === "win32" ? value.toLowerCase() : value;
-	const rootKey = normalize(root).endsWith(sep) ? normalize(root) : normalize(root) + sep;
-	return normalize(candidate).startsWith(rootKey);
 }
 /**
 * @author ddj 2026年10月29号
@@ -10110,197 +10897,6 @@ function reasonOf(error) {
 	return typeof code === "string" ? code : String(error);
 }
 //#endregion
-//#region src/shared/pathKey.ts
-/**
-* 路径比较口径：Host 与客户端共用同一套「远端 / 盘符 / 相对路径」判定，只在平台折叠上分工。
-* @author ddj 2026年10月30号
-*/
-/** 远端仓库身份：`scheme://...` 区分大小写，绝不能折叠。 */
-const REMOTE = /^[a-z]+:\/\//i;
-/** 盘符绝对路径：大小写不敏感与宿主平台无关，两边都必须折叠。 */
-const DRIVE = /^[a-z]:\//i;
-/**
-* @author ddj 2026年10月30号
-* @description: 统一分隔符为 `/`，其余字符原样保留。
-* @param path 原始路径
-* @returns 反斜杠已归一化的路径
-*/
-function unifiedPath(path) {
-	return path.replace(/\\/g, "/");
-}
-/**
-* @author ddj 2026年10月30号
-* @description: 生成路径比较键。盘符路径恒折叠大小写；其余路径是否折叠由调用方按运行平台决定
-* （Host 在 Windows 上折叠，客户端不在宿主进程里，取 false）。
-* @param path 原始路径
-* @param foldCase 非盘符路径是否折叠大小写
-* @returns 比较键
-*/
-function pathKeyFor(path, foldCase) {
-	const unified = unifiedPath(path);
-	if (REMOTE.test(unified)) return unified;
-	if (DRIVE.test(unified)) return unified.toLowerCase();
-	return foldCase ? unified.toLowerCase() : unified;
-}
-//#endregion
-//#region src/shared/pendingReview.ts
-/** 待审条目在面板列表里的 id 前缀；客户端与 Host 共用这一份口径。 */
-const PENDING_PREFIX = "pending:";
-//#endregion
-//#region src/pendingCompat.ts
-/** 进程内"已被待审接管"的路径集合；旧写入口守卫只读它，绝不碰数据库。 */
-const coveredPaths = /* @__PURE__ */ new Set();
-/**
-* @author ddj 2026年10月29号
-* @description: 由条目 id 派生稳定序号，保证轮询期间面板锚点不跳。
-* @param id 待审条目身份
-* @returns 正整数序号
-*/
-function stableSeq(id) {
-	let hash = 2166136261;
-	for (let index = 0; index < id.length; index++) {
-		hash ^= id.charCodeAt(index);
-		hash = Math.imul(hash, 16777619);
-	}
-	return Math.abs(hash) % 2147483647 + 1;
-}
-/**
-* @author ddj 2026年10月29号
-* @description: Host 侧的路径比较口径：远端身份保留大小写，其余按运行平台折叠。
-* @param path 路径
-* @returns 比较键
-*/
-function pathKey$1(path) {
-	return pathKeyFor(path, process.platform === "win32");
-}
-/**
-* @author ddj 2026年10月30号
-* @description: 判断两个路径是否指同一文件：比较键相同，或一方是另一方的工作区相对写法。
-* 面板传下来的路径可能是相对路径，而条目里存的是绝对路径。
-* @param left 路径
-* @param right 路径
-* @returns 是否同一文件
-*/
-function pendingSamePath(left, right) {
-	const a = pathKey$1(left);
-	const b = pathKey$1(right);
-	if (!a || !b) return false;
-	return a === b || a.endsWith("/" + b) || b.endsWith("/" + a);
-}
-/**
-* @author ddj 2026年10月30号
-* @description: 列表里的条目 id 带待审前缀用于区分通道，内核按原始身份存取，这里统一还原。
-* @param id 请求里的条目 id
-* @returns 待审内核使用的原始 id
-*/
-function pendingRawId(id) {
-	return id.startsWith("pending:") ? id.slice(8) : id;
-}
-/**
-* @author ddj 2026年10月30号
-* @description: 列表显示用的短路径：工作区内显示相对路径，区外保留原文。
-* @param cwd 工作区
-* @param path 条目路径
-* @returns 显示用路径
-*/
-function pendingDisplay(cwd, path) {
-	const root = cwd.replace(/[\\/]+$/, "");
-	const unified = path.replace(/\\/g, "/");
-	const base = root.replace(/\\/g, "/");
-	if (base && (unified === base || unified.toLowerCase().startsWith(base.toLowerCase() + "/"))) return unified.slice(base.length + 1);
-	return path;
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 待审条目转面板列表项。
-* @param item 待审条目
-* @param cwd 工作区，用于显示相对路径；缺省显示原始路径
-* @returns 面板列表项
-*/
-function pendingItemOf(item, cwd) {
-	return {
-		id: PENDING_PREFIX + item.id,
-		sessionId: item.sessionId,
-		turn: 0,
-		seq: stableSeq(item.id),
-		path: item.path,
-		currentPath: item.path,
-		display: cwd ? pendingDisplay(cwd, item.path) : item.path,
-		added: item.added,
-		deleted: item.deleted,
-		kind: item.oversized ? "oversized" : "text",
-		decision: item.settled ? "accepted" : "pending",
-		revision: item.revision,
-		current: true
-	};
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 待审详情转面板详情；Revert 映射到面板的 Undo 能力位。
-* @param detail 待审详情
-* @param capturedAt 采集时间文案
-* @returns 面板详情
-*/
-function pendingDetailOf(detail, capturedAt, cwd) {
-	return {
-		item: pendingItemOf(detail.item, cwd),
-		diff: detail.diff,
-		capturedAt,
-		blocks: detail.blocks,
-		capability: {
-			keep: detail.capability.keep,
-			undo: detail.capability.revert,
-			reason: detail.capability.reason
-		}
-	};
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 记住/忘记"该路径由待审投影接管"。进程内集合，绝不在旧写入口上查库（避免撞上写事务锁）。
-* @param cwd 工作区
-* @param path 路径
-* @param covered 是否接管
-* @returns 无
-*/
-function trackPendingCover(cwd, path, covered) {
-	const key = `${pathKey$1(cwd)}|${pathKey$1(path)}`;
-	if (covered) coveredPaths.add(key);
-	else coveredPaths.delete(key);
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 判断某路径是否已由待审投影接管；仅读进程内集合，不产生任何 IO。
-* @param cwd 工作区
-* @param path 请求路径
-* @returns 是否已被接管
-*/
-function pendingCovers(cwd, path) {
-	return coveredPaths.has(`${pathKey$1(cwd)}|${pathKey$1(path)}`);
-}
-/**
-* @author ddj 2026年10月29号
-* @description: 合并官方页与待审页：待审覆盖的路径从官方结果中剔除，其余原样保留。
-* @param official 官方页
-* @param pending 待审页
-* @param cwd 工作区，用于把待审行显示成相对路径
-* @returns 合并后的页
-*/
-function mergedPage(official, pending, cwd) {
-	const covered = /* @__PURE__ */ new Set();
-	for (const item of pending.items) {
-		covered.add(pathKey$1(item.path));
-		covered.add(pathKey$1(item.id));
-	}
-	const kept = official.items.filter((item) => !covered.has(pathKey$1(item.currentPath)) && !covered.has(pathKey$1(item.path)));
-	return {
-		items: [...pending.items.map((item) => pendingItemOf(item, cwd)), ...kept],
-		pending: pending.pending + kept.filter((item) => item.decision === "pending").length,
-		nextCursor: official.nextCursor,
-		gaps: official.gaps,
-		...official.overview ? { overview: official.overview } : {}
-	};
-}
-//#endregion
 //#region src/search/query.ts
 /**
 * 规范化用户搜索文本。
@@ -16040,6 +16636,7 @@ function finishUndo(cwd, request) {
 }
 //#endregion
 //#region src/reviewRpc.ts
+/** Session-scoped official review RPC. @author ddj 2026年10月26号 */
 /** 批量写入快照的硬上限：待审积压超过它说明状态异常，宁可拒绝也不做无界写循环。 */
 const BATCH_LIMIT = 2e3;
 /** 冷端 Undo 说明：Undo 会校验证据并写回源文件，只能在持有该会话的那一端执行。 */
@@ -16195,7 +16792,7 @@ function reviewHandlers(ctx, registry) {
 	*/
 	function pendingPageOf(cwd, sessionId) {
 		try {
-			const page = loadPage(cwd, sessionId, addedFiles(cwd, sessionId));
+			const page = loadPage(cwd, sessionId);
 			return page.items.some((item) => item.settled === true) ? {
 				...page,
 				items: page.items.filter((item) => item.settled !== true)
@@ -16209,6 +16806,99 @@ function reviewHandlers(ctx, registry) {
 			};
 		}
 	}
+	/**
+	* @private
+	* @author ddj 2026年11月03号
+	* @description: 按批次与条目派生幂等操作号：同一批次重放复用同一结果，不重复推进 revision。
+	* @param batchId 客户端批次身份
+	* @param id 条目身份
+	* @param seq 事件序号
+	* @returns 64 位 hex 操作号
+	*/
+	function operationOf(batchId, id, seq) {
+		return createHash("sha256").update(`${batchId}|${id}|${seq}`).digest("hex");
+	}
+	/**
+	* @private
+	* @author ddj 2026年11月03号
+	* @description: 取条目展示名，缺失时退回身份本身。
+	* @param items 本批条目
+	* @param id 条目身份
+	* @returns 展示名
+	*/
+	function displayOf(items, id) {
+		return items.find((item) => item.id === id)?.display ?? id;
+	}
+	/**
+	* @private
+	* @author ddj 2026年11月03号
+	* @description: 官方段的批量保留。段级异常只记进 result.error，不取消待审段。
+	* @param cwd 工作区
+	* @param batchId 批次身份
+	* @param items 官方条目
+	* @param result 汇总结果
+	* @returns 无
+	*/
+	function keepOfficialStage(cwd, batchId, items, result) {
+		try {
+			const outcome = keepOfficialAll(cwd, items.map((item) => ({
+				id: item.id,
+				seq: item.seq,
+				revision: item.revision,
+				operationId: operationOf(batchId, item.id, item.seq)
+			})));
+			result.completed += outcome.paths.length;
+			result.paths.push(...outcome.paths);
+			for (const skip of outcome.skipped) result.skipped.push({
+				id: skip.id,
+				display: displayOf(items, skip.id),
+				reason: skip.reason
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			log.warn(`[review] keepAll 官方段失败: ${message}`);
+			if (!result.error) result.error = message;
+		}
+	}
+	/**
+	* @private
+	* @author ddj 2026年11月03号
+	* @description: 待审段的批量保留。冷端只跳过待审条目（判定需要活跃会话），官方条目不受影响。
+	* @param scope 已解析作用域
+	* @param batchId 批次身份
+	* @param items 待审条目（带 pending 前缀）
+	* @param result 汇总结果
+	* @returns 无
+	*/
+	async function keepPendingStage(scope, batchId, items, result) {
+		if (!scope.live) {
+			for (const item of items) result.skipped.push({
+				id: item.id,
+				display: item.display,
+				reason: "待审条目需要在会话活跃的一端判定"
+			});
+			return;
+		}
+		const targets = items.map((item) => ({
+			id: item.id.slice(8),
+			display: item.display,
+			operationId: operationOf(batchId, item.id, item.seq)
+		}));
+		try {
+			const outcome = await keepAll(scope.cwd, targets);
+			result.completed += outcome.kept.length;
+			for (const entry of outcome.kept) result.paths.push(entry.path);
+			for (const skip of outcome.skipped) result.skipped.push({
+				id: PENDING_PREFIX + skip.id,
+				display: skip.display,
+				reason: skip.reason
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			log.warn(`[review] keepAll 待审段失败: ${message}`);
+			if (!result.error) result.error = message;
+		}
+	}
 	return {
 		"edrv.review.list": async (args) => {
 			const { cwd } = await scopeOf(args.sessionId);
@@ -16242,8 +16932,7 @@ function reviewHandlers(ctx, registry) {
 			const scope = await scopeOf(args.sessionId);
 			const cwd = scope.cwd;
 			if (args.id.startsWith("pending:")) {
-				const entryId = args.id.slice(8);
-				const detail = loadDetail(cwd, entryId, addedFiles(cwd, args.sessionId).has(entryId));
+				const detail = loadDetail(cwd, args.id.slice(8));
 				if (!detail) return {
 					ok: false,
 					error: "待审条目不存在"
@@ -16291,7 +16980,7 @@ function reviewHandlers(ctx, registry) {
 						decision: args.decision,
 						scope: args.scope === "hunk" ? "block" : "file",
 						...args.blockId === void 0 ? {} : { blockId: args.blockId }
-					});
+					}, void 0, policyOf(ctx, sessionOf(ctx, args.sessionId)));
 					if (!result.ok) return {
 						ok: false,
 						error: result.reason
@@ -16325,6 +17014,43 @@ function reviewHandlers(ctx, registry) {
 					error: message
 				};
 			}
+		},
+		"edrv.review.keepAll": async (args) => {
+			try {
+				const scope = await scopeOf(args.sessionId);
+				const items = Array.isArray(args.items) ? args.items : [];
+				if (!items.length) return {
+					ok: false,
+					error: "没有可保留的待审记录"
+				};
+				if (items.length > BATCH_LIMIT) return {
+					ok: false,
+					error: `待审记录过多（${items.length} 条，上限 ${BATCH_LIMIT}），请先分批处理后重试`
+				};
+				const result = {
+					completed: 0,
+					total: items.length,
+					paths: [],
+					skipped: [],
+					error: ""
+				};
+				const official = items.filter((item) => !item.id.startsWith(PENDING_PREFIX));
+				const pending = items.filter((item) => item.id.startsWith(PENDING_PREFIX));
+				if (official.length) keepOfficialStage(scope.cwd, args.batchId, official, result);
+				if (pending.length) await keepPendingStage(scope, args.batchId, pending, result);
+				log.info(`[review] keepAll live=${scope.live ? 1 : 0} total=${result.total} kept=${result.completed} skipped=${result.skipped.length}`);
+				return {
+					ok: true,
+					result
+				};
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				log.warn(`[review] keepAll 失败: ${message}`);
+				return {
+					ok: false,
+					error: message
+				};
+			}
 		}
 	};
 }
@@ -16392,17 +17118,15 @@ function readHandlers(kit) {
 	return {
 		"edrv.pending.list": async (args) => {
 			const cwd = await kit.read(args.sessionId);
-			const page = loadPage(cwd, args.sessionId, addedFiles(cwd, args.sessionId));
-			for (const item of page.items) trackPendingCover(cwd, item.path, true);
+			const page = loadPage(cwd, args.sessionId);
+			setPendingCovers(cwd, args.sessionId, page.items.map((item) => item.path));
 			return {
 				ok: true,
 				page
 			};
 		},
 		"edrv.pending.detail": async (args) => {
-			const cwd = await kit.read(args.sessionId);
-			const rawId = pendingRawId(args.id);
-			const detail = loadDetail(cwd, rawId, addedFiles(cwd, args.sessionId).has(rawId));
+			const detail = loadDetail(await kit.read(args.sessionId), pendingRawId(args.id));
 			return detail ? {
 				ok: true,
 				detail
@@ -16455,7 +17179,7 @@ function decideHandlers(kit) {
 			const id = pendingRawId(args.id);
 			const path = loadEntries(cwd).find((stored) => stored.entry.id === id)?.entry.path;
 			const removed = removeEntry(cwd, id, args.revision);
-			if (removed && path) trackPendingCover(cwd, path, false);
+			if (removed && path) trackPendingCover(cwd, path, false, args.sessionId);
 			return {
 				ok: true,
 				removed
@@ -16512,7 +17236,8 @@ function refreshHandlers(kit) {
 					includeUntracked: args.includeUntracked,
 					path: args.path
 				});
-				for (const item of loadPage(cwd, args.sessionId).items) trackPendingCover(cwd, item.path, true);
+				const page = loadPage(cwd, args.sessionId);
+				setPendingCovers(cwd, args.sessionId, page.items.map((item) => item.path));
 				return {
 					ok: true,
 					imported: result.imported,
@@ -16795,15 +17520,16 @@ function recView(record, ws = null) {
 	};
 }
 /**
-* 旧写入口守卫：路径已由待审累计基线接管时一律拒绝，避免两套权威同时写同一文件。
-* @author ddj 2026年10月29号
-* @param cwd 工作区
+* 旧写入口守卫：本会话可见的待审累计基线接管了该路径时一律拒绝，避免两套权威同时写同一文件。
+* 只按会话可见范围判定：别的会话在管、本会话看不见的条目不能拦人，否则用户无从处理。
+* @author ddj 2026年11月3号
+* @param sc 会话与工作区
 * @param path 请求涉及的路径（可为空表示无法定位）
 * @returns 拒绝原因，未接管时为 null
 */
-function legacyBlocked(cwd, path) {
+function legacyBlocked(sc, path) {
 	if (!path) return null;
-	if (!pendingCovers(cwd, path)) return null;
+	if (!pendingCovers(sc.cwd, path, sc.session.id)) return null;
 	return "该文件已由待审累计基线接管，请使用面板 Keep/Revert（edrv.review.decide）";
 }
 /** 会话/工作区公共前置：返回 {session,cwd} 或错误文案。 */
@@ -17309,6 +18035,7 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 					const staleStart = performance.now();
 					await autoArchiveStale(ctx, sc.session, sc.cwd, bucket);
 					await archiveCanceled(ctx, sc.session, sc.cwd, bucket);
+					await retireCovered(ctx, sc.session, sc.cwd, bucket);
 					staleMs = performance.now() - staleStart;
 				}
 			}
@@ -17380,7 +18107,7 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				error: sc.err
 			};
 			const bucket = await bucketOf(registry, ctx, sc.cwd);
-			const blocked = legacyBlocked(sc.cwd, bucket.get(args.callId)?.path);
+			const blocked = legacyBlocked(sc, bucket.get(args.callId)?.path);
 			if (blocked) return {
 				ok: false,
 				error: blocked
@@ -17407,7 +18134,7 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				error: sc.err
 			};
 			const bucket = await bucketOf(registry, ctx, sc.cwd);
-			const blocked = legacyBlocked(sc.cwd, bucket.get(args.callId)?.path);
+			const blocked = legacyBlocked(sc, bucket.get(args.callId)?.path);
 			if (blocked) return {
 				ok: false,
 				error: blocked
@@ -17433,7 +18160,7 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				ok: false,
 				error: sc.err
 			};
-			const blocked = legacyBlocked(sc.cwd, args.path);
+			const blocked = legacyBlocked(sc, args.path);
 			if (blocked) return {
 				ok: false,
 				error: blocked
@@ -17463,7 +18190,7 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 				ok: false,
 				error: sc.err
 			};
-			const blocked = legacyBlocked(sc.cwd, missingPath(args.token));
+			const blocked = legacyBlocked(sc, missingPath(args.token));
 			if (blocked) return {
 				ok: false,
 				error: blocked
@@ -17489,7 +18216,7 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 			};
 			const bucket = await bucketOf(registry, ctx, sc.cwd);
 			const items = Array.isArray(args.items) ? args.items : [];
-			const blocked = items.map((item) => legacyBlocked(sc.cwd, bucket.get(item.callId)?.path)).find((reason) => reason !== null);
+			const blocked = items.map((item) => legacyBlocked(sc, bucket.get(item.callId)?.path)).find((reason) => reason !== null);
 			if (blocked) return {
 				ok: false,
 				error: blocked
@@ -29579,7 +30306,7 @@ function attachRuntime(ctx, runtime) {
 	});
 	const pending = installPending(ctx, (write) => {
 		try {
-			trackPendingCover(write.cwd, write.path, true);
+			trackPendingCover(write.cwd, write.path, true, write.sessionId);
 		} catch {}
 		try {
 			recordWrite(write);