@xrn1997/dsh-session-delete 0.6.0 → 0.7.0

package/lib/index.js

@@ -1,18 +1,17 @@
 import path, { join, resolve } from "node:path";
-import zlib from "node:zlib";
-import { existsSync } from "node:fs";
 import { mkdir, readFile, readdir, realpath, rename, rm, stat } from "node:fs/promises";
+import zlib from "node:zlib";
 import { homedir } from "node:os";
 //#region src/shared/wire.ts
 /**
-* 跨半 wire 契约：前缀、九个端点、请求/响应形状与失败码。
+* 跨半 wire 契约：前缀、十个端点、请求/响应形状与失败码。
 * Node 半（src/api/dispatch.ts）与浏览器半（src/client/remote.ts）共用这一份，不各写字面量。
 *
 * 构建约束：本文件零运行时依赖、无 import；浏览器半把整个文件 inline 进 bundle。
 * 信封 {ok:true,value} / {ok:false,error:{code,message,details?}} 也是两半的共同契约。
 */
 /**
-* 插件专属前缀（九段相对它命名）。
+* 插件专属前缀（十段相对它命名）。
 *
 * 为什么必须带插件名：宿主 `connection.fetch.register` 对**重复的精确路径**直接抛错
 * （`connection: exact Fetch route "…" is already registered`），撞了就是整棵插件树 boot 失败——
@@ -20,11 +19,11 @@ import { homedir } from "node:os";
 */
 const SESSION_DELETE_API_PREFIX = "/dsh-session-delete-api";
 /**
-* 唯一的取数基础路径：宿主 `/api` + 插件前缀。九段 exact Fetch 路由、客户端探测与附件 URL
+* 唯一的取数基础路径：宿主 `/api` + 插件前缀。十段 exact Fetch 路由、客户端探测与附件 URL
 * 都从它起；`SESSION_DELETE_API_PREFIX` 只作为段名的相对前缀与错误原文。
 */
 const OFFICIAL_SESSION_DELETE_API_PREFIX = `/api${SESSION_DELETE_API_PREFIX}`;
-/** 九个段名（相对前缀）。**每项 `{ path, method }` 两键**：某段用什么方法也是线上形状的一部分
+/** 十段段名（相对前缀）。**每项 `{ path, method }` 两键**：某段用什么方法也是线上形状的一部分
 *  （ADR-0003），家就在这一张表——路由记录（`src/api/route-table.ts`）逐行投影（`ROUTES.x.method`），
 *  浏览器半的 GET 段同样投影、写段把 `ROUTES.x.method` 交给 `src/client/remote.ts` 的 `post()`，
 *  两半都不逐段手写一份。
@@ -39,7 +38,8 @@ const OFFICIAL_SESSION_DELETE_API_PREFIX = `/api${SESSION_DELETE_API_PREFIX}`;
 *    这一段只负责"有多少、在哪、多大"。
 *  - `attachment`：附件原始字节（全仓唯一的二进制响应段；失败仍回 JSON 信封）。
 *  - `attachmentOrphans`：无引用图片对象的扫描报告（纯读；数量/字节 + 供预览的对象清单）。
-*  - `attachmentClean`：清掉报告那一刻无引用的图片对象（聚合回执 `AttachmentCleanupWire`）。 */
+*  - `attachmentClean`：清掉报告那一刻无引用的图片对象（聚合回执 `AttachmentCleanupWire`）。
+*  - `config`：三只可调项的读/写共用一段——空体读当前值，带字段写回 profile 的 patch 层。 */
 const ROUTES = {
 	list: {
 		path: "/list",
@@ -50,6 +50,11 @@ const ROUTES = {
 		path: "/ping",
 		method: "GET"
 	},
+	/** 可调项：空体读（与 `/detail` 同法，用 POST 表达一个读）；带字段写，写必须进到达序链。 */
+	config: {
+		path: "/config",
+		method: "POST"
+	},
 	/** 单条详情（读回收站目录里那条会话自己的日志）。 */
 	detail: {
 		path: "/detail",
@@ -86,6 +91,22 @@ const ROUTES = {
 		method: "POST"
 	}
 };
+/** 三只可调项的接受范围（闭区间整数）。Node 半的归一与浏览器半的表单共用这一格：
+*  两处各写一份范围就会「表单说能存、宿主激活时说越界」。 */
+const CONFIG_LIMITS = {
+	orphanPreviewLimit: {
+		min: 1,
+		max: 1e4
+	},
+	maxAttachmentBytes: {
+		min: 1,
+		max: 209715200
+	},
+	maxJsonRefBytes: {
+		min: 1,
+		max: 104857600
+	}
+};
 /** 请求参数名：浏览器半发、Node 半读，同名同义（`empty` 没有入参）。
 *  附件段是 **query 参数**（GET 二进制响应，没有请求体）。 */
 const PARAMS = {
@@ -192,14 +213,21 @@ function carriedRollbackFailures(error) {
 }
 /** 原错误保留，回滚失败作为 `details.rollbackFailures` 上线；码仍按原错误的动词码，
 *  没有可继承的就落 io。**内层的回滚失败要并进来**：一个成员自己退失败、兄弟也退失败时，
-*  两份失败都得在 details 里，消息也不能出现第二个「回滚未完成」。 */
+*  两份失败都得在 details 里，消息也不能出现第二个「回滚未完成」。
+*  **原错误 details 的其余键原样保留**：孤儿清理的部分回执（`removed` / `freedBytes` /
+*  `failedSessionId`）就挂在它上面，整份替换会把已经发生的删除报成 0。 */
 function withRollbackFailures(error, failures) {
 	const code = verbCodeOf(error) ?? "io";
 	const carried = carriedRollbackFailures(error);
 	const merged = [.../* @__PURE__ */ new Set([...carried, ...failures])];
 	const base = error instanceof Error ? error.message : String(error);
 	const extra = failures.filter((failure) => !carried.includes(failure));
-	return verbError(code, base.includes("；回滚未完成：") ? extra.length > 0 ? `${base}；${extra.join("；")}` : base : `${base}；回滚未完成：${merged.join("；")}`, error, { rollbackFailures: merged });
+	const message = base.includes("；回滚未完成：") ? extra.length > 0 ? `${base}；${extra.join("；")}` : base : `${base}；回滚未完成：${merged.join("；")}`;
+	const priorDetails = error?.details;
+	return verbError(code, message, error, {
+		...priorDetails,
+		rollbackFailures: merged
+	});
 }
 //#endregion
 //#region src/remote/map-error.ts
@@ -922,6 +950,92 @@ async function memberMove(deps, presence, member, deletedAt, parentEntryId) {
 	};
 }
 //#endregion
+//#region src/ports/fs-port.ts
+/**
+* **缺席**只认 ENOENT 与 ENOTDIR（"路径中间有一截不是目录"与"不存在"是同一种回答）。
+*
+* EACCES / EIO / ELOOP / 断挂载**不是缺席**：这些读数说明"我们看不见"，不是"那里没有"。
+* 破坏性动作（删目录、删附件对象、按"没有引用"清共享图）据此做决定，把读不出折成没有
+* 就是数据消失；ADR-0039 是这条判据的裁决。
+*/
+function isAbsentPath(error) {
+	const code = error?.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+/** 模块级递归：端口方法**解构出来单独调**也不能靠 `this`（`{ sizeOfDir } = port` 会让方法体的
+*  `this` 变成 undefined）。所以端口只做转发，递归在模块作用域里自调。 */
+async function sizeOfDir(p) {
+	let total = 0;
+	for (const e of await readdir(p, { withFileTypes: true })) {
+		const child = join(p, e.name);
+		total += e.isDirectory() ? await sizeOfDir(child) : (await stat(child)).size;
+	}
+	return total;
+}
+/** 路径在不在：只有缺席两种错误回 `false`，其余读错误照抛。`exists` 与 `rename` 的目标检查共用。 */
+async function pathPresent(p) {
+	try {
+		await stat(p);
+		return true;
+	} catch (error) {
+		if (isAbsentPath(error)) return false;
+		throw error;
+	}
+}
+function createFsPort() {
+	return {
+		exists: pathPresent,
+		async ensureDir(p) {
+			await mkdir(p, { recursive: true });
+		},
+		async rename(from, to) {
+			if (await pathPresent(to)) throw new Error(`目标已存在，拒绝覆盖：${to}`);
+			try {
+				await rename(from, to);
+			} catch (error) {
+				if (error.code === "EXDEV") throw new Error(`跨文件系统搬不动（sessions 与 session-trash 需在同一卷）：${from} → ${to}`, { cause: error });
+				throw error;
+			}
+		},
+		async removeDir(p) {
+			await rm(p, {
+				recursive: true,
+				force: true
+			});
+		},
+		sizeOfDir: (p) => sizeOfDir(p),
+		async listFiles(p) {
+			return readdir(p);
+		},
+		async listDirs(p) {
+			const dirs = [];
+			for (const entry of await readdir(p, { withFileTypes: true })) {
+				if (entry.isDirectory()) {
+					dirs.push(entry.name);
+					continue;
+				}
+				if (!entry.isSymbolicLink()) continue;
+				try {
+					if ((await stat(join(p, entry.name))).isDirectory()) dirs.push(entry.name);
+				} catch {}
+			}
+			return dirs;
+		},
+		async realpath(p) {
+			return realpath(p);
+		},
+		async readFile(p) {
+			return readFile(p);
+		},
+		async statFile(p) {
+			return { size: (await stat(p)).size };
+		},
+		async removeFile(p) {
+			await rm(p, { force: true });
+		}
+	};
+}
+//#endregion
 //#region src/log/zstd-frames.ts
 const MAGIC = [
 	40,
@@ -1166,10 +1280,10 @@ function isRecord(value) {
 function numberOf(value) {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
 }
-/** `statFile` / `readFile` / `sizeOfDir` 里只有 ENOENT 能当"不在"；权限、盘挂、I/O 错误都必须露成读不出。 */
-function isMissing(error) {
-	return error?.code === "ENOENT";
-}
+/** 路径缺席的判据只有一处：`src/ports/fs-port.ts` 的 `isAbsentPath`（ENOENT / ENOTDIR）。
+*  `statFile` / `readFile` / `sizeOfDir` 的读错误里，"不在"只认这两枚；权限、盘挂、I/O 错误
+*  都必须露成读不出（ADR-0039），别在这里另写一份只有 ENOENT 的抄本。 */
+const isMissing = isAbsentPath;
 /** 合法附件 ID → 宿主附件库里的绝对路径。`name` 不参与拼接。 */
 function attachmentPathOf(home, kind, id) {
 	if (!isAttachmentId(id)) throw new Error(`附件 id 形状不对：${id}`);
@@ -1403,6 +1517,32 @@ async function collectRemainingImageRefs(deps, input) {
 	};
 }
 /**
+* 剩余引用扫描的 fail-closed 收口（独占计划 / 执行期复核 / 孤儿扫描三处共用同一形状）：扫描抛错或
+* 任一引用源读不出都回 `reason`，读得出才交引用集——「读不出」绝不折成「没有引用」（ADR-0020；
+* 缺席判据见 ADR-0039）。`reasonLabel` 只补"这次是为什么扫"的前半句，后半句是读数原文。
+*/
+async function remainingRefsFailClosed(deps, excludeDirs, reasonLabel) {
+	try {
+		const refs = await collectRemainingImageRefs(deps, {
+			sessionRoot: `${deps.home}/sessions`,
+			excludeDirs
+		});
+		if (refs.unreadable.length > 0) return {
+			ok: false,
+			reason: `${reasonLabel}：${refs.unreadable[0]}`
+		};
+		return {
+			ok: true,
+			refs
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			reason: `${reasonLabel}：${String(error)}`
+		};
+	}
+}
+/**
 * 独占计划：候选 = 本次被删会话日志里的图片 id；剩余引用 = 活动会话 + 全部未删 `session-trash`
 * 目录 + storages/cache。
 * 剩余引用源读不出 ⇒ 整体跳过；候选日志读不出 / 附件对象 stat 失败 ⇒ 只跳过那一部分，其余照常。
@@ -1425,24 +1565,13 @@ async function planImageAttachmentRemoval(deps, removedDirs) {
 		bytes: 0,
 		...skipReasons.length > 0 ? { skipped: skipReasons.join("；") } : {}
 	};
-	let remaining;
-	try {
-		remaining = await collectRemainingImageRefs(deps, {
-			sessionRoot: `${deps.home}/sessions`,
-			excludeDirs: removedDirs
-		});
-	} catch (error) {
-		return {
-			entries: [],
-			bytes: 0,
-			skipped: `读不到剩余引用源，无法证明独占：${String(error)}`
-		};
-	}
-	if (remaining.unreadable.length > 0) return {
+	const scanned = await remainingRefsFailClosed(deps, removedDirs, "读不到剩余引用源，无法证明独占");
+	if (!scanned.ok) return {
 		entries: [],
 		bytes: 0,
-		skipped: `读不到剩余引用源，无法证明独占：${remaining.unreadable[0]}`
+		skipped: scanned.reason
 	};
+	const remaining = scanned.refs;
 	const entries = [];
 	let bytes = 0;
 	let unreadableObjects = 0;
@@ -1469,6 +1598,31 @@ async function planImageAttachmentRemoval(deps, removedDirs) {
 	};
 }
 /**
+* 执行期复核：计划与真删对象之间隔着一整趟目录删除（秒级），这期间别的会话可能把同一张图
+* （内容寻址 ⇒ 同一个 sha256 id）再引用一次，或派生存储新写一条引用。计划是数据、会过期；
+* 删对象之前用同一套剩余引用扫描再判一次，**只删这一刻仍无引用的那些**（ADR-0041）。
+*
+* 调用时机：会话 / 回收站目录已经删掉之后、`executeImageAttachmentRemoval` 之前——那时被删的
+* 引用源已经不在了，扫到的就是真正的"剩余"。读不出照旧 fail closed：回空计划 + `skipped`，
+* 宁可留下孤儿也不删共享。空计划直接返回（不为零删付一次全 home 扫描）。
+*/
+async function recheckImageRemovalExclusivity(deps, plan) {
+	if (plan.entries.length === 0) return plan;
+	const scanned = await remainingRefsFailClosed(deps, [], "读不到剩余引用源，无法复核独占");
+	if (!scanned.ok) return {
+		entries: [],
+		bytes: 0,
+		skipped: plan.skipped === void 0 ? scanned.reason : `${plan.skipped}；${scanned.reason}`
+	};
+	const remaining = scanned.refs;
+	const entries = plan.entries.filter((entry) => !remaining.ids.has(entry.id));
+	return {
+		entries,
+		bytes: entries.reduce((total, entry) => total + entry.bytes, 0),
+		...plan.skipped === void 0 ? {} : { skipped: plan.skipped }
+	};
+}
+/**
 * 逐文件删；ENOENT 由端口的 `force` 吞掉；其他错误计数并继续。
 *
 * 删除动作只认「`home` + `id` 自己推导出来的那一条路径」：计划是数据，手搭的/被改过的条目
@@ -1521,24 +1675,13 @@ const OBJECT_NAME = /^[0-9a-f]{64}$/u;
 * 对象列表或 stat 读不出同样整份跳过：报告宁可失败，也不给一份"少算了一些"的清理计划。
 */
 async function scanOrphanImageAttachments(deps) {
-	let remaining;
-	try {
-		remaining = await collectRemainingImageRefs(deps, {
-			sessionRoot: `${deps.home}/sessions`,
-			excludeDirs: []
-		});
-	} catch (error) {
-		return {
-			entries: [],
-			bytes: 0,
-			skipped: `读不到引用源，无法判定孤儿附件：${String(error)}`
-		};
-	}
-	if (remaining.unreadable.length > 0) return {
+	const scanned = await remainingRefsFailClosed(deps, [], "读不到引用源，无法判定孤儿附件");
+	if (!scanned.ok) return {
 		entries: [],
 		bytes: 0,
-		skipped: `读不到引用源，无法判定孤儿附件：${remaining.unreadable[0]}`
+		skipped: scanned.reason
 	};
+	const remaining = scanned.refs;
 	const objectsRoot = `${deps.home}/attachments/v1/objects`;
 	const entries = [];
 	let bytes = 0;
@@ -1597,9 +1740,9 @@ async function cleanOrphanImageAttachments(deps) {
 * purge / orphan-clean 的删除计划（{@link planMemberRemovals}）才付——executor 摘账本要用它。
 */
 /** `exists → sizeOfDir` 的唯一一条度量口径（成员目录与回收站目录共用）：先问在不在，再量字节；
-*  ENOENT 是唯一一种当"不在"的失败，别的错误照旧响亮。别再在调用点各写一遍这段 try/catch。
+*  缺席（ENOENT / ENOTDIR）才是"不在"，别的错误照旧响亮（ADR-0039）。别再在调用点各写一遍这段 try/catch。
 *
-*  **已知粒度**：`sizeOfDir` 递归里撞到的 ENOENT 与"目录本身没了"是同一个码，所以目录里某个文件
+*  **已知粒度**：`sizeOfDir` 递归里撞到的缺席与"目录本身没了"是同一个码，所以目录里某个文件
 *  恰好在这一拍消失时，整条目录会被记成「不在」（`/list` 少算这条、删除计划里没有可删的字节，
 *  而清册行照旧摘——盘上留下目录等下一次 `reconcile` 重建成行，自愈、不丢数据）。复核一次
 *  `exists(dir)` 能把两者分开，却会让「宿主正在写、文件刚被挪走」这类正常竞态把 `/list` 整个打红——
@@ -1811,15 +1954,20 @@ async function planOrphanRemoval(deps, members) {
 *
 * 顺序：整批摘归档集 → 摘有账本的成员的账本 → 逐条回收站行
 * （在才删目录 → 摘清册行 → 通告成员离场）→ 逐条盘上成员（删目录 → 通告成员离场）→ 逐条附件对象。
-* 目录删掉就没有"退回去"这回事，中途失败**不回滚**；已经删掉的由下面的计数器如实交回。
-*
-* 附件清理排在**所有会话目录删完之后**：对象只在会话真的没了之后才动；单文件失败只进
-* `attachments.failed`，不影响（也不回滚）会话删除的回执。
+* 目录删掉就没有"退回去"这回事，中途失败**不回滚目录**；已经删掉的由下面的计数器如实交回。
+* **归档态回滚**：`unarchive` 排在所有删除之前（免得留下"会话没了、归档集还挂着"的幽灵 id），
+* 所以中途失败时目录还在、归档位却已经摘了。失败出口把**目录还在**的那些（这一趟没删掉、也不是计划时
+* 就缺席）按删除前的读数重新归档（`isArchived` 先读过一次，不是按 `wasArchived` 猜）；目录不在的跳过
+* ——那时恢复归档只会造幽灵 id。
+* 回滚自己的失败走 `details.rollbackFailures`，不让它把原错误吞掉（ADR-0040）。
+* **附件计划在执行期复核**：计划到删对象之间的窗口里新增的引用会让计划过期；删对象前用同一套
+* 剩余引用扫描重判一次，只删这一刻仍无引用的对象（ADR-0041）。
 *
 * 失败形状：
 * - `kind:'orphan'`（orphan-clean）⇒ `io` + `{removed, freedBytes, failedSessionId}`，不伪装成整组没动；
 * - `kind:'trash'`（purge）⇒ 同一个标签、不带 details；
-* - orphan-clean 的 unarchive / detach 原样抛出。
+* - orphan-clean 的归档实况预读 / unarchive / detach 原样抛出；
+* - 归档态回滚不干净时，原错误带 `details.rollbackFailures`（码仍按原错误的动词码）。
 *
 * 通告只经 `member-presence`（摘活体三态 + `api-session/removed`），不在这里另写一份。
 */
@@ -1841,7 +1989,7 @@ async function executeRemoval(deps, plan) {
 		} : void 0;
 		throw verbError("io", `${label}：${String(error)}`, error, details);
 	};
-	/** 退归档集 / 摘账本这一步的失败形状：purge 折成带标签的 `io`；orphan-clean 原样抛。 */
+	/** 归档实况预读 / 退归档集 / 摘账本这一步的失败形状：purge 折成带标签的 `io`；orphan-clean 原样抛。 */
 	const step = async (label, sessionId, run) => {
 		if (plan.kind === "orphan") {
 			await run();
@@ -1853,49 +2001,79 @@ async function executeRemoval(deps, plan) {
 			fail(label, error, sessionId);
 		}
 	};
-	for (const sessionId of plan.unarchive) await step("取消归档失败", sessionId, () => deps.host.unarchive(sessionId));
-	for (const member of plan.members) {
-		const workspaceId = member.workspaceId;
-		if (workspaceId === void 0) continue;
-		await step("摘账本失败", member.sessionId, () => deps.host.detach(member.sessionId, workspaceId));
-	}
-	for (const row of plan.trash) {
-		if (row.present) {
+	const archivedBefore = /* @__PURE__ */ new Set();
+	for (const sessionId of plan.unarchive) await step("读取归档状态失败", sessionId, async () => {
+		if (await deps.host.isArchived(sessionId)) archivedBefore.add(sessionId);
+	});
+	/** 走到过 `unarchive` 这一步的 id（含失败那一条）：失败时按它回滚。 */
+	const unarchived = [];
+	/** 计划时目录还在的 id：只有这些会话还有本体可挂归档。计划时就缺席的行 / 成员也在 `unarchive`
+	*  名单里（那一步顺带清幽灵 id），但没有目录可回滚。 */
+	const onDisk = /* @__PURE__ */ new Set([...plan.trash.filter((row) => row.present).map((row) => row.entry.sessionId), ...plan.members.map((member) => member.sessionId)]);
+	/** 目录已经真删掉的 id：没有归档态可放回去，跳过——否则会在 registry 里留下幽灵 id。 */
+	const deleted = /* @__PURE__ */ new Set();
+	try {
+		for (const sessionId of plan.unarchive) {
+			unarchived.push(sessionId);
+			await step("取消归档失败", sessionId, () => deps.host.unarchive(sessionId));
+		}
+		for (const member of plan.members) {
+			const workspaceId = member.workspaceId;
+			if (workspaceId === void 0) continue;
+			await step("摘账本失败", member.sessionId, () => deps.host.detach(member.sessionId, workspaceId));
+		}
+		for (const row of plan.trash) {
+			if (row.present) {
+				try {
+					await deps.fs.removeDir(row.dir);
+				} catch (error) {
+					fail("删除回收站目录失败", error, row.entry.sessionId);
+				}
+				deleted.add(row.entry.sessionId);
+				freedSoFar += row.bytes;
+			}
 			try {
-				await deps.fs.removeDir(row.dir);
+				await deps.ledger.remove(row.entry.id);
 			} catch (error) {
-				fail("删除回收站目录失败", error, row.entry.sessionId);
+				fail("摘除回收站条目失败", error, row.entry.sessionId);
 			}
-			freedSoFar += row.bytes;
+			removed += 1;
+			await presence.memberGone(row.entry.sessionId);
 		}
-		try {
-			await deps.ledger.remove(row.entry.id);
-		} catch (error) {
-			fail("摘除回收站条目失败", error, row.entry.sessionId);
+		const memberLabel = plan.kind === "trash" ? "删除盘上后代目录失败" : "删除会话目录失败";
+		for (const member of plan.members) {
+			try {
+				await deps.fs.removeDir(member.dir);
+			} catch (error) {
+				fail(memberLabel, error, member.sessionId);
+			}
+			deleted.add(member.sessionId);
+			removed += 1;
+			freedSoFar += member.bytes;
+			await presence.memberGone(member.sessionId);
 		}
-		removed += 1;
-		await presence.memberGone(row.entry.sessionId);
-	}
-	const memberLabel = plan.kind === "trash" ? "删除盘上后代目录失败" : "删除会话目录失败";
-	for (const member of plan.members) {
-		try {
-			await deps.fs.removeDir(member.dir);
-		} catch (error) {
-			fail(memberLabel, error, member.sessionId);
+		const attachmentPlan = await recheckImageRemovalExclusivity(deps, plan.attachments);
+		const attachments = await executeImageAttachmentRemoval(deps, attachmentPlan);
+		return {
+			removed,
+			freedBytes: plan.bytes,
+			attachments: {
+				...attachments,
+				...attachmentPlan.skipped === void 0 ? {} : { skipped: attachmentPlan.skipped }
+			}
+		};
+	} catch (error) {
+		const rollbackFailures = [];
+		for (const sessionId of [...unarchived].reverse()) {
+			if (!archivedBefore.has(sessionId) || deleted.has(sessionId) || !onDisk.has(sessionId)) continue;
+			try {
+				await deps.host.archive(sessionId);
+			} catch (rollbackError) {
+				rollbackFailures.push(rollbackReason("恢复归档失败", rollbackError));
+			}
 		}
-		removed += 1;
-		freedSoFar += member.bytes;
-		await presence.memberGone(member.sessionId);
+		throw rollbackFailures.length === 0 ? error : withRollbackFailures(error, rollbackFailures);
 	}
-	const attachments = await executeImageAttachmentRemoval(deps, plan.attachments);
-	return {
-		removed,
-		freedBytes: plan.bytes,
-		attachments: {
-			...attachments,
-			...plan.attachments.skipped === void 0 ? {} : { skipped: plan.attachments.skipped }
-		}
-	};
 }
 //#endregion
 //#region src/verbs/orphan-subagents.ts
@@ -2002,6 +2180,7 @@ async function cleanOrphanGroup(deps, group) {
 //#endregion
 //#region src/ports/agent-handles.ts
 const CAPTURED_AGENT_HANDLES = Symbol.for("dsh-session-delete.captured-agent-handles");
+const CAPTURED_AGENT_WRAPPERS = Symbol.for("dsh-session-delete.captured-agent-wrappers");
 /** 在 `ctx.agents` 上包一层 `resume` / `create`，把返回的 agent handle 的 dispose 按会话 id 记下。
 *  服务缺席时走 `ctx.inject(['agents'])` **等服务挂上再装**——live profile 的插件激活顺序可能早于
 *  `agents` 服务就绪；只在 apply 时 `get` 一次会让捕获静默缺席（真机症状：重启前在回收站的能冷恢复，
@@ -2010,14 +2189,46 @@ const CAPTURED_AGENT_HANDLES = Symbol.for("dsh-session-delete.captured-agent-han
 *  **安装时机**：先 `get('agents')`，没装成再 `inject(['agents'])`（两者只装一次，符号表兜住）。
 *  **symbol 表**：句柄表挂在服务实例的 {@link CAPTURED_AGENT_HANDLES} 上；同一个 agents 服务上的第二次
 *  安装（`get` 与 `inject` 各一次，或第二个 `createHostPort`）看见它就直接共用，不把 wrapper 套第二层。
+*  **安装者拥有 wrapper**：包装记录先在闭包里留一份（`ownWrappers`，建立于 symbol 写入之前），同时挂到
+*  {@link CAPTURED_AGENT_WRAPPERS}；第一次成功安装时经 `ctx.effect` 注册一条卸载恢复——按 own property
+*  descriptor 的身份把 `resume` / `create` 写回目标自有的原函数（`restoreTo`；代理读回的影子不写回，
+*  别人后装的 wrapper 不动），并摘掉仍归本闭包的 symbol 表。恢复是总的：一条写回失败不跳过其余记录。
+*  恢复一次即锁死：晚到的安装与晚到的 handle 落地都被 `restored` 挡住。没有 `ctx.effect`（假件 / 旧 ctx）
+*  时包装照装，只是没有恢复。
 *  **读回判据**：cordis 的 traceable 服务代理每次读函数都会新包一层（`get` 里的 `createShadowMethod`），
 *  所以只能看 own property descriptor 的身份；拿 `service[name]` 读回比身份是必然的假警报。
 */
 function captureAgentHandles(ctx) {
 	let handles = /* @__PURE__ */ new Map();
+	/** 本闭包装上的包装记录：symbol 写入是 best-effort，恢复不能只靠它。 */
+	let ownWrappers;
 	let installed = false;
+	/** 卸载恢复只跑一次；同时是「清理之后不再安装、不再捕获」的闸。 */
+	let restored = false;
+	/**
+	* 卸载恢复：按记录倒序把仍是我们装的方法写回 `restoreTo`，再摘掉仍是本闭包那张表的 symbol 并清空
+	* 句柄表。身份判据挡两件事：别人后装的 wrapper 不被覆盖；别人换过的 symbol 表不被误删。
+	* 恢复必须走完：一条写回失败只跳过那一条，摘 symbol 与清表在 `finally` 里照做。
+	*/
+	const restore = (service) => {
+		if (restored) return;
+		restored = true;
+		const records = ownWrappers ?? service[CAPTURED_AGENT_WRAPPERS] ?? [];
+		try {
+			for (const record of [...records].reverse()) try {
+				if (Object.getOwnPropertyDescriptor(service, record.name)?.value === record.wrapped) service[record.name] = record.restoreTo;
+			} catch {}
+		} finally {
+			try {
+				if (service[CAPTURED_AGENT_HANDLES] === handles) Reflect.deleteProperty(service, CAPTURED_AGENT_HANDLES);
+				if (service[CAPTURED_AGENT_WRAPPERS] === records) Reflect.deleteProperty(service, CAPTURED_AGENT_WRAPPERS);
+			} finally {
+				handles.clear();
+			}
+		}
+	};
 	const install = (candidate) => {
-		if (installed) return;
+		if (installed || restored) return;
 		const service = candidate;
 		if (service === void 0 || service === null) return;
 		const existing = service[CAPTURED_AGENT_HANDLES];
@@ -2026,13 +2237,17 @@ function captureAgentHandles(ctx) {
 			installed = true;
 			return;
 		}
+		const wrappers = [];
 		let wrappedCount = 0;
 		for (const name of ["resume", "create"]) try {
 			const original = service[name];
 			if (typeof original !== "function") continue;
+			const own = Object.getOwnPropertyDescriptor(service, name)?.value;
+			const restoreTo = typeof own === "function" ? own : original;
 			const wrapped = function(...args) {
 				const result = Reflect.apply(original, this, args);
 				result.then((value) => {
+					if (restored) return;
 					const handle = value;
 					const id = handle?.agent?.id;
 					const dispose = handle?.dispose;
@@ -2045,13 +2260,24 @@ function captureAgentHandles(ctx) {
 			};
 			service[name] = wrapped;
 			if (Object.getOwnPropertyDescriptor(service, name)?.value !== wrapped) throw new Error(`agents.${name} is not writable`);
+			wrappers.push({
+				name,
+				original,
+				restoreTo,
+				wrapped
+			});
 			wrappedCount += 1;
 		} catch {}
 		if (wrappedCount === 0) return;
+		ownWrappers = wrappers;
 		try {
 			service[CAPTURED_AGENT_HANDLES] = handles;
+			service[CAPTURED_AGENT_WRAPPERS] = wrappers;
 		} catch {}
 		installed = true;
+		try {
+			ctx.effect?.(() => () => restore(service), "session-delete.agent-handles");
+		} catch {}
 	};
 	const service = ctx.get("agents");
 	if (service !== void 0 && service !== null) install(service);
@@ -2079,6 +2305,21 @@ function liveSessionsOf(ctx) {
 	if (typeof store.get !== "function" || typeof store.liveEntryFor !== "function") return void 0;
 	return store;
 }
+/**
+* 会话 header 的**公开**读面：live `sessions.get(id).header` 优先（保留宿主原来的优先级），
+* 否则 `sessionPersistence.stat(id).header`。未知会话回 `undefined`；需要落到持久化时服务缺席 /
+* 形状不符抛错，由调用方决定是响亮失败（projectDirOf）还是降级（titleOf 的空串）。
+*/
+async function headerOf(host, sessionId) {
+	const store = liveSessionsOf(host);
+	if (store !== void 0) try {
+		const live = store.get(sessionId);
+		if (live?.header !== void 0) return live.header;
+	} catch {}
+	const persistence = host.get("sessionPersistence");
+	if (persistence === void 0 || persistence === null || typeof persistence.stat !== "function") throw new Error("session-delete: sessionPersistence 服务缺席");
+	return (await persistence.stat(sessionId))?.header;
+}
 /** 官方的「这些父的孩子」那一支：`kind:'parent'` 的判据逐字是 `values.includes(record.header.parentSession ?? null)`。
 *  它只按 `parentSession` 原样匹配，**不是**子会话分类器：旧宿主（≤0.2.1-rc.5）的普通 fork 也写
 *  `parentSession`，0.2.2-alpha.2 起才不写。子会话的判据是 `origin` 的 subagent 标记（宿主归档闸、归档
@@ -2174,15 +2415,6 @@ function projectionCacheOf(ctx) {
 	if (typeof cache.cachedSnapshot !== "function" || typeof cache.cachedPredecessorTitle !== "function") return void 0;
 	return cache;
 }
-/** 宿主 `readSessionHeader` 对未知会话抛的是裸 `Error`，只认这句；真存储故障照抛，不能折成未命中。
-*  出处：asar `dsh-workspace/lib/types/index.js` 的
-*  `cannot validate session '${id}': session persistence holds no such session`。
-*  同文件有类型的近似句是 `WorkspaceUnknownSessionError`（`hold` 无 `s`），不会误伤。 */
-const NO_SUCH_SESSION = "session persistence holds no such session";
-/** 只认上面那一句；其余（含非 Error 抛出物）一律**不算未命中**。 */
-function isUnknownSession(error) {
-	return error instanceof Error && error.message.includes(NO_SUCH_SESSION);
-}
 /** 宿主会话表的一次取数（`ctx.sessionController.list()` 的两种返回形状都折成数组）。
 *  服务没挂 / 形状不对 / 抛错 ⇒ 空表——**这条不替宿主兜错误**：调用方拿空表的语义都是"少发一条通告"，
 *  不是"恢复失败"。 */
@@ -2223,23 +2455,20 @@ function createHostPort(ctx) {
 		},
 		/**
 		* cwd → 宿主项目目录名；没有 cwd 落到 `_no-cwd`。
-		* 账本里没有这个会话回 `undefined`（未命中，不是故障）；真存储故障照抛。
+		* header 走公开面（live `sessions` → `sessionPersistence.stat`）；未知会话回 `undefined`
+		* （未命中，不是故障）；服务缺席/真存储故障照抛。
 		* 未命中由 `delete-session.ts` 折成 `not-found`，真故障留 `io`——两者不能混。
 		*/
 		async projectDirOf(sessionId) {
-			let header;
-			try {
-				header = await registry.readSessionHeader(sessionId);
-			} catch (error) {
-				if (isUnknownSession(error)) return void 0;
-				throw error;
-			}
+			const header = await headerOf(host, sessionId);
+			if (header === void 0) return void 0;
 			return header.cwd === void 0 ? NO_CWD_PROJECT_DIR : projectKey(header.cwd);
 		},
-		/** 标题走宿主投影缓存；尽力取，取不到返回空串，绝不因此让删除失败。 */
+		/** 标题走宿主投影缓存；header 来自公开的 live/持久化读面，尽力取，取不到返回空串。 */
 		async titleOf(sessionId) {
 			try {
-				const header = await registry.readSessionHeader(sessionId);
+				const header = await headerOf(host, sessionId);
+				if (header === void 0) return "";
 				const cache = projectionCacheOf(host);
 				const title = (cache?.cachedSnapshot(header, ["title"]) ?? cache?.cachedPredecessorTitle(header))?.values.title;
 				return typeof title === "string" ? title : "";
@@ -2673,6 +2902,111 @@ function applyActions(deps, action, ids) {
 	}
 }
 //#endregion
+//#region src/config.ts
+/**
+* 可调项（Config，ADR-0037）：三只旋钮 + 本地 Standard Schema。
+*
+* 为什么不用 `@deepseek-ai/schemastery` 写 schema：那是宿主包，值 import 会破本仓「跨插件一律
+* `import type`」的硬约束；Cordis 的 Config 接受 Standard Schema（`@standard-schema/spec`），
+* 手写这一小段即可，不需要把宿主 schema 库搬进插件。代价是宿主只为 native Schemastery schema 投影
+* 字段表单，这枚手写的 Standard Schema 不在其列——字段表单由插件设置页的「可调项」卡提供
+* （ADR-0043），profile 的 `cordis.patch.yml` 仍是默认值与覆盖的家。
+*
+* 这里只做**默认值、归一与 schema**，不持有运行期现场：`apply` 归一一次，结果作为
+* `CoreDeps.config` 注入；读方从自己的 deps 读，不 import 模块级单例。
+* 客户端 6 秒撤销时长不在这里：它是浏览器半的产品决定，不跨半传。
+*/
+const DEFAULT_CONFIG = Object.freeze({
+	orphanPreviewLimit: 200,
+	maxAttachmentBytes: 20971520,
+	maxJsonRefBytes: 10485760
+});
+function intField(input, key, range) {
+	const value = input[key];
+	if (value === void 0) return DEFAULT_CONFIG[key];
+	if (typeof value !== "number" || !Number.isInteger(value) || value < range.min || value > range.max) throw new Error(`配置项 ${key} 需为 ${range.min}..${range.max} 的整数`);
+	return value;
+}
+/**
+* 把 patch 里的 `config` 归一成完整配置：缺省取默认值，未知键 / 非整数 / 越界都抛。
+* 抛错会让插件激活失败（响亮），而不是悄悄用半套配置跑。
+*/
+function normalizeConfig(value) {
+	if (value === void 0 || value === null) return DEFAULT_CONFIG;
+	if (typeof value !== "object" || Array.isArray(value)) throw new Error("配置需为对象");
+	const input = value;
+	const known = new Set(Object.keys(CONFIG_LIMITS));
+	for (const key of Object.keys(input)) if (!known.has(key)) throw new Error(`未知配置项：${key}`);
+	return {
+		orphanPreviewLimit: intField(input, "orphanPreviewLimit", CONFIG_LIMITS.orphanPreviewLimit),
+		maxAttachmentBytes: intField(input, "maxAttachmentBytes", CONFIG_LIMITS.maxAttachmentBytes),
+		maxJsonRefBytes: intField(input, "maxJsonRefBytes", CONFIG_LIMITS.maxJsonRefBytes)
+	};
+}
+/**
+* 插件 Config：Cordis 接受 Standard Schema，`~standard.validate` 交回归一后的配置。
+* 宿主在激活前校验；`apply` 再归一一次（同一份事实，不会漂）。
+*/
+const Config = { "~standard": {
+	version: 1,
+	vendor: "dsh-session-delete",
+	validate(value) {
+		try {
+			return { value: normalizeConfig(value) };
+		} catch (error) {
+			return { issues: [{ message: error instanceof Error ? error.message : String(error) }] };
+		}
+	}
+} };
+//#endregion
+//#region src/verbs/config.ts
+/**
+* `/config` 的读/写动词：三只可调项的当前值与写回。
+*
+* 读是免费快照（`apply` 归一后的那一份），写才碰宿主：
+* - 先按 `src/config.ts` 的 `normalizeConfig` 校验（未知键 / 非整数 / 越界回 400，不拿半套值写盘）；
+* - 再走宿主 `configEditor.edit(entry, change)`：完整 raw config 落进 profile 的 patch 层，
+*   由编辑器串行化、校验并让这一行重启（字段不是 volatile，重启是它给的语义）。
+* - `configEditor` / `entry` 缺席（老宿主、嵌套上下文）回 `io` 并在原文里说清替代路径——
+*   不静默假装保存成功。
+*
+* `entry` 由组合根从 `ctx.fiber.entry` 取（见 `src/index.ts`）；本文件不碰 ctx。
+*/
+/** `/config` 的请求体：`null` 或 `{}` 是读；只要带一个键就当写（未知键由 {@link normalizeConfig} 400 拒掉）。
+*  路由表按同一句话定纯度，所以别在别处再写一遍这个判据。 */
+function configPatchOf(body) {
+	if (body === null || Object.keys(body).length === 0) return void 0;
+	return body;
+}
+/** 空体 = 读当前值；带字段 = 写。请求体已经由适配器解析成对象或 null。 */
+function readOrSaveConfig(deps, body) {
+	const patch = configPatchOf(body);
+	if (patch === void 0) return deps.config;
+	return saveConfig(deps, patch);
+}
+async function saveConfig(deps, patch) {
+	let next;
+	try {
+		next = normalizeConfig({
+			...deps.config,
+			...patch
+		});
+	} catch (error) {
+		throw routeError("bad-request", 400, error instanceof Error ? error.message : String(error));
+	}
+	const editor = deps.configEditor;
+	if (editor === void 0 || deps.entry === void 0) throw verbError("io", "这一代宿主不能保存配置；请直接改 profile 的 cordis.patch.yml");
+	try {
+		await editor.edit(deps.entry, (current) => ({
+			...current,
+			...next
+		}));
+	} catch (error) {
+		throw verbError("io", `配置没有保存：${error instanceof Error ? error.message : String(error)}`, error);
+	}
+	return next;
+}
+//#endregion
 //#region src/trash/detail.ts
 /**
 * 回收站**单条详情**：从回收站目录里那条会话自己的日志读出元信息与正文块（用例见 `tests/trash-detail.test.ts`）。
@@ -3440,7 +3774,7 @@ function requireIdArray(body) {
 	return value;
 }
 /**
-* 九个段名各一行。`Record<段名, AnyRouteSpec>` 是闸：`wire.ts` 加了段名而这里没加，编译不过；
+* 十个段名各一行。`Record<段名, AnyRouteSpec>` 是闸：`wire.ts` 加了段名而这里没加，编译不过；
 * 每行的 `slice` 又把该行的 `run` 钉在自己那一格 deps 上（ADR-0032）。
 */
 const ROUTE_TABLE = {
@@ -3462,6 +3796,15 @@ const ROUTE_TABLE = {
 		response: "json",
 		run: async () => "pong"
 	},
+	[ROUTES.config.path]: {
+		slice: "config",
+		method: ROUTES.config.method,
+		body: "json",
+		purity: (body) => configPatchOf(body) === void 0 ? "pure" : "chained",
+		read: "none",
+		response: "json",
+		run: async (deps, body) => readOrSaveConfig(deps, body)
+	},
 	[ROUTES.attachment.path]: {
 		slice: "attachment",
 		method: ROUTES.attachment.method,
@@ -3545,7 +3888,7 @@ function routeOf(rest) {
 /**
 * /dsh-session-delete-api 的分发核心：只负责路由记录的执行。
 *
-* 传输适配器只有 `src/api/connection-route.ts` 一个：九段注册到宿主 `connection.fetch.register`
+* 传输适配器只有 `src/api/connection-route.ts` 一个：十段注册到宿主 `connection.fetch.register`
 * 的 exact Fetch 路由（`Request` / `Response`），Host/Origin/浏览器认证由宿主 `/api` bridge 完成
 * （ADR-0033）。`Request` 的字节闸 / JSON 解析、`Response` 的头与失败信封都归适配器；
 * 这里只收已经解析好的请求，做查表 → 按段注入窄面 → 跑处理 → 回结果。
@@ -3605,7 +3948,7 @@ function removalOf(full) {
 		config: full.config
 	};
 }
-/** 四格只建一次：收窄对象在 dispatcher 构造期固定，请求路径只做引用选择。 */
+/** 五格只建一次：收窄对象在 dispatcher 构造期固定，请求路径只做引用选择。 */
 function slicesOf(full) {
 	const core = coreOf(full);
 	return {
@@ -3615,6 +3958,11 @@ function slicesOf(full) {
 		attachment: {
 			...core,
 			attachments: full.attachments
+		},
+		config: {
+			...core,
+			...full.configEditor === void 0 ? {} : { configEditor: full.configEditor },
+			...full.entry === void 0 ? {} : { entry: full.entry }
 		}
 	};
 }
@@ -3665,7 +4013,7 @@ function createDispatcher(deps) {
 //#endregion
 //#region src/api/connection-route.ts
 /**
-* 现代宿主的 exact Fetch 路由适配器：把九段注册到 `connection.fetch.register`，
+* 现代宿主的 exact Fetch 路由适配器：把十段注册到 `connection.fetch.register`，
 * 由宿主 `/api` bridge 做 Host/Origin/浏览器认证（ADR-0033）。
 *
 * 为什么路径必须带 `/api`：宿主 `assertFetchRoute` 用 `endpointFromPath('/api', path)` 校验，
@@ -3797,11 +4145,14 @@ function toResponse(result) {
 	});
 	return new Response(JSON.stringify(result.body), {
 		status: result.status,
-		headers: { "content-type": "application/json; charset=utf-8" }
+		headers: {
+			"content-type": "application/json; charset=utf-8",
+			"cache-control": "private, no-store"
+		}
 	});
 }
 /**
-* 注册九段 exact Fetch 路由。返回一个组合 disposer；调用方把它挂在自己的 effect 上。
+* 注册十段 exact Fetch 路由。返回一个组合 disposer；调用方把它挂在自己的 effect 上。
 * `connection` 是插件的硬依赖（web UI / 桌面端都装 `client-connection`）；`fetch.register`
 * 缺席属于宿主形状漂移，直接抛——静默返回空 disposer 会让插件「在但没有入口」。
 * `dispatch` 与分发器同源。
@@ -3845,131 +4196,6 @@ function registerConnectionRoutes(service, dispatch) {
 	return disposeAll;
 }
 //#endregion
-//#region src/config.ts
-const DEFAULT_CONFIG = Object.freeze({
-	orphanPreviewLimit: 200,
-	maxAttachmentBytes: 20971520,
-	maxJsonRefBytes: 10485760
-});
-const LIMITS = {
-	orphanPreviewLimit: {
-		min: 1,
-		max: 1e4
-	},
-	maxAttachmentBytes: {
-		min: 1,
-		max: 209715200
-	},
-	maxJsonRefBytes: {
-		min: 1,
-		max: 104857600
-	}
-};
-function intField(input, key, range) {
-	const value = input[key];
-	if (value === void 0) return DEFAULT_CONFIG[key];
-	if (typeof value !== "number" || !Number.isInteger(value) || value < range.min || value > range.max) throw new Error(`配置项 ${key} 需为 ${range.min}..${range.max} 的整数`);
-	return value;
-}
-/**
-* 把 patch 里的 `config` 归一成完整配置：缺省取默认值，未知键 / 非整数 / 越界都抛。
-* 抛错会让插件激活失败（响亮），而不是悄悄用半套配置跑。
-*/
-function normalizeConfig(value) {
-	if (value === void 0 || value === null) return DEFAULT_CONFIG;
-	if (typeof value !== "object" || Array.isArray(value)) throw new Error("配置需为对象");
-	const input = value;
-	const known = new Set(Object.keys(LIMITS));
-	for (const key of Object.keys(input)) if (!known.has(key)) throw new Error(`未知配置项：${key}`);
-	return {
-		orphanPreviewLimit: intField(input, "orphanPreviewLimit", LIMITS.orphanPreviewLimit),
-		maxAttachmentBytes: intField(input, "maxAttachmentBytes", LIMITS.maxAttachmentBytes),
-		maxJsonRefBytes: intField(input, "maxJsonRefBytes", LIMITS.maxJsonRefBytes)
-	};
-}
-/**
-* 插件 Config：Cordis 接受 Standard Schema，`~standard.validate` 交回归一后的配置。
-* 宿主在激活前校验；`apply` 再归一一次（同一份事实，不会漂）。
-*/
-const Config = { "~standard": {
-	version: 1,
-	vendor: "dsh-session-delete",
-	validate(value) {
-		try {
-			return { value: normalizeConfig(value) };
-		} catch (error) {
-			return { issues: [{ message: error instanceof Error ? error.message : String(error) }] };
-		}
-	}
-} };
-//#endregion
-//#region src/ports/fs-port.ts
-/** 模块级递归：端口方法**解构出来单独调**也不能靠 `this`（`{ sizeOfDir } = port` 会让方法体的
-*  `this` 变成 undefined）。所以端口只做转发，递归在模块作用域里自调。 */
-async function sizeOfDir(p) {
-	let total = 0;
-	for (const e of await readdir(p, { withFileTypes: true })) {
-		const child = join(p, e.name);
-		total += e.isDirectory() ? await sizeOfDir(child) : (await stat(child)).size;
-	}
-	return total;
-}
-function createFsPort() {
-	return {
-		async exists(p) {
-			return existsSync(p);
-		},
-		async ensureDir(p) {
-			await mkdir(p, { recursive: true });
-		},
-		async rename(from, to) {
-			if (existsSync(to)) throw new Error(`目标已存在，拒绝覆盖：${to}`);
-			try {
-				await rename(from, to);
-			} catch (error) {
-				if (error.code === "EXDEV") throw new Error(`跨文件系统搬不动（sessions 与 session-trash 需在同一卷）：${from} → ${to}`, { cause: error });
-				throw error;
-			}
-		},
-		async removeDir(p) {
-			await rm(p, {
-				recursive: true,
-				force: true
-			});
-		},
-		sizeOfDir: (p) => sizeOfDir(p),
-		async listFiles(p) {
-			return readdir(p);
-		},
-		async listDirs(p) {
-			const dirs = [];
-			for (const entry of await readdir(p, { withFileTypes: true })) {
-				if (entry.isDirectory()) {
-					dirs.push(entry.name);
-					continue;
-				}
-				if (!entry.isSymbolicLink()) continue;
-				try {
-					if ((await stat(join(p, entry.name))).isDirectory()) dirs.push(entry.name);
-				} catch {}
-			}
-			return dirs;
-		},
-		async realpath(p) {
-			return realpath(p);
-		},
-		async readFile(p) {
-			return readFile(p);
-		},
-		async statFile(p) {
-			return { size: (await stat(p)).size };
-		},
-		async removeFile(p) {
-			await rm(p, { force: true });
-		}
-	};
-}
-//#endregion
 //#region src/ports/home.ts
 /**
 * 宿主数据根。官方解析器在 asar `dsh/node_modules/@deepseek-ai/dsh-home-paths/lib/index.js`：
@@ -4227,14 +4453,15 @@ const name = "@xrn1997/dsh-session-delete";
 * 三项都是在隔离数据根上实测注入成功、且本插件真正用到的宿主服务。**不进 inject 的**：
 * - `remote`：那是**浏览器半**的服务（asar `dsh-api-gateway/lib/client.js`：`super(ctx, "remote")`），
 *   Node 半挂的是 `ctx.typertGateway`。把它写进 Node 半的 inject 会让插件永远 pending（同 `slots` 那次的形状）。
-* - `sessions` / `sessionProjectionCache`：两者都按 `ctx.get(...)` **可选读**——`sessions` 只给 `evictLive`
-*   用（活跃判据走 waterfall，见 src/ports/host-port.ts；服务缺席回 `unknown`），`sessionProjectionCache` 是标题的尽力读面。
-*   inject 一个可能没挂的服务 = 整个插件 pending。
-*   它取不到时 `titleOf` 返回空串，正是契约允许的降级。
+* - `sessions` / `sessionProjectionCache` / `sessionPersistence`：都按 `ctx.get(...)` **可选读**——
+*   `sessions` 给 `evictLive` 和 live header 用（活跃判据走 waterfall，见 src/ports/host-port.ts；
+*   服务缺席回 `unknown`），`sessionProjectionCache` 是标题的投影读面，`sessionPersistence` 是
+*   `projectDirOf` / `titleOf` 的公开 header 读面（workspaceRegistry 硬注入它，标准组合必有）。
+*   inject 一个可能没挂的服务 = 整个插件 pending；标题取不到时 `titleOf` 返回空串，正是契约允许的降级。
 * - `agents`：只给 handle 捕获用（`ctx.get('agents')`；缺席时 `ctx.inject(['agents'])` 等服务就绪再装）。
 *   它同样可能晚于本插件激活，写进插件 inject 只会让整个插件 pending。
 *
-* `connection` 是浏览器半取数通道的唯一承载者：九段注册到 `connection.fetch.register` 的
+* `connection` 是浏览器半取数通道的唯一承载者：十段注册到 `connection.fetch.register` 的
 * `/api/dsh-session-delete-api/*`，Host/Origin/浏览器认证由宿主 `/api` bridge 完成（ADR-0033）。
 * 支持面是 web UI 与桌面端，二者的标准组合都装 `client-connection`；服务缺席时插件停在 pending
 * ——可见的激活失败，而不是静默地没有入口。`webServer` 不再直接使用：exact route 仍由宿主的
@@ -4262,6 +4489,8 @@ function apply(ctx, rawConfig) {
 	const home = resolveHome();
 	const rawManifest = createHostStorageManifest(ctx);
 	const host = createHostPort(ctx);
+	const configEditor = ctx.get("configEditor");
+	const entry = ctx.fiber?.entry;
 	const deps = {
 		fs,
 		host,
@@ -4270,7 +4499,9 @@ function apply(ctx, rawConfig) {
 		presence: createMemberPresence(host),
 		config,
 		attachments: createAttachmentsPort(ctx),
-		now: () => Date.now()
+		now: () => Date.now(),
+		...configEditor === void 0 ? {} : { configEditor },
+		...entry === void 0 ? {} : { entry }
 	};
 	const connection = ctx.get("connection");
 	if (connection === void 0) throw new Error("session-delete: connection 服务缺席");