dsh-manage-session 0.3.3 → 0.4.8

package/lib/index.js

@@ -183,885 +183,1205 @@ function pruneArchiveFile(ids, log, searchPaths) {
 	throw new Error(lastReason);
 }
 //#endregion
-//#region src/host/history/purge.ts
-/**
-* 归档文件清理（**真删除**）—— 会话管家唯一的破坏性操作。
-*
-* 与「取消归档状态」（`pruneArchiveFile`）是**两件事**，刻意分开：
-*
-* | | 取消归档状态 | 清理归档文件 |
-* |---|---|---|
-* | 改什么 | 只改 `global.archivedSessionIds` | 删磁盘实体 **+** 改两处 id |
-* | 会话 | 回到侧边栏 | 从世界上消失 |
-* | 可逆 | 重启即生效 | 不可逆 |
-*
-* 「清理归档文件」必须**连带**执行「取消归档状态」：文件删了、id 还留在数组里，
-* 就是一条僵尸归档 —— 侧边栏看不见它，一旦被取消归档又会冒出一个打不开的空会话。
-*
-* 一次清理动 4 处：
-* 1. `~/.dsh/sessions/<工作区>/<会话id>/` —— 整个目录（可能含 `session.jsonl.zstd`
-*    与旧格式 `session.v3.jsonl.zstd` 两份，所以必须整目录删，不能只删当前格式）
-* 2. `~/.dsh/storages/session_projcache/sessions/<会话id>.json` —— 逐条投影缓存
-* 3. `workspace.json` → `global.archivedSessionIds`
-* 4. `workspace.json` → `tables.workspaces.*.sessionIds`
-*
-* 执行顺序是**先改文件、后删实体**：改文件是原子的且可整体中止（失败则一个字节都没删）；
-* 反过来先删实体再改文件，中途失败会留下僵尸 id。
-*/
-/** 转录根目录（`<dshHome>/sessions`）。 */
-function sessionsRootFor(dshHome) {
-	return join(dshHome, "sessions");
-}
+//#region src/host/health/decode.ts
 /**
-* 投影缓存（**逐条布局**）根目录。
+* 会话日志读取链路（`log-integrity` gate 与 `lossless-json` gate 的共同底座）。
 *
-* 注意另有一个 `<dshHome>/storages/session_projcache.json`（整份布局）——
-* 那是布局迁移留下的**化石**，宿主早已不再写它，本插件也不碰它。
-*/
-function projCacheRootFor(dshHome) {
-	return join(dshHome, "storages", "session_projcache", "sessions");
-}
-/**
-* 会话 id 的目录名归一化。
+* 链路与 `_tools/dsh-session-invariant-repro.mjs` 的 `decodeSessionLog` 一致：
+*   zstd 多帧扫描（撕裂尾帧用 ZSTD_e_flush 抢救）→ 逐行 JSON.parse
+*   → provenance 展开（storage 形态的 seq ranges）→ `decodeStorageRecord` 解包
+*   （`text-chunks` / `reasoning-chunks` / `tool-call-chunks` 展开回 `assistant/chunk`）
+*   → seq 连续性校验（提交区出现缺口即停止并按 prefix 语义处理）。
 *
-* 归档集合里一律是 `session-<uuid>`，但子会话的目录名是不带前缀的 `<uuid>`，
-* 两者必须视为同一个会话，否则清理会「找不到文件」而静默什么都没删。
+* 解码器优先使用宿主真实的 `@deepseek-ai/dsh-session`（运行时按需软加载，零硬依赖）；
+* 不可用时使用本文件内的等价实现（同格式：dt 为**时间**增量、成员数 = dt.length + 1；
+* provenance 存储形态为 `[[start,end],…]` 区间编码）。二者的差异会被显式记入
+* `decoder` 字段，禁止静默回退。
 */
-function dirKey(name) {
-	return name.startsWith("session-") ? name.slice(8) : name;
-}
-/** 是不是目录（读不到就当不是）。 */
-function isDir(path) {
-	try {
-		return statSync(path).isDirectory();
-	} catch {
-		return false;
+/** zstd 帧魔数（0xFD2FB528 的小端读取值）。 */
+const ZSTD_MAGIC = 4247762216;
+/** 打包行类型（读路径必须解包）。 */
+const PACKED_ROWS = /* @__PURE__ */ new Set([
+	"text-chunks",
+	"reasoning-chunks",
+	"tool-call-chunks"
+]);
+/** 扫描拼接的 zstd 多帧；返回完整帧范围与撕裂尾帧起点。 */
+function scanZstdFrames(buffer) {
+	const frames = [];
+	let offset = 0;
+	while (offset < buffer.length) {
+		const start = offset;
+		if (buffer.length - offset < 4) return {
+			frames,
+			tornStart: start
+		};
+		if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC) return {
+			frames,
+			tornStart: start
+		};
+		offset += 4;
+		if (offset === buffer.length) return {
+			frames,
+			tornStart: start
+		};
+		const descriptor = buffer.readUInt8(offset);
+		offset += 1;
+		if ((descriptor & 24) !== 0) return {
+			frames,
+			tornStart: start
+		};
+		const contentSizeFlag = descriptor >>> 6;
+		const singleSegment = (descriptor & 32) !== 0;
+		const checksum = (descriptor & 4) !== 0;
+		const dictionaryFlag = descriptor & 3;
+		const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+		const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
+		const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+		if (buffer.length - offset < remainingHeaderBytes) return {
+			frames,
+			tornStart: start
+		};
+		offset += remainingHeaderBytes;
+		for (;;) {
+			if (buffer.length - offset < 3) return {
+				frames,
+				tornStart: start
+			};
+			const blockHeader = buffer.readUIntLE(offset, 3);
+			offset += 3;
+			const lastBlock = (blockHeader & 1) !== 0;
+			const blockType = blockHeader >>> 1 & 3;
+			const blockSize = blockHeader >>> 3;
+			if (blockType === 3) return {
+				frames,
+				tornStart: start
+			};
+			const payloadBytes = blockType === 1 ? 1 : blockSize;
+			if (buffer.length - offset < payloadBytes) return {
+				frames,
+				tornStart: start
+			};
+			offset += payloadBytes;
+			if (lastBlock) break;
+		}
+		if (checksum) {
+			if (buffer.length - offset < 4) return {
+				frames,
+				tornStart: start
+			};
+			offset += 4;
+		}
+		frames.push({
+			start,
+			end: offset
+		});
 	}
+	return { frames };
 }
-/**
-* 扫一遍转录根，建立「会话 id → 目录」索引。
-*
-* 同一个 id 同时存在带前缀与不带前缀的目录时，**优先带 `session-` 前缀的那个**
-* （归档集合里的 id 本身带前缀）。
-* @param sessionsRoot - `<dshHome>/sessions`。
-* @returns 归一化 id → 目录绝对路径。
-*/
-function indexSessionDirs(sessionsRoot) {
-	const map = /* @__PURE__ */ new Map();
-	if (!existsSync(sessionsRoot)) return map;
-	for (const workspace of readdirSync(sessionsRoot)) {
-		const wsDir = join(sessionsRoot, workspace);
-		if (!isDir(wsDir)) continue;
-		for (const name of readdirSync(wsDir)) {
-			const entry = join(wsDir, name);
-			if (!isDir(entry)) continue;
-			const key = dirKey(name);
-			const existing = map.get(key);
-			const prefer = name.startsWith("session-") && existing !== void 0 && !basename(existing).startsWith("session-");
-			if (existing === void 0 || prefer) map.set(key, entry);
+/** 存储形态的 provenance（`[[start,end],…]` 区间编码或直接 seq 数组）展开为递增 seq 列表。 */
+function decodeSeqRangesStorage(value, currentSeq) {
+	if (!Array.isArray(value)) throw new Error("sourceEventSeqs must be an array when present");
+	const out = [];
+	for (const entry of value) {
+		if (typeof entry === "number") {
+			out.push(entry);
+			continue;
 		}
+		if (Array.isArray(entry) && entry.length === 2) {
+			const [start, end] = entry;
+			if (typeof start !== "number" || typeof end !== "number" || end < start) throw new Error("sourceEventSeqs range is malformed");
+			for (let seq = start; seq <= end; seq += 1) out.push(seq);
+			continue;
+		}
+		throw new Error("sourceEventSeqs entry is neither a seq nor a [start,end] range");
 	}
-	return map;
+	for (const seq of out) if (!Number.isSafeInteger(seq) || seq < 0 || seq >= currentSeq) throw new Error(`sourceEventSeqs must reference earlier events: ${seq} >= ${currentSeq}`);
+	return out;
 }
-/** 递归求目录占用字节数（读不到的条目跳过，不抛错）。 */
-function dirSize(dir) {
-	let total = 0;
-	let entries;
-	try {
-		entries = readdirSync(dir, { withFileTypes: true });
-	} catch {
-		return 0;
+/** 本地等价实现：把一行存储记录解包为事件（打包行展开为 assistant/chunk）。 */
+function decodeRecordLocal(value) {
+	if (typeof value !== "object" || value === null) return [value];
+	const record = value;
+	const type = record["type"];
+	if (typeof type !== "string" || !PACKED_ROWS.has(type)) {
+		const seq = record["seq"];
+		if (typeof seq === "number" && (!Number.isSafeInteger(seq) || seq < 0)) throw new Error(`session event seq ${String(seq)} is not a non-negative safe integer`);
+		return [record];
 	}
-	for (const entry of entries) {
-		const path = join(dir, entry.name);
-		if (entry.isDirectory()) total += dirSize(path);
-		else try {
-			total += statSync(path).size;
-		} catch {}
+	const data = record["data"];
+	if (data === void 0) throw new Error(`malformed ${type} storage row: data must be an object`);
+	const members = type === "tool-call-chunks" ? data["args"] : data["texts"];
+	if (!Array.isArray(members) || members.length === 0 || members.some((entry) => typeof entry !== "string")) throw new Error(`malformed ${type} storage row: payload must be a non-empty string array`);
+	const dt = data["dt"];
+	if (!Array.isArray(dt) || dt.some((gap) => !Number.isSafeInteger(gap))) throw new Error(`malformed ${type} storage row: dt must be an array of safe integers`);
+	if (dt.length !== members.length - 1) throw new Error(`malformed ${type} storage row: dt length ${dt.length} does not match ${members.length} members`);
+	const seq0 = record["seq0"];
+	const time0 = record["time0"];
+	if (typeof seq0 !== "number" || typeof time0 !== "number") throw new Error(`malformed ${type} storage row: seq0/time0 must be numbers`);
+	const turn = data["turn"];
+	const step = data["step"];
+	const index = data["index"];
+	const out = [];
+	let time = time0;
+	for (let k = 0; k < members.length; k += 1) {
+		if (k > 0) time += dt[k - 1];
+		let chunk;
+		if (type === "text-chunks") chunk = {
+			type: "text-delta",
+			index,
+			text: members[k]
+		};
+		else if (type === "reasoning-chunks") chunk = {
+			type: "reasoning-delta",
+			index,
+			text: members[k]
+		};
+		else chunk = {
+			type: "tool-call-delta",
+			index,
+			id: typeof data["id"] === "string" ? data["id"] : "",
+			...typeof data["name"] === "string" ? { name: data["name"] } : {},
+			argumentsDelta: members[k]
+		};
+		out.push({
+			type: "assistant/chunk",
+			seq: seq0 + k,
+			time,
+			data: {
+				turn,
+				step,
+				chunk
+			}
+		});
 	}
-	return total;
+	return out;
 }
 /**
-* 解析一批会话在磁盘上的实体与占用（**只读，不删任何东西**）。
-*
-* 列表按行显示体积就走这里 —— 体积差异极大（实测单条缓存可达 23 MB、单条转录可达
-* 6 MB，也有 0 字节的），报一个总量对用户没有意义。
-* @param ids - 会话 id（带不带 `session-` 前缀都接受）。
-* @param dshHome - DSH 主目录。
-* @returns 会话 id → 实体位置与占用。
-*/
-function locateSessionUsage(ids, dshHome) {
-	const dirs = indexSessionDirs(sessionsRootFor(dshHome));
-	const cacheRoot = projCacheRootFor(dshHome);
-	const out = /* @__PURE__ */ new Map();
-	for (const sessionId of ids) {
-		const key = dirKey(sessionId);
-		const usage = {
-			sessionId,
-			bytes: 0,
-			cacheBytes: 0
-		};
-		const dir = dirs.get(key);
-		if (dir !== void 0) {
-			usage.dir = dir;
-			usage.bytes = dirSize(dir);
+* 读取一个会话日志文件（zip 帧扫描 + 解包 + seq 连续性）。
+* @param file - 当前代日志的绝对路径（由代次解析得出，不假定具体文件名）。
+* @param bytes - 文件内容（调用方读取，便于测试注入）。
+* @param decoders - 可选官方解码器（缺省用本地等价实现）。
+* @returns 事件、统计与问题清单。
+*/
+function decodeSessionLogBytes(file, bytes, decoders) {
+	const { frames, tornStart } = scanZstdFrames(bytes);
+	const parts = [];
+	const frameIssues = [];
+	for (const frame of frames) try {
+		parts.push(zlib.zstdDecompressSync(bytes.subarray(frame.start, frame.end)));
+	} catch (err) {
+		frameIssues.push(`frame@${frame.start}: ${String(err instanceof Error ? err.message : err)}`);
+	}
+	let recoveredFromTorn = 0;
+	if (tornStart !== void 0) try {
+		const recovered = zlib.zstdDecompressSync(bytes.subarray(tornStart), { finishFlush: zlib.constants.ZSTD_e_flush });
+		recoveredFromTorn = recovered.length;
+		parts.push(recovered);
+	} catch {}
+	const lines = Buffer.concat(parts).toString("utf8").split("\n").filter((line) => line.trim() !== "");
+	const issues = frameIssues.map((why, index) => ({
+		line: index + 1,
+		why
+	}));
+	const decodeRecord = decoders?.decodeStorageRecord ?? decodeRecordLocal;
+	const events = [];
+	for (let index = 1; index < lines.length; index += 1) {
+		const line = lines[index];
+		let decoded;
+		try {
+			const parsed = JSON.parse(line);
+			decoded = decodeRecord(parsed["sourceEventSeqs"] === void 0 ? parsed : {
+				...parsed,
+				sourceEventSeqs: decoders?.decodeSeqRanges !== void 0 && typeof parsed["seq"] === "number" ? decoders.decodeSeqRanges(parsed["sourceEventSeqs"], parsed["seq"]) : decodeSeqRangesStorage(parsed["sourceEventSeqs"], Number(parsed["seq"] ?? 0))
+			});
+		} catch (err) {
+			issues.push({
+				line: index + 1,
+				why: `decode failed: ${String(err instanceof Error ? err.message : err)}`
+			});
+			break;
 		}
-		for (const name of [`${sessionId}.json`, `${key}.json`]) {
-			const candidate = join(cacheRoot, name);
-			if (existsSync(candidate)) {
-				usage.cacheFile = candidate;
-				try {
-					usage.cacheBytes = statSync(candidate).size;
-				} catch {}
+		const rowStart = events.length;
+		let gapped = false;
+		for (const event of decoded) {
+			if (event.seq !== events.length) {
+				issues.push({
+					line: index + 1,
+					why: `seq gap (expected ${events.length}, got ${event.seq})`
+				});
+				events.length = rowStart;
+				gapped = true;
 				break;
 			}
+			events.push(event);
 		}
-		out.set(sessionId, usage);
+		if (gapped) break;
 	}
-	return out;
+	const openStep = findOpenStep(events);
+	let header;
+	const headerLine = lines[0];
+	if (headerLine !== void 0) try {
+		const parsed = JSON.parse(headerLine);
+		if (typeof parsed === "object" && parsed !== null) header = parsed;
+	} catch {}
+	return {
+		events,
+		frames: frames.length,
+		...tornStart === void 0 ? {} : { tornStart },
+		recoveredFromTorn,
+		issues,
+		decoder: decoders === void 0 ? "local" : "official",
+		...openStep === void 0 ? {} : { openStep },
+		...header === void 0 ? {} : { header }
+	};
 }
+/** 从文件读取并解码。 */
+function decodeSessionLogFile(file, decoders) {
+	return decodeSessionLogBytes(file, readFileSync(file), decoders);
+}
+/** 尾部未收尾的 open step（有 step/start 无对应 step/end）。 */
+function findOpenStep(events) {
+	let open;
+	for (const event of events) {
+		const data = event.data;
+		if (event.type === "step/start" && typeof data?.turn === "number" && typeof data?.step === "number") {
+			open = {
+				turn: data.turn,
+				step: data.step
+			};
+			continue;
+		}
+		if (event.type === "step/end") open = void 0;
+	}
+	return open;
+}
+//#endregion
+//#region src/host/health/source-kind.ts
 /**
-* 断言目标是 `root` 的**直接子项**（层级也校验）。
+* 插件署名格式（source kind）体检门与转换。
 *
-* 破坏性操作不能只靠「路径拼对了」—— 拼错一层就是删掉整个 sessions 根。
-* @param root - 允许的父目录。
-* @param target - 待删目标。
-* @param depth - 相对 root 的期望层数。
-* @returns 是否安全。
+* ## 背景：会话格式 v4 的署名要求
+*
+* 宿主 0.1.7-rc.1 起（会话格式 v4）废弃裸 `source: { kind: 'plugin', plugin: '<name>' }`
+* 的署名方式，要求每条插件写入的消息使用生产者自有 kind（`plugin:<name>`）。
+* 校验失败时**整轮失败**（SessionFormatError），不是丢一条消息。
+* 修复模式（与已适配的 aegis、dsh-better-sidebar 一致）：
+*   `{ kind: 'plugin', plugin: '<name>' }` → `{ kind: 'plugin:<name>' }`（删除 plugin 字段）。
+*
+* ## 版本依赖表（各格式代次依赖的宿主固定版本与处置策略）
+*
+* | 格式代次 | 宿主版本线          | 旧署名行是否合法 | 处置策略                                   |
+* |---|---|---|---|
+* | v1       | 未考证（早期线）     | 合法             | 不动（leave-asis）                          |
+* | v2       | 未考证               | 合法             | 不动                                        |
+* | v3       | 0.1.6 时代（待考证） | 合法             | 不动：宿主 v3→v4 迁移负责，插件越权改写属过度操作 |
+* | v4       | ≥ 0.1.7-rc.1（已实锤）| **拒绝**（SessionFormatError） | 检测 + 可选转换（本模块） |
+*
+* 判定依据是**日志 header 的 version 字段**（`decode.ts` 已解析为 `SessionLogRead.header`），
+* 不猜文件名、不猜宿主安装版本：同一份磁盘语料可能混有多条版本线的产物，
+* 每份日志按它自己的 header 代次走对应的策略线。
+*
+* ## 红线（与 repair.ts 的红线关系）
+*
+* repair.ts 的红线是「禁止改写会话日志」。本模块的转换是**经用户显式触发的唯一例外**：
+* 只改 `source.kind` / `source.plugin` 两个署名字段，其余字节原样保留；改前整文件备份；
+* 日志完整性不合格（撕裂尾帧 / 解码失败 / seq 缺口）或代次不在 v4 线时**拒绝执行**。
+* 这三道闸缺一不可，否则就退化成「静默改历史数据」。
 */
-function isSafeChild(root, target, depth) {
-	const rel = relative(resolve(root), resolve(target));
-	if (rel === "" || rel.startsWith("..") || resolve(root, rel) !== resolve(target)) return false;
-	return rel.split(sep).filter((part) => part !== "").length === depth;
+/** v4 线起点的宿主版本（会话格式 v4 引入 producer-owned source kind）。 */
+const V4_HOST_MIN = "0.1.7-rc.1";
+/** 从解码后的日志提取旧署名事实（只读）。 */
+function readSourceKindFacts(log) {
+	const byPlugin = {};
+	const examples = [];
+	for (const event of log.events) {
+		const source = event.data?.source;
+		if (source === void 0 || typeof source !== "object" || source.kind !== "plugin" || typeof source.plugin !== "string" || source.plugin === "") continue;
+		byPlugin[source.plugin] = (byPlugin[source.plugin] ?? 0) + 1;
+		if (examples.length < 5) examples.push({
+			seq: event.seq,
+			plugin: source.plugin
+		});
+	}
+	const headerVersion = typeof log.header?.["version"] === "number" ? log.header["version"] : void 0;
+	return {
+		legacyCount: Object.values(byPlugin).reduce((sum, n) => sum + n, 0),
+		byPlugin,
+		examples,
+		...headerVersion === void 0 ? {} : { headerVersion }
+	};
 }
-/** 单次清理的最大 id 数（与 prune 一致）。 */
-const MAX_PURGE_IDS = 5e3;
 /**
-* `session-history-purge`：**真删除**归档会话的磁盘实体，并连带取消其归档状态。
-* @param payload - `{ sessionIds: string[] }`。
-* @param log - 可选日志出口。
-* @param options - `dshHome` 必填；`searchPaths` 可选覆盖。
-* @returns 清理条数、释放字节数与逐条失败。
+* gate 5：插件署名格式（v4 线要求 producer-owned kind）。
+*
+* 档位判据（有据才抬档）：
+* - header.version ≥ 4 且观测到旧署名行 → `warn`：v4 校验拒绝这种署名；存量行让
+*   未适配插件的读回判断（`kind === 'plugin' && plugin === name`）失配，转换可消除；
+* - header.version < 4 → `ok`：v3 及更早线旧行合法，宿主迁移负责，**不动**（防过度操作）；
+* - header.version 无从读取 → `skipped`：无从判定该走哪条版本线。
+* @param facts - 旧署名事实；undefined 表示未提供（无日志）。
 */
-function purgeHistory(payload, log, options) {
-	const dshHome = options?.dshHome;
-	if (dshHome === void 0 || dshHome === "") return {
-		ok: false,
-		error: "缺少 dshHome：破坏性清理拒绝在未知路径上执行"
+function gateSourceKind(facts) {
+	if (facts === void 0) return {
+		id: "source-kind",
+		level: "skipped",
+		evidence: "未提供日志读取结果，本门无从判定"
 	};
-	const record = payload;
-	if (!Array.isArray(record?.sessionIds) || record.sessionIds.length === 0) return {
-		ok: false,
-		error: "缺少 sessionIds 数组"
+	const version = facts.headerVersion;
+	const plugins = Object.entries(facts.byPlugin);
+	const detail = {
+		headerVersion: version,
+		legacyCount: facts.legacyCount,
+		byPlugin: facts.byPlugin,
+		examples: facts.examples,
+		v4HostMin: V4_HOST_MIN
+	};
+	if (version === void 0) return {
+		id: "source-kind",
+		level: "skipped",
+		evidence: "日志 header 无 version 字段，无从判定格式代次线",
+		detail
 	};
-	const ids = [...new Set(record.sessionIds.filter((id) => typeof id === "string" && id !== ""))];
-	if (ids.length === 0) return {
-		ok: false,
-		error: "sessionIds 无有效值"
+	if (version < 4) return {
+		id: "source-kind",
+		level: "ok",
+		evidence: `格式代次 v${version}（v4 之前的版本线）：旧署名行合法，宿主 v3→v4 迁移负责，不做转换` + (plugins.length > 0 ? `（观测到 ${plugins.reduce((s, [, n]) => s + n, 0)} 行旧署名，按策略不动）` : ""),
+		detail
 	};
-	if (ids.length > 5e3) return {
-		ok: false,
-		error: `单次最多清理 ${MAX_PURGE_IDS} 个`
+	if (plugins.length === 0) return {
+		id: "source-kind",
+		level: "ok",
+		evidence: `格式代次 v${version}：全部插件署名均为 producer-owned kind（plugin:<name>）`,
+		detail
 	};
-	const wanted = new Set(ids);
-	const usage = locateSessionUsage(ids, dshHome);
-	const candidates = options?.searchPaths ?? [join(dshHome, "storages", "workspace.json")];
-	let edited = false;
-	let lastReason = `workspace 存储文件不存在（已试：${candidates.join("、")}）`;
-	for (const path of candidates) {
-		const outcome = editWorkspaceDocument(path, (document) => {
-			let changed = false;
-			const global = document.global;
-			if (Array.isArray(global?.archivedSessionIds)) {
-				const kept = global.archivedSessionIds.filter((id) => typeof id !== "string" || !wanted.has(id));
-				if (kept.length !== global.archivedSessionIds.length) {
-					document.global = {
-						...global,
-						archivedSessionIds: kept
-					};
-					changed = true;
-				}
-			}
-			const tables = document.tables;
-			if (tables?.workspaces !== void 0) for (const [workspaceId, workspace] of Object.entries(tables.workspaces)) {
-				if (!Array.isArray(workspace?.sessionIds)) continue;
-				const kept = workspace.sessionIds.filter((id) => typeof id !== "string" || !wanted.has(id));
-				if (kept.length !== workspace.sessionIds.length) {
-					tables.workspaces[workspaceId] = {
-						...workspace,
-						sessionIds: kept
-					};
-					changed = true;
-				}
-			}
-			return changed;
-		}, log);
-		if (!outcome.ok) {
-			lastReason = outcome.reason;
-			continue;
-		}
-		edited = true;
-		break;
-	}
-	if (!edited) return {
+	const summary = plugins.map(([name, count]) => `${name}×${count}`).join("、");
+	return {
+		id: "source-kind",
+		level: "warn",
+		evidence: `格式代次 v${version} 但存在 ${facts.legacyCount} 行旧署名（${summary}）：宿主 v4 拒绝该形态，未适配插件读回判断也会失配；可执行署名转换`,
+		detail
+	};
+}
+/**
+* 从旧署名对象构造新署名：`{ kind: 'plugin', plugin: name, …rest }` → `{ kind: 'plugin:name', …rest }`。
+* 非 legacy（缺 plugin 字段 / kind 不符）返回 undefined，调用方跳过该行。
+*
+* ⚠️ 只对**第三方**生产者名成立（第四轮审计 ST1）：宿主 `producerKind`
+* （dsh-session-format-v3-to-v4@0.1.7-rc.2 lib/index.js:88-96）对第一方名走改名表
+* 或同名裸 kind，本函数无条件加前缀会对那 30 个名字写出宿主永不产出的 kind。
+* 第一方名由 `FIRST_PARTY_RENAMED_PRODUCERS` / `FIRST_PARTY_SAME_NAME_PRODUCERS`
+* 判定，`migrateSessionSourceKind` 命中即跳过并如实上报（宿主迁移职权，不代转换）。
+*/
+function migrateLegacySource(source) {
+	if (typeof source !== "object" || source === null) return void 0;
+	const record = source;
+	if (record["kind"] !== "plugin" || typeof record["plugin"] !== "string" || record["plugin"] === "") return void 0;
+	const { plugin, ...rest } = record;
+	return {
+		...rest,
+		kind: `plugin:${plugin}`
+	};
+}
+/**
+* 宿主 v3→v4 迁移会**改名**的第一方生产者（出处：dsh-session-format-v3-to-v4@
+* 0.1.7-rc.2 lib/index.js:51-57 `RENAMED_PRODUCERS`，逐字照录）。
+*/
+const FIRST_PARTY_RENAMED_PRODUCERS = Object.freeze({
+	"compact": "compact-checkpoint",
+	"tools-code-mode": "ptc-mode",
+	"tools-ptc": "ptc-mode",
+	"dsh-compaction-basic": "compact-basic",
+	"@deepseek-ai/dsh-system-prompt": "runtime-context"
+});
+/**
+* 宿主迁移后**保留同名裸 kind** 的第一方生产者（出处：同上 lib/index.js:59-84
+* `RELEASED_SAME_NAME_PRODUCERS`，逐字照录；注释明言限第一方）。
+* 注：`@deepseek-ai/dsh-system-prompt` 还有 role 敏感分支（role=system →
+* `system-prompt`），steward 无 role 上下文、结构性不可复刻——这正是第一方名
+* 一律跳过、交还宿主迁移的核心理由之一。
+*/
+const FIRST_PARTY_SAME_NAME_PRODUCERS = /* @__PURE__ */ new Set([
+	"agent-instructions",
+	"session-reference",
+	"team-message",
+	"goal",
+	"skill-invocation",
+	"skill-catalog",
+	"coordinator",
+	"subagent-report",
+	"subagent-settled",
+	"webhook",
+	"agent-message",
+	"model-selection",
+	"plan-mode",
+	"time-context",
+	"tmux-context",
+	"user-approval",
+	"repeat-tool-reminder",
+	"tool-cordis",
+	"cordis-host-runner",
+	"tool-goal",
+	"tool-jobs",
+	"hooks-codex",
+	"hooks-claude-code",
+	"schedule",
+	"dsh-session-title-llm"
+]);
+/** 是否第一方生产者名（宿主迁移职权，steward 不代转换——防归因静默损坏）。 */
+function isFirstPartyLegacyProducer(plugin) {
+	return Object.hasOwn(FIRST_PARTY_RENAMED_PRODUCERS, plugin) || FIRST_PARTY_SAME_NAME_PRODUCERS.has(plugin);
+}
+/**
+* 转换一个会话日志里的旧署名行（v4 线专用；先备份，只动署名字段）。
+*
+* 执行闸（任一不满足即拒绝，不写盘）：
+* 1. 日志可整体解码且无完整性问题（撕裂尾帧 / 解码失败 / seq 缺口）；
+* 2. header.version ≥ 4（v3 及更早的旧行按契约由宿主迁移，不动）；
+* 3. 确有旧署名行（没有则空手而归，不做无谓重压缩）。
+* @param sessionId - 会话 id（用于结果标注）。
+* @param logPath - 当前代日志路径（必须 .zstd 结尾）。
+* @param log - 已解码的日志（复用体检结果，闸 1/2 在其上判定）。
+* @param dshHome - DSH home（备份不依赖它，参数保留与其它处置一致的面）。
+* @param now - 时间源（备份后缀，测试可控）。
+*/
+function migrateSessionSourceKind(sessionId, logPath, log, dshHome, now = Date.now) {
+	const failure = (error) => ({
 		ok: false,
-		error: lastReason
+		sessionId,
+		path: logPath,
+		error
+	});
+	if (!logPath.endsWith(".zstd")) return failure(`非 zstd 产物，拒绝处理：${logPath}`);
+	if (log.issues.length > 0) return failure(`日志存在 ${log.issues.length} 条完整性问题，拒绝改写（先解决 log-integrity 门）`);
+	if (log.tornStart !== void 0) return failure("存在撕裂尾帧，拒绝改写（先让宿主完成提交或处置 log-integrity 门）");
+	const headerVersion = typeof log.header?.["version"] === "number" ? log.header["version"] : void 0;
+	if (headerVersion === void 0) return failure("日志 header 无 version 字段，无法确认格式代次线，拒绝改写");
+	if (headerVersion < 4) return failure(`格式代次 v${headerVersion}：旧署名在该版本线合法，宿主迁移负责，不做转换（防过度操作）`);
+	let original;
+	try {
+		original = readPlaintext(logPath);
+	} catch (err) {
+		return failure(`读取日志失败：${String(err instanceof Error ? err.message : err)}`);
+	}
+	const lines = original.split("\n");
+	let changedRows = 0;
+	const byPlugin = {};
+	const skippedFirstParty = {};
+	const rewritten = lines.map((line, index) => {
+		if (index === 0 || line.trim() === "") return line;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			return line;
+		}
+		if (typeof parsed !== "object" || parsed === null) return line;
+		const record = parsed;
+		const data = record["data"];
+		if (data === void 0 || typeof data !== "object") return line;
+		const legacy = data["source"];
+		if (legacy === void 0 || typeof legacy !== "object" || legacy["kind"] !== "plugin" || typeof legacy["plugin"] !== "string" || legacy["plugin"] === "") return line;
+		const plugin = legacy["plugin"];
+		if (isFirstPartyLegacyProducer(plugin)) {
+			skippedFirstParty[plugin] = (skippedFirstParty[plugin] ?? 0) + 1;
+			return line;
+		}
+		const migrated = migrateLegacySource(legacy);
+		if (migrated === void 0) return line;
+		data["source"] = migrated;
+		changedRows += 1;
+		byPlugin[plugin] = (byPlugin[plugin] ?? 0) + 1;
+		return JSON.stringify(record);
+	});
+	if (changedRows === 0) return {
+		ok: true,
+		sessionId,
+		path: logPath,
+		changedRows: 0,
+		byPlugin: {},
+		...Object.values(skippedFirstParty).reduce((sum, n) => sum + n, 0) > 0 ? { skippedFirstParty } : {}
 	};
-	const sessionsRoot = sessionsRootFor(dshHome);
-	const cacheRoot = projCacheRootFor(dshHome);
-	const failures = [];
-	let purged = 0;
-	let freedBytes = 0;
-	for (const sessionId of ids) {
-		const entry = usage.get(sessionId);
-		let missing = 0;
-		let entryFreed = 0;
-		if (entry?.dir !== void 0) {
-			if (!isSafeChild(sessionsRoot, entry.dir, 2)) {
-				failures.push({
-					sessionId,
-					reason: `拒绝删除越界路径：${entry.dir}`
-				});
-				continue;
-			}
-			try {
-				rmSync(entry.dir, {
-					recursive: true,
-					force: true
-				});
-				entryFreed += entry.bytes;
-			} catch (err) {
-				failures.push({
-					sessionId,
-					reason: `删除转录目录失败：${String(err instanceof Error ? err.message : err)}`
-				});
-				continue;
-			}
-		} else missing++;
-		if (entry?.cacheFile !== void 0) {
-			if (!isSafeChild(cacheRoot, entry.cacheFile, 1)) {
-				failures.push({
-					sessionId,
-					reason: `拒绝删除越界缓存：${entry.cacheFile}`
-				});
-				continue;
-			}
-			try {
-				entryFreed += entry.cacheBytes;
-				rmSync(entry.cacheFile, { force: true });
-			} catch (err) {
-				failures.push({
-					sessionId,
-					reason: `删除投影缓存失败：${String(err instanceof Error ? err.message : err)}`
-				});
-				continue;
-			}
-		} else missing++;
-		if (missing === 2) log?.(`purge: ${sessionId} had no on-disk entity; only the archive state was cleared`);
-		purged++;
-		freedBytes += entryFreed;
+	const backup = `${logPath}.pre-sourcemigrate-${now()}`;
+	try {
+		copyFileSync(logPath, backup);
+		const compressed = zlib.zstdCompressSync(Buffer.from(rewritten.join("\n"), "utf8"));
+		const tmp = `${logPath}.sourcemigrate-tmp`;
+		writeFileSync(tmp, compressed);
+		renameSync(tmp, logPath);
+		return {
+			ok: true,
+			sessionId,
+			path: logPath,
+			backup,
+			changedRows,
+			byPlugin,
+			...Object.keys(skippedFirstParty).length > 0 ? { skippedFirstParty } : {}
+		};
+	} catch (err) {
+		return failure(`转换落盘失败（原文件未动，备份${existsSync(backup) ? "已生成" : "未生成"}）：${String(err instanceof Error ? err.message : err)}`);
 	}
-	log?.(`archive purge: cleared ${purged} of ${ids.length}; freed ${(freedBytes / 1048576).toFixed(1)}MB; failures ${failures.length}`);
-	return {
-		ok: true,
-		purged,
-		freedBytes,
-		requiresRestart: true,
-		...failures.length === 0 ? {} : { failures }
-	};
 }
+/** 读出整份 zstd 日志的明文；失败时抛出（调用方拒绝改写并如实上报）。 */
+function readPlaintext(logPath) {
+	const bytes = readFileSync(logPath);
+	const { frames, tornStart } = scanZstdFrames(bytes);
+	if (tornStart !== void 0) throw new Error("存在撕裂尾帧，拒绝改写");
+	const parts = [];
+	for (const frame of frames) parts.push(zlib.zstdDecompressSync(bytes.subarray(frame.start, frame.end)));
+	return Buffer.concat(parts).toString("utf8");
+}
+/** 备份文件的后缀约定（purge/清理工具可据此识别并一并处置）。 */
+const SOURCE_MIGRATE_BACKUP_SUFFIX = ".pre-sourcemigrate-";
 //#endregion
-//#region src/host/history/archive.ts
+//#region src/host/history/purge.ts
 /**
-* 会话历史文件（归档）域的服务端处理。
+* 归档文件清理（**真删除**）—— 会话管家唯一的破坏性操作。
 *
-* 与 dsh-session-search-toggle 的差异（**刻意且必须记入交付说明**）：
-* toggle 的 `list-archived` 从它自己的独立索引里列出归档行（`engine.listArchived()`），
-* 而索引已随搜索索引包离开本包。因此本包改为从**官方归档集合**列出来源真值
-* （`readArchiveSet`：存储文件优先、registry 兜底），标题等元数据为尽力而为：
-* 依次尝试 `sessionQuery.readTitleSnapshots` → 投影缓存记录里的 title。
-* 列表与 prune **同源**（都认存储文件），否则清理成功后面板不会刷新；
-* registry 与文件的差集作为 `pendingRestart` 返回，面板据此提示重启。
-* 清理（prune）路径与迁移前**逐字等价**（备份 + 原子替换 + 需重启提示），
-* 另加一道写后校验：读回文件确认目标 id 确实消失。
+* 与「取消归档状态」（`pruneArchiveFile`）是**两件事**，刻意分开：
+*
+* | | 取消归档状态 | 清理归档文件 |
+* |---|---|---|
+* | 改什么 | 只改 `global.archivedSessionIds` | 删磁盘实体 **+** 改两处 id |
+* | 会话 | 回到侧边栏 | 从世界上消失 |
+* | 可逆 | 重启即生效 | 不可逆 |
+*
+* 「清理归档文件」必须**连带**执行「取消归档状态」：文件删了、id 还留在数组里，
+* 就是一条僵尸归档 —— 侧边栏看不见它，一旦被取消归档又会冒出一个打不开的空会话。
+*
+* 一次清理动 4 处：
+* 1. `~/.dsh/sessions/<工作区>/<会话id>/` —— 整个目录（可能含 `session.jsonl.zstd`
+*    与旧格式 `session.v3.jsonl.zstd` 两份，所以必须整目录删，不能只删当前格式）
+* 2. `~/.dsh/storages/session_projcache/sessions/<会话id>.json` —— 逐条投影缓存
+* 3. `workspace.json` → `global.archivedSessionIds`
+* 4. `workspace.json` → `tables.workspaces.*.sessionIds`
+*
+* 执行顺序是**先改文件、后删实体**：改文件是原子的且可整体中止（失败则一个字节都没删）；
+* 反过来先删实体再改文件，中途失败会留下僵尸 id。
 */
-/** 投影缓存记录里可能存在的标题（同目录第二来源）。 */
-function titleFromProjectionCache(sessionId) {
-	const path = join(homedir(), ".dsh", "storages", "session_projcache", "sessions", `${sessionId}.json`);
-	if (!existsSync(path)) return "";
-	try {
-		const value = JSON.parse(readFileSync(path, "utf8")).record?.rows?.title?.val;
-		return typeof value === "string" ? value : "";
-	} catch {
-		return "";
-	}
+/** 是否署名转换备份文件（`*.pre-sourcemigrate-<ts>`）。 */
+function isSourceMigrateBackupName(name) {
+	return name.includes(SOURCE_MIGRATE_BACKUP_SUFFIX);
 }
 /**
-* `session-history-list`：列出官方归档集合（尽力附带标题等元数据）。
-* @param getRegistry - 惰性 workspaceRegistry 面。
-* @param query - 可选标题快照面。
-* @param searchPaths - 可选存储文件候选路径（DSH_HOME 非默认值/测试注入）。
-* @returns 归档行清单。
+* 列出一个转录目录里的署名转换备份（只扫顶层：备份与日志同目录落盘）。
+* @returns 备份绝对路径与合计字节数；目录不存在时为空。
 */
-async function listHistory(getRegistry, query, searchPaths, dshHome) {
-	const read = readArchiveSet(getRegistry(), searchPaths);
-	if (read.source === "none") return {
-		ok: false,
-		error: "workspace 存储文件与 workspaceRegistry 均不可用，无法读取归档集合"
-	};
-	const ids = [...read.ids];
-	const titles = /* @__PURE__ */ new Map();
-	let degraded;
-	if (query?.readTitleSnapshots !== void 0 && ids.length > 0) try {
-		const observations = await query.readTitleSnapshots(ids);
-		ids.forEach((id, index) => {
-			const title = observations[index]?.value?.title?.title;
-			if (typeof title === "string" && title !== "") titles.set(id, title);
-		});
+function backupFilesIn(dir) {
+	const files = [];
+	let bytes = 0;
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
 	} catch {
-		degraded = "sessionQuery 标题快照不可用，标题回退到投影缓存/空";
-	}
-	else if (ids.length > 0) degraded = "sessionQuery 不可用，标题回退到投影缓存/空";
-	const items = ids.map((sessionId) => {
 		return {
-			sessionId,
-			title: titles.get(sessionId) ?? titleFromProjectionCache(sessionId),
-			cwd: "",
-			updatedAt: 0,
-			bytes: 0,
-			cacheBytes: 0
+			files,
+			bytes
 		};
-	});
-	if (dshHome !== void 0 && dshHome !== "" && items.length > 0) try {
-		const usage = locateSessionUsage(ids, dshHome);
-		for (const item of items) {
-			const entry = usage.get(item.sessionId);
-			if (entry === void 0) continue;
-			item.bytes = entry.bytes;
-			item.cacheBytes = entry.cacheBytes;
-		}
-	} catch {}
-	const fileIds = new Set(ids);
-	const pendingRestart = (read.registryIds ?? []).filter((id) => !fileIds.has(id)).length;
+	}
+	for (const entry of entries) {
+		if (!entry.isFile() || !isSourceMigrateBackupName(entry.name)) continue;
+		const path = join(dir, entry.name);
+		files.push(path);
+		try {
+			bytes += statSync(path).size;
+		} catch {}
+	}
 	return {
-		ok: true,
-		items,
-		source: read.source,
-		...degraded === void 0 ? {} : { degraded },
-		...pendingRestart === 0 ? {} : { pendingRestart }
+		files,
+		bytes
 	};
 }
-/** 按 DSH_HOME 解析存储文件候选（与 archive-source 的默认候选保持同一形状）。 */
-function storagePathsFor(dshHome) {
-	return [join(dshHome, "storages", "workspace.json")];
+/** 转录根目录（`<dshHome>/sessions`）。 */
+function sessionsRootFor(dshHome) {
+	return join(dshHome, "sessions");
 }
-/** 单次清理的最大 id 数（与迁移前一致）。 */
-const MAX_PRUNE_IDS = 5e3;
 /**
-* `session-history-prune`：从官方归档数组中批量移除会话 id。
-* 行为与迁移前等价：校验入参 → 备份并原子替换存储文件 → 返回 removed/remaining，
-* 并明确要求重启 DSH（宿主内存中的集合只在启动时重载）。
-* @param payload - `{ sessionIds: string[] }`。
-* @param log - 可选日志出口。
-* @param searchPaths - 可选候选路径覆盖（测试注入用）。
+* 投影缓存（**逐条布局**）根目录。
+*
+* 注意另有一个 `<dshHome>/storages/session_projcache.json`（整份布局）——
+* 那是布局迁移留下的**化石**，宿主早已不再写它，本插件也不碰它。
 */
-function pruneHistory(payload, log, searchPaths) {
-	const record = payload;
-	if (!Array.isArray(record?.sessionIds) || record.sessionIds.length === 0) return {
-		ok: false,
-		error: "缺少 sessionIds 数组"
-	};
-	const ids = [...new Set(record.sessionIds.filter((id) => typeof id === "string" && id !== ""))];
-	if (ids.length === 0) return {
-		ok: false,
-		error: "sessionIds 无有效值"
-	};
-	if (ids.length > 5e3) return {
-		ok: false,
-		error: `单次最多清理 ${MAX_PRUNE_IDS} 个`
-	};
-	let result;
+function projCacheRootFor(dshHome) {
+	return join(dshHome, "storages", "session_projcache", "sessions");
+}
+/**
+* 会话 id 的目录名归一化。
+*
+* 归档集合里一律是 `session-<uuid>`，但子会话的目录名是不带前缀的 `<uuid>`，
+* 两者必须视为同一个会话，否则清理会「找不到文件」而静默什么都没删。
+*/
+function dirKey(name) {
+	return name.startsWith("session-") ? name.slice(8) : name;
+}
+/** 是不是目录（读不到就当不是）。 */
+function isDir(path) {
 	try {
-		result = pruneArchiveFile(ids, log, searchPaths);
-	} catch (err) {
-		return {
-			ok: false,
-			error: String(err instanceof Error ? err.message : err)
-		};
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
 	}
-	const after = readArchiveSet(void 0, searchPaths);
-	if (after.source !== "storage-file") return {
-		ok: false,
-		error: "写入后无法读回存储文件，无法确认清理结果"
-	};
-	const stillThere = new Set(after.ids);
-	const leftover = ids.filter((id) => stillThere.has(id));
-	if (leftover.length > 0) return {
-		ok: false,
-		error: `存储文件在写入后仍包含 ${leftover.length} 个目标 id，清理未生效`
-	};
-	log?.(`archive prune requested ${ids.length}, removed ${result.removed}, remaining ${result.remaining}`);
-	return {
-		ok: true,
-		removed: result.removed,
-		remaining: result.remaining,
-		requiresRestart: true
-	};
 }
-//#endregion
-//#region src/host/health/attribution.ts
 /**
-* 归属：把投影 key 指回产出它的插件包。
+* 扫一遍转录根，建立「会话 id → 目录」索引。
 *
-* 做法是静态扫描 profile 的 `node_modules`：`<pkg>/lib/index.js` 里
-* `sessionProjections.register({ key: 'xxx' })`（或其定义工厂）会命中
-* `key:\s*['"](\w+)['"]` 正则；据此建立 `投影 key → 包名` 索引。
-* `@deepseek-ai/*` 视为内置（core）；扫不到时如实返回 `unknown`，禁止臆测。
+* 同一个 id 同时存在带前缀与不带前缀的目录时，**优先带 `session-` 前缀的那个**
+* （归档集合里的 id 本身带前缀）。
+* @param sessionsRoot - `<dshHome>/sessions`。
+* @returns 归一化 id → 目录绝对路径。
 */
-/** 默认扫描根：profile 的 node_modules。 */
-function defaultProfileNodeModules(dshHome) {
-	return join(dshHome ?? join(homedir(), ".dsh"), "profiles", "web", "node_modules");
-}
-/** 收集候选包目录（含 @scope/pkg 一层）。 */
-function candidatePackages(root) {
-	const out = [];
-	if (!existsSync(root)) return out;
-	for (const entry of readdirSync(root, { withFileTypes: true })) {
-		if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-		if (entry.name.startsWith(".")) continue;
-		const dir = join(root, entry.name);
-		if (entry.name.startsWith("@")) {
-			let scoped = [];
-			try {
-				scoped = readdirSync(dir);
-			} catch {
-				continue;
-			}
-			for (const child of scoped) out.push({
-				name: `${entry.name}/${child}`,
-				dir: join(dir, child)
-			});
-			continue;
+function indexSessionDirs(sessionsRoot) {
+	const map = /* @__PURE__ */ new Map();
+	if (!existsSync(sessionsRoot)) return map;
+	for (const workspace of readdirSync(sessionsRoot)) {
+		const wsDir = join(sessionsRoot, workspace);
+		if (!isDir(wsDir)) continue;
+		for (const name of readdirSync(wsDir)) {
+			const entry = join(wsDir, name);
+			if (!isDir(entry)) continue;
+			const key = dirKey(name);
+			const existing = map.get(key);
+			const prefer = name.startsWith("session-") && existing !== void 0 && !basename(existing).startsWith("session-");
+			if (existing === void 0 || prefer) map.set(key, entry);
 		}
-		out.push({
-			name: entry.name,
-			dir
-		});
 	}
-	return out;
+	return map;
 }
-/** 单个入口文件的最大扫描字节数（超大 bundle 直接跳过，避免无谓内存与耗时）。 */
-const MAX_SCAN_BYTES = 12 << 20;
-/** 扫描若干候选入口文件里出现的投影 key。 */
-function keysInFile(file) {
-	if (!existsSync(file)) return [];
-	let text;
+/** 递归求目录占用字节数（读不到的条目跳过，不抛错）。 */
+function dirSize(dir) {
+	let total = 0;
+	let entries;
 	try {
-		if (statSync(file).size > MAX_SCAN_BYTES) return [];
-		text = readFileSync(file, "utf8");
+		entries = readdirSync(dir, { withFileTypes: true });
 	} catch {
-		return [];
+		return 0;
 	}
-	const keys = /* @__PURE__ */ new Set();
-	const pattern = /key:\s*['"]([A-Za-z_$][\w$]*)['"]/g;
-	let match;
-	while ((match = pattern.exec(text)) !== null) {
-		const key = match[1];
-		if (key !== void 0 && key !== "") keys.add(key);
+	for (const entry of entries) {
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) total += dirSize(path);
+		else try {
+			total += statSync(path).size;
+		} catch {}
 	}
-	return [...keys];
+	return total;
 }
 /**
-* 建立投影 key → 包 的索引。
-* @param nodeModulesRoot - profile 的 node_modules 根。
-* @returns 归属记录（同一 key 多包命中时保留首个并排序稳定）。
+* 解析一批会话在磁盘上的实体与占用（**只读，不删任何东西**）。
+*
+* 列表按行显示体积就走这里 —— 体积差异极大（实测单条缓存可达 23 MB、单条转录可达
+* 6 MB，也有 0 字节的），报一个总量对用户没有意义。
+* @param ids - 会话 id（带不带 `session-` 前缀都接受）。
+* @param dshHome - DSH 主目录。
+* @returns 会话 id → 实体位置与占用。
 */
-function buildProjectionOwnerIndex(nodeModulesRoot) {
-	const records = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const pack of candidatePackages(nodeModulesRoot)) {
-		const lib = join(pack.dir, "lib");
-		let entries = [];
-		try {
-			if (!statSync(lib).isDirectory()) continue;
-			entries = readdirSync(lib).filter((name) => name.endsWith(".js"));
-		} catch {
-			continue;
+function locateSessionUsage(ids, dshHome) {
+	const dirs = indexSessionDirs(sessionsRootFor(dshHome));
+	const cacheRoot = projCacheRootFor(dshHome);
+	const out = /* @__PURE__ */ new Map();
+	for (const sessionId of ids) {
+		const key = dirKey(sessionId);
+		const usage = {
+			sessionId,
+			bytes: 0,
+			backupBytes: 0,
+			backupCount: 0,
+			cacheBytes: 0
+		};
+		const dir = dirs.get(key);
+		if (dir !== void 0) {
+			usage.dir = dir;
+			usage.bytes = dirSize(dir);
+			const backups = backupFilesIn(dir);
+			usage.backupBytes = backups.bytes;
+			usage.backupCount = backups.files.length;
 		}
-		for (const name of entries) {
-			const file = join(lib, name);
-			for (const key of keysInFile(file)) {
-				if (seen.has(key)) continue;
-				seen.add(key);
-				records.push({
-					key,
-					package: pack.name,
-					kind: pack.name.startsWith("@deepseek-ai/") ? "core" : "plugin",
-					entry: `${pack.name}/lib/${name}`
-				});
+		for (const name of [`${sessionId}.json`, `${key}.json`]) {
+			const candidate = join(cacheRoot, name);
+			if (existsSync(candidate)) {
+				usage.cacheFile = candidate;
+				try {
+					usage.cacheBytes = statSync(candidate).size;
+				} catch {}
+				break;
 			}
 		}
+		out.set(sessionId, usage);
 	}
-	return records.sort((left, right) => left.key.localeCompare(right.key));
-}
-/** 索引查询器。 */
-function createAttributor(index) {
-	const byKey = new Map(index.map((record) => [record.key, record]));
-	return (projection) => {
-		const owner = byKey.get(projection);
-		if (owner === void 0) return {
-			projection,
-			package: "unknown"
-		};
-		return {
-			projection,
-			package: owner.package
-		};
-	};
+	return out;
 }
-//#endregion
-//#region src/host/health/cache.ts
-/** 进程内体检缓存：分批扫描过程中累积，走完一遍语料才成型。 */
-var HealthCache = class {
-	ready;
-	pending;
-	/** 读当前成型的缓存（未成型则 undefined）。 */
-	read() {
-		return this.ready;
-	}
-	/** 开始一轮分批扫描（客户端以 `offset: 0` 发起时调用）。 */
-	begin(total) {
-		this.pending = {
-			total: Math.max(0, Math.floor(total)),
-			findings: [],
-			visited: 0
-		};
-	}
-	/**
-	* 追加一批扫描结果。
-	*
-	* 只有累积的已访问数走满语料总数才成型；语言中途断掉（关面板、报错）不会留下
-	* 半份缓存冒充完整结果。
-	* @param findings - 本批的非 ok 报告。
-	* @param scanned - 本批**已访问**的会话数（不是命中数）。
-	* @param now - 时间源（测试可控）。
-	* @returns 本批追加后缓存是否刚好成型。
-	*/
-	append(findings, scanned, now = Date.now) {
-		const pending = this.pending;
-		if (pending === void 0) return false;
-		pending.findings.push(...findings);
-		pending.visited += Math.max(0, Math.floor(scanned));
-		if (pending.visited < pending.total) return false;
-		this.ready = {
-			findings: pending.findings,
-			total: pending.total,
-			generatedAt: now()
-		};
-		this.pending = void 0;
-		return true;
-	}
-	/**
-	* 单条就地回写（单会话体检 / 可逆处置后调用）。
-	*
-	* 这是缓存的**关键收益**：处置本就重算了 `after` 报告，把它写回即可，
-	* 不必为了刷新一行而重扫整个语料。
-	* @param report - 重算出的单会话报告。
-	* @returns 是否真的改动了缓存（无缓存时为 false）。
-	*/
-	patch(report) {
-		const ready = this.ready;
-		if (ready === void 0) return false;
-		const index = ready.findings.findIndex((entry) => entry.sessionId === report.sessionId);
-		if (report.level === "ok") {
-			if (index < 0) return false;
-			ready.findings.splice(index, 1);
-			return true;
-		}
-		if (index >= 0) ready.findings[index] = report;
-		else ready.findings.push(report);
-		return true;
-	}
-	/** 丢弃缓存与未完成的累积。 */
-	clear() {
-		this.ready = void 0;
-		this.pending = void 0;
-	}
-};
-//#endregion
-//#region src/host/health/decode.ts
 /**
-* 会话日志读取链路（`log-integrity` gate 与 `lossless-json` gate 的共同底座）。
-*
-* 链路与 `_tools/dsh-session-invariant-repro.mjs` 的 `decodeSessionLog` 一致：
-*   zstd 多帧扫描（撕裂尾帧用 ZSTD_e_flush 抢救）→ 逐行 JSON.parse
-*   → provenance 展开（storage 形态的 seq ranges）→ `decodeStorageRecord` 解包
-*   （`text-chunks` / `reasoning-chunks` / `tool-call-chunks` 展开回 `assistant/chunk`）
-*   → seq 连续性校验（提交区出现缺口即停止并按 prefix 语义处理）。
+* 断言目标是 `root` 的**直接子项**（层级也校验）。
 *
-* 解码器优先使用宿主真实的 `@deepseek-ai/dsh-session`（运行时按需软加载，零硬依赖）；
-* 不可用时使用本文件内的等价实现（同格式：dt 为**时间**增量、成员数 = dt.length + 1；
-* provenance 存储形态为 `[[start,end],…]` 区间编码）。二者的差异会被显式记入
-* `decoder` 字段，禁止静默回退。
+* 破坏性操作不能只靠「路径拼对了」—— 拼错一层就是删掉整个 sessions 根。
+* @param root - 允许的父目录。
+* @param target - 待删目标。
+* @param depth - 相对 root 的期望层数。
+* @returns 是否安全。
 */
-/** zstd 帧魔数（0xFD2FB528 的小端读取值）。 */
-const ZSTD_MAGIC = 4247762216;
-/** 打包行类型（读路径必须解包）。 */
-const PACKED_ROWS = /* @__PURE__ */ new Set([
-	"text-chunks",
-	"reasoning-chunks",
-	"tool-call-chunks"
-]);
-/** 扫描拼接的 zstd 多帧；返回完整帧范围与撕裂尾帧起点。 */
-function scanZstdFrames(buffer) {
-	const frames = [];
-	let offset = 0;
-	while (offset < buffer.length) {
-		const start = offset;
-		if (buffer.length - offset < 4) return {
-			frames,
-			tornStart: start
-		};
-		if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC) return {
-			frames,
-			tornStart: start
-		};
-		offset += 4;
-		if (offset === buffer.length) return {
-			frames,
-			tornStart: start
-		};
-		const descriptor = buffer.readUInt8(offset);
-		offset += 1;
-		if ((descriptor & 24) !== 0) return {
-			frames,
-			tornStart: start
-		};
-		const contentSizeFlag = descriptor >>> 6;
-		const singleSegment = (descriptor & 32) !== 0;
-		const checksum = (descriptor & 4) !== 0;
-		const dictionaryFlag = descriptor & 3;
-		const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
-		const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
-		const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
-		if (buffer.length - offset < remainingHeaderBytes) return {
-			frames,
-			tornStart: start
-		};
-		offset += remainingHeaderBytes;
-		for (;;) {
-			if (buffer.length - offset < 3) return {
-				frames,
-				tornStart: start
-			};
-			const blockHeader = buffer.readUIntLE(offset, 3);
-			offset += 3;
-			const lastBlock = (blockHeader & 1) !== 0;
-			const blockType = blockHeader >>> 1 & 3;
-			const blockSize = blockHeader >>> 3;
-			if (blockType === 3) return {
-				frames,
-				tornStart: start
-			};
-			const payloadBytes = blockType === 1 ? 1 : blockSize;
-			if (buffer.length - offset < payloadBytes) return {
-				frames,
-				tornStart: start
-			};
-			offset += payloadBytes;
-			if (lastBlock) break;
-		}
-		if (checksum) {
-			if (buffer.length - offset < 4) return {
-				frames,
-				tornStart: start
-			};
-			offset += 4;
-		}
-		frames.push({
-			start,
-			end: offset
-		});
-	}
-	return { frames };
+function isSafeChild(root, target, depth) {
+	const rel = relative(resolve(root), resolve(target));
+	if (rel === "" || rel.startsWith("..") || resolve(root, rel) !== resolve(target)) return false;
+	return rel.split(sep).filter((part) => part !== "").length === depth;
 }
-/** 存储形态的 provenance（`[[start,end],…]` 区间编码或直接 seq 数组）展开为递增 seq 列表。 */
-function decodeSeqRangesStorage(value, currentSeq) {
-	if (!Array.isArray(value)) throw new Error("sourceEventSeqs must be an array when present");
-	const out = [];
-	for (const entry of value) {
-		if (typeof entry === "number") {
-			out.push(entry);
-			continue;
-		}
-		if (Array.isArray(entry) && entry.length === 2) {
-			const [start, end] = entry;
-			if (typeof start !== "number" || typeof end !== "number" || end < start) throw new Error("sourceEventSeqs range is malformed");
-			for (let seq = start; seq <= end; seq += 1) out.push(seq);
+/** 单次清理的最大 id 数（与 prune 一致）。 */
+const MAX_PURGE_IDS = 5e3;
+/**
+* `session-history-purge`：**真删除**归档会话的磁盘实体，并连带取消其归档状态。
+* @param payload - `{ sessionIds: string[] }`。
+* @param log - 可选日志出口。
+* @param options - `dshHome` 必填；`searchPaths` 可选覆盖。
+* @returns 清理条数、释放字节数与逐条失败。
+*/
+function purgeHistory(payload, log, options) {
+	const dshHome = options?.dshHome;
+	if (dshHome === void 0 || dshHome === "") return {
+		ok: false,
+		error: "缺少 dshHome：破坏性清理拒绝在未知路径上执行"
+	};
+	const record = payload;
+	if (!Array.isArray(record?.sessionIds) || record.sessionIds.length === 0) return {
+		ok: false,
+		error: "缺少 sessionIds 数组"
+	};
+	const ids = [...new Set(record.sessionIds.filter((id) => typeof id === "string" && id !== ""))];
+	if (ids.length === 0) return {
+		ok: false,
+		error: "sessionIds 无有效值"
+	};
+	if (ids.length > 5e3) return {
+		ok: false,
+		error: `单次最多清理 ${MAX_PURGE_IDS} 个`
+	};
+	const wanted = new Set(ids);
+	const usage = locateSessionUsage(ids, dshHome);
+	const candidates = options?.searchPaths ?? [join(dshHome, "storages", "workspace.json")];
+	let edited = false;
+	let lastReason = `workspace 存储文件不存在（已试：${candidates.join("、")}）`;
+	for (const path of candidates) {
+		const outcome = editWorkspaceDocument(path, (document) => {
+			let changed = false;
+			const global = document.global;
+			if (Array.isArray(global?.archivedSessionIds)) {
+				const kept = global.archivedSessionIds.filter((id) => typeof id !== "string" || !wanted.has(id));
+				if (kept.length !== global.archivedSessionIds.length) {
+					document.global = {
+						...global,
+						archivedSessionIds: kept
+					};
+					changed = true;
+				}
+			}
+			const tables = document.tables;
+			if (tables?.workspaces !== void 0) for (const [workspaceId, workspace] of Object.entries(tables.workspaces)) {
+				if (!Array.isArray(workspace?.sessionIds)) continue;
+				const kept = workspace.sessionIds.filter((id) => typeof id !== "string" || !wanted.has(id));
+				if (kept.length !== workspace.sessionIds.length) {
+					tables.workspaces[workspaceId] = {
+						...workspace,
+						sessionIds: kept
+					};
+					changed = true;
+				}
+			}
+			return changed;
+		}, log);
+		if (!outcome.ok) {
+			lastReason = outcome.reason;
 			continue;
 		}
-		throw new Error("sourceEventSeqs entry is neither a seq nor a [start,end] range");
+		edited = true;
+		break;
 	}
-	for (const seq of out) if (!Number.isSafeInteger(seq) || seq < 0 || seq >= currentSeq) throw new Error(`sourceEventSeqs must reference earlier events: ${seq} >= ${currentSeq}`);
-	return out;
+	if (!edited) return {
+		ok: false,
+		error: lastReason
+	};
+	const sessionsRoot = sessionsRootFor(dshHome);
+	const cacheRoot = projCacheRootFor(dshHome);
+	const failures = [];
+	let purged = 0;
+	let freedBytes = 0;
+	let backupsRemoved = 0;
+	for (const sessionId of ids) {
+		const entry = usage.get(sessionId);
+		let missing = 0;
+		let entryFreed = 0;
+		if (entry?.dir !== void 0) {
+			if (!isSafeChild(sessionsRoot, entry.dir, 2)) {
+				failures.push({
+					sessionId,
+					reason: `拒绝删除越界路径：${entry.dir}`
+				});
+				continue;
+			}
+			backupsRemoved += entry.backupCount;
+			try {
+				rmSync(entry.dir, {
+					recursive: true,
+					force: true
+				});
+				entryFreed += entry.bytes;
+			} catch (err) {
+				failures.push({
+					sessionId,
+					reason: `删除转录目录失败：${String(err instanceof Error ? err.message : err)}`
+				});
+				continue;
+			}
+		} else missing++;
+		if (entry?.cacheFile !== void 0) {
+			if (!isSafeChild(cacheRoot, entry.cacheFile, 1)) {
+				failures.push({
+					sessionId,
+					reason: `拒绝删除越界缓存：${entry.cacheFile}`
+				});
+				continue;
+			}
+			try {
+				entryFreed += entry.cacheBytes;
+				rmSync(entry.cacheFile, { force: true });
+			} catch (err) {
+				failures.push({
+					sessionId,
+					reason: `删除投影缓存失败：${String(err instanceof Error ? err.message : err)}`
+				});
+				continue;
+			}
+		} else missing++;
+		if (missing === 2) log?.(`purge: ${sessionId} had no on-disk entity; only the archive state was cleared`);
+		purged++;
+		freedBytes += entryFreed;
+	}
+	log?.(`archive purge: cleared ${purged} of ${ids.length}; freed ${(freedBytes / 1048576).toFixed(1)}MB; backups ${backupsRemoved}; failures ${failures.length}`);
+	return {
+		ok: true,
+		purged,
+		freedBytes,
+		backupsRemoved,
+		requiresRestart: true,
+		...failures.length === 0 ? {} : { failures }
+	};
 }
-/** 本地等价实现：把一行存储记录解包为事件（打包行展开为 assistant/chunk）。 */
-function decodeRecordLocal(value) {
-	if (typeof value !== "object" || value === null) return [value];
-	const record = value;
-	const type = record["type"];
-	if (typeof type !== "string" || !PACKED_ROWS.has(type)) {
-		const seq = record["seq"];
-		if (typeof seq === "number" && (!Number.isSafeInteger(seq) || seq < 0)) throw new Error(`session event seq ${String(seq)} is not a non-negative safe integer`);
-		return [record];
+//#endregion
+//#region src/host/history/archive.ts
+/**
+* 会话历史文件（归档）域的服务端处理。
+*
+* 与 dsh-session-search-toggle 的差异（**刻意且必须记入交付说明**）：
+* toggle 的 `list-archived` 从它自己的独立索引里列出归档行（`engine.listArchived()`），
+* 而索引已随搜索索引包离开本包。因此本包改为从**官方归档集合**列出来源真值
+* （`readArchiveSet`：存储文件优先、registry 兜底），标题等元数据为尽力而为：
+* 依次尝试 `sessionQuery.readTitleSnapshots` → 投影缓存记录里的 title。
+* 列表与 prune **同源**（都认存储文件），否则清理成功后面板不会刷新；
+* registry 与文件的差集作为 `pendingRestart` 返回，面板据此提示重启。
+* 清理（prune）路径与迁移前**逐字等价**（备份 + 原子替换 + 需重启提示），
+* 另加一道写后校验：读回文件确认目标 id 确实消失。
+*/
+/** 投影缓存记录里可能存在的标题（同目录第二来源）。 */
+function titleFromProjectionCache(sessionId) {
+	const path = join(homedir(), ".dsh", "storages", "session_projcache", "sessions", `${sessionId}.json`);
+	if (!existsSync(path)) return "";
+	try {
+		const value = JSON.parse(readFileSync(path, "utf8")).record?.rows?.title?.val;
+		return typeof value === "string" ? value : "";
+	} catch {
+		return "";
 	}
-	const data = record["data"];
-	if (data === void 0) throw new Error(`malformed ${type} storage row: data must be an object`);
-	const members = type === "tool-call-chunks" ? data["args"] : data["texts"];
-	if (!Array.isArray(members) || members.length === 0 || members.some((entry) => typeof entry !== "string")) throw new Error(`malformed ${type} storage row: payload must be a non-empty string array`);
-	const dt = data["dt"];
-	if (!Array.isArray(dt) || dt.some((gap) => !Number.isSafeInteger(gap))) throw new Error(`malformed ${type} storage row: dt must be an array of safe integers`);
-	if (dt.length !== members.length - 1) throw new Error(`malformed ${type} storage row: dt length ${dt.length} does not match ${members.length} members`);
-	const seq0 = record["seq0"];
-	const time0 = record["time0"];
-	if (typeof seq0 !== "number" || typeof time0 !== "number") throw new Error(`malformed ${type} storage row: seq0/time0 must be numbers`);
-	const turn = data["turn"];
-	const step = data["step"];
-	const index = data["index"];
-	const out = [];
-	let time = time0;
-	for (let k = 0; k < members.length; k += 1) {
-		if (k > 0) time += dt[k - 1];
-		let chunk;
-		if (type === "text-chunks") chunk = {
-			type: "text-delta",
-			index,
-			text: members[k]
-		};
-		else if (type === "reasoning-chunks") chunk = {
-			type: "reasoning-delta",
-			index,
-			text: members[k]
+}
+/**
+* `session-history-list`：列出官方归档集合（尽力附带标题等元数据）。
+* @param getRegistry - 惰性 workspaceRegistry 面。
+* @param query - 可选标题快照面。
+* @param searchPaths - 可选存储文件候选路径（DSH_HOME 非默认值/测试注入）。
+* @returns 归档行清单。
+*/
+async function listHistory(getRegistry, query, searchPaths, dshHome) {
+	const read = readArchiveSet(getRegistry(), searchPaths);
+	if (read.source === "none") return {
+		ok: false,
+		error: "workspace 存储文件与 workspaceRegistry 均不可用，无法读取归档集合"
+	};
+	const ids = [...read.ids];
+	const titles = /* @__PURE__ */ new Map();
+	let degraded;
+	if (query?.readTitleSnapshots !== void 0 && ids.length > 0) try {
+		const observations = await query.readTitleSnapshots(ids);
+		ids.forEach((id, index) => {
+			const title = observations[index]?.value?.title?.title;
+			if (typeof title === "string" && title !== "") titles.set(id, title);
+		});
+	} catch {
+		degraded = "sessionQuery 标题快照不可用，标题回退到投影缓存/空";
+	}
+	else if (ids.length > 0) degraded = "sessionQuery 不可用，标题回退到投影缓存/空";
+	const items = ids.map((sessionId) => {
+		return {
+			sessionId,
+			title: titles.get(sessionId) ?? titleFromProjectionCache(sessionId),
+			cwd: "",
+			updatedAt: 0,
+			bytes: 0,
+			cacheBytes: 0,
+			backupBytes: 0
 		};
-		else chunk = {
-			type: "tool-call-delta",
-			index,
-			id: typeof data["id"] === "string" ? data["id"] : "",
-			...typeof data["name"] === "string" ? { name: data["name"] } : {},
-			argumentsDelta: members[k]
+	});
+	if (dshHome !== void 0 && dshHome !== "" && items.length > 0) try {
+		const usage = locateSessionUsage(ids, dshHome);
+		for (const item of items) {
+			const entry = usage.get(item.sessionId);
+			if (entry === void 0) continue;
+			item.bytes = entry.bytes;
+			item.cacheBytes = entry.cacheBytes;
+			item.backupBytes = entry.backupBytes;
+		}
+	} catch {}
+	const fileIds = new Set(ids);
+	const pendingRestart = (read.registryIds ?? []).filter((id) => !fileIds.has(id)).length;
+	return {
+		ok: true,
+		items,
+		source: read.source,
+		...degraded === void 0 ? {} : { degraded },
+		...pendingRestart === 0 ? {} : { pendingRestart }
+	};
+}
+/** 按 DSH_HOME 解析存储文件候选（与 archive-source 的默认候选保持同一形状）。 */
+function storagePathsFor(dshHome) {
+	return [join(dshHome, "storages", "workspace.json")];
+}
+/** 单次清理的最大 id 数（与迁移前一致）。 */
+const MAX_PRUNE_IDS = 5e3;
+/**
+* `session-history-prune`：从官方归档数组中批量移除会话 id。
+* 行为与迁移前等价：校验入参 → 备份并原子替换存储文件 → 返回 removed/remaining，
+* 并明确要求重启 DSH（宿主内存中的集合只在启动时重载）。
+* @param payload - `{ sessionIds: string[] }`。
+* @param log - 可选日志出口。
+* @param searchPaths - 可选候选路径覆盖（测试注入用）。
+*/
+function pruneHistory(payload, log, searchPaths) {
+	const record = payload;
+	if (!Array.isArray(record?.sessionIds) || record.sessionIds.length === 0) return {
+		ok: false,
+		error: "缺少 sessionIds 数组"
+	};
+	const ids = [...new Set(record.sessionIds.filter((id) => typeof id === "string" && id !== ""))];
+	if (ids.length === 0) return {
+		ok: false,
+		error: "sessionIds 无有效值"
+	};
+	if (ids.length > 5e3) return {
+		ok: false,
+		error: `单次最多清理 ${MAX_PRUNE_IDS} 个`
+	};
+	let result;
+	try {
+		result = pruneArchiveFile(ids, log, searchPaths);
+	} catch (err) {
+		return {
+			ok: false,
+			error: String(err instanceof Error ? err.message : err)
 		};
-		out.push({
-			type: "assistant/chunk",
-			seq: seq0 + k,
-			time,
-			data: {
-				turn,
-				step,
-				chunk
+	}
+	const after = readArchiveSet(void 0, searchPaths);
+	if (after.source !== "storage-file") return {
+		ok: false,
+		error: "写入后无法读回存储文件，无法确认清理结果"
+	};
+	const stillThere = new Set(after.ids);
+	const leftover = ids.filter((id) => stillThere.has(id));
+	if (leftover.length > 0) return {
+		ok: false,
+		error: `存储文件在写入后仍包含 ${leftover.length} 个目标 id，清理未生效`
+	};
+	log?.(`archive prune requested ${ids.length}, removed ${result.removed}, remaining ${result.remaining}`);
+	return {
+		ok: true,
+		removed: result.removed,
+		remaining: result.remaining,
+		requiresRestart: true
+	};
+}
+//#endregion
+//#region src/host/health/attribution.ts
+/**
+* 归属：把投影 key 指回产出它的插件包。
+*
+* 做法是静态扫描 profile 的 `node_modules`：`<pkg>/lib/index.js` 里
+* `sessionProjections.register({ key: 'xxx' })`（或其定义工厂）会命中
+* `key:\s*['"](\w+)['"]` 正则；据此建立 `投影 key → 包名` 索引。
+* `@deepseek-ai/*` 视为内置（core）；扫不到时如实返回 `unknown`，禁止臆测。
+*/
+/** 默认扫描根：profile 的 node_modules。 */
+function defaultProfileNodeModules(dshHome) {
+	return join(dshHome ?? join(homedir(), ".dsh"), "profiles", "web", "node_modules");
+}
+/** 收集候选包目录（含 @scope/pkg 一层）。 */
+function candidatePackages(root) {
+	const out = [];
+	if (!existsSync(root)) return out;
+	for (const entry of readdirSync(root, { withFileTypes: true })) {
+		if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+		if (entry.name.startsWith(".")) continue;
+		const dir = join(root, entry.name);
+		if (entry.name.startsWith("@")) {
+			let scoped = [];
+			try {
+				scoped = readdirSync(dir);
+			} catch {
+				continue;
 			}
+			for (const child of scoped) out.push({
+				name: `${entry.name}/${child}`,
+				dir: join(dir, child)
+			});
+			continue;
+		}
+		out.push({
+			name: entry.name,
+			dir
 		});
 	}
 	return out;
 }
+/** 单个入口文件的最大扫描字节数（超大 bundle 直接跳过，避免无谓内存与耗时）。 */
+const MAX_SCAN_BYTES = 12 << 20;
+/** 扫描若干候选入口文件里出现的投影 key。 */
+function keysInFile(file) {
+	if (!existsSync(file)) return [];
+	let text;
+	try {
+		if (statSync(file).size > MAX_SCAN_BYTES) return [];
+		text = readFileSync(file, "utf8");
+	} catch {
+		return [];
+	}
+	const keys = /* @__PURE__ */ new Set();
+	const pattern = /key:\s*['"]([A-Za-z_$][\w$]*)['"]/g;
+	let match;
+	while ((match = pattern.exec(text)) !== null) {
+		const key = match[1];
+		if (key !== void 0 && key !== "") keys.add(key);
+	}
+	return [...keys];
+}
 /**
-* 读取一个会话日志文件（zip 帧扫描 + 解包 + seq 连续性）。
-* @param file - 当前代日志的绝对路径（由代次解析得出，不假定具体文件名）。
-* @param bytes - 文件内容（调用方读取，便于测试注入）。
-* @param decoders - 可选官方解码器（缺省用本地等价实现）。
-* @returns 事件、统计与问题清单。
+* 建立投影 key → 包 的索引。
+* @param nodeModulesRoot - profile 的 node_modules 根。
+* @returns 归属记录（同一 key 多包命中时保留首个并排序稳定）。
 */
-function decodeSessionLogBytes(file, bytes, decoders) {
-	const { frames, tornStart } = scanZstdFrames(bytes);
-	const parts = [];
-	const frameIssues = [];
-	for (const frame of frames) try {
-		parts.push(zlib.zstdDecompressSync(bytes.subarray(frame.start, frame.end)));
-	} catch (err) {
-		frameIssues.push(`frame@${frame.start}: ${String(err instanceof Error ? err.message : err)}`);
-	}
-	let recoveredFromTorn = 0;
-	if (tornStart !== void 0) try {
-		const recovered = zlib.zstdDecompressSync(bytes.subarray(tornStart), { finishFlush: zlib.constants.ZSTD_e_flush });
-		recoveredFromTorn = recovered.length;
-		parts.push(recovered);
-	} catch {}
-	const lines = Buffer.concat(parts).toString("utf8").split("\n").filter((line) => line.trim() !== "");
-	const issues = frameIssues.map((why, index) => ({
-		line: index + 1,
-		why
-	}));
-	const decodeRecord = decoders?.decodeStorageRecord ?? decodeRecordLocal;
-	const events = [];
-	for (let index = 1; index < lines.length; index += 1) {
-		const line = lines[index];
-		let decoded;
+function buildProjectionOwnerIndex(nodeModulesRoot) {
+	const records = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const pack of candidatePackages(nodeModulesRoot)) {
+		const lib = join(pack.dir, "lib");
+		let entries = [];
 		try {
-			const parsed = JSON.parse(line);
-			decoded = decodeRecord(parsed["sourceEventSeqs"] === void 0 ? parsed : {
-				...parsed,
-				sourceEventSeqs: decoders?.decodeSeqRanges !== void 0 && typeof parsed["seq"] === "number" ? decoders.decodeSeqRanges(parsed["sourceEventSeqs"], parsed["seq"]) : decodeSeqRangesStorage(parsed["sourceEventSeqs"], Number(parsed["seq"] ?? 0))
-			});
-		} catch (err) {
-			issues.push({
-				line: index + 1,
-				why: `decode failed: ${String(err instanceof Error ? err.message : err)}`
-			});
-			break;
+			if (!statSync(lib).isDirectory()) continue;
+			entries = readdirSync(lib).filter((name) => name.endsWith(".js"));
+		} catch {
+			continue;
 		}
-		const rowStart = events.length;
-		let gapped = false;
-		for (const event of decoded) {
-			if (event.seq !== events.length) {
-				issues.push({
-					line: index + 1,
-					why: `seq gap (expected ${events.length}, got ${event.seq})`
+		for (const name of entries) {
+			const file = join(lib, name);
+			for (const key of keysInFile(file)) {
+				if (seen.has(key)) continue;
+				seen.add(key);
+				records.push({
+					key,
+					package: pack.name,
+					kind: pack.name.startsWith("@deepseek-ai/") ? "core" : "plugin",
+					entry: `${pack.name}/lib/${name}`
 				});
-				events.length = rowStart;
-				gapped = true;
-				break;
 			}
-			events.push(event);
 		}
-		if (gapped) break;
 	}
-	const openStep = findOpenStep(events);
-	let header;
-	const headerLine = lines[0];
-	if (headerLine !== void 0) try {
-		const parsed = JSON.parse(headerLine);
-		if (typeof parsed === "object" && parsed !== null) header = parsed;
-	} catch {}
-	return {
-		events,
-		frames: frames.length,
-		...tornStart === void 0 ? {} : { tornStart },
-		recoveredFromTorn,
-		issues,
-		decoder: decoders === void 0 ? "local" : "official",
-		...openStep === void 0 ? {} : { openStep },
-		...header === void 0 ? {} : { header }
-	};
+	return records.sort((left, right) => left.key.localeCompare(right.key));
 }
-/** 从文件读取并解码。 */
-function decodeSessionLogFile(file, decoders) {
-	return decodeSessionLogBytes(file, readFileSync(file), decoders);
+/** 索引查询器。 */
+function createAttributor(index) {
+	const byKey = new Map(index.map((record) => [record.key, record]));
+	return (projection) => {
+		const owner = byKey.get(projection);
+		if (owner === void 0) return {
+			projection,
+			package: "unknown"
+		};
+		return {
+			projection,
+			package: owner.package
+		};
+	};
 }
-/** 尾部未收尾的 open step（有 step/start 无对应 step/end）。 */
-function findOpenStep(events) {
-	let open;
-	for (const event of events) {
-		const data = event.data;
-		if (event.type === "step/start" && typeof data?.turn === "number" && typeof data?.step === "number") {
-			open = {
-				turn: data.turn,
-				step: data.step
-			};
-			continue;
+//#endregion
+//#region src/host/health/cache.ts
+/** 进程内体检缓存：分批扫描过程中累积，走完一遍语料才成型。 */
+var HealthCache = class {
+	ready;
+	pending;
+	/** 读当前成型的缓存（未成型则 undefined）。 */
+	read() {
+		return this.ready;
+	}
+	/** 开始一轮分批扫描（客户端以 `offset: 0` 发起时调用）。 */
+	begin(total) {
+		this.pending = {
+			total: Math.max(0, Math.floor(total)),
+			findings: [],
+			visited: 0
+		};
+	}
+	/**
+	* 追加一批扫描结果。
+	*
+	* 只有累积的已访问数走满语料总数才成型；语言中途断掉（关面板、报错）不会留下
+	* 半份缓存冒充完整结果。
+	* @param findings - 本批的非 ok 报告。
+	* @param scanned - 本批**已访问**的会话数（不是命中数）。
+	* @param now - 时间源（测试可控）。
+	* @returns 本批追加后缓存是否刚好成型。
+	*/
+	append(findings, scanned, now = Date.now) {
+		const pending = this.pending;
+		if (pending === void 0) return false;
+		pending.findings.push(...findings);
+		pending.visited += Math.max(0, Math.floor(scanned));
+		if (pending.visited < pending.total) return false;
+		this.ready = {
+			findings: pending.findings,
+			total: pending.total,
+			generatedAt: now()
+		};
+		this.pending = void 0;
+		return true;
+	}
+	/**
+	* 单条就地回写（单会话体检 / 可逆处置后调用）。
+	*
+	* 这是缓存的**关键收益**：处置本就重算了 `after` 报告，把它写回即可，
+	* 不必为了刷新一行而重扫整个语料。
+	* @param report - 重算出的单会话报告。
+	* @returns 是否真的改动了缓存（无缓存时为 false）。
+	*/
+	patch(report) {
+		const ready = this.ready;
+		if (ready === void 0) return false;
+		const index = ready.findings.findIndex((entry) => entry.sessionId === report.sessionId);
+		if (report.level === "ok") {
+			if (index < 0) return false;
+			ready.findings.splice(index, 1);
+			return true;
 		}
-		if (event.type === "step/end") open = void 0;
+		if (index >= 0) ready.findings[index] = report;
+		else ready.findings.push(report);
+		return true;
 	}
-	return open;
-}
+	/** 丢弃缓存与未完成的累积。 */
+	clear() {
+		this.ready = void 0;
+		this.pending = void 0;
+	}
+};
 //#endregion
 //#region src/host/health/generation.ts
 /**
@@ -1700,6 +2020,7 @@ function buildSessionReport(context) {
 		gates.push(gateProjectionCache(readProjectionCache(context.sessionId, tail.lastSeq, context.dshHome)));
 		gates.push(gateLosslessJson(context.projectionState, context.attribute));
 		gates.push(gateColdRead(tail));
+		gates.push(gateSourceKind(readSourceKindFacts(log)));
 	}
 	const level = gates.some((gate) => gate.level === "fail") ? "fail" : gates.some((gate) => gate.level === "warn") ? "warn" : "ok";
 	return {
@@ -2017,28 +2338,17 @@ function scanSessions(options) {
 //#region src/index.ts
 /** 本插件声明的宿主服务（与 toggle 相同的注入面）。 */
 const inject = ["webServer", "webRuntime"];
-/** 运行时配置 schema（与 src/config.ts 的形状保持一致）。 */
+/** Resolve one possibly-volatile field: a live ref on 0.1.7+, a plain value otherwise. */
+function readVolatileValue(value) {
+	if (value !== null && typeof value === "object" && typeof value.get === "function") return value.get();
+	return value;
+}
+/** 运行时配置 schema（与 src/config.ts 的形状保持一致）。0.1.7：volatile 字段即设置表单。 */
 const Config = z.object({
-	enabled: z.boolean().default(true),
-	historyFiles: z.boolean().default(true),
-	healthCheck: z.boolean().default(true)
+	enabled: z.boolean().default(true).volatile(),
+	historyFiles: z.boolean().default(true).volatile(),
+	healthCheck: z.boolean().default(true).volatile()
 });
-/**
-* 官方 `installSettingsSection` 的内联等价：通过 settings 服务注册命名空间、
-* 以组合入口作为 `base` 层、并保持运行时来源实时（与 toggle / thinking-levels 同范式）。
-*/
-function installSettingsSection(ctx, ns, schema, entry, hooks) {
-	ctx.inject(["settings"], (sctx) => {
-		const scope = sctx.settings.register(ns, schema, { base: entry });
-		hooks.setSource(() => scope.get());
-		hooks.onChange();
-		sctx.effect(() => () => {
-			hooks.setSource(() => entry);
-			hooks.onChange();
-		});
-		scope.watch(() => hooks.onChange());
-	});
-}
 /** 单次请求体的上限（防御无界读取）。 */
 const MAX_BODY_BYTES = 16 << 20;
 /** 归一化 Host authority，无法解析时为 undefined。 */
@@ -2133,7 +2443,8 @@ const HEALTH_METHODS = [
 	"session-health-status",
 	"session-health-scan",
 	"session-health-session",
-	"session-health-repair"
+	"session-health-repair",
+	"session-health-source-migrate"
 ];
 /** 依据开关判定某方法是否启用。 */
 function methodEnabled(method, config) {
@@ -2244,6 +2555,31 @@ async function handleMethod(method, payload, runtime) {
 			prescriptions: prescribe(report, runtime.dshHome)
 		};
 	}
+	if (method === "session-health-source-migrate") {
+		if (session.logPath === void 0) return {
+			ok: false,
+			error: "会话尚未发布当前代日志，无从转换（先用会话代次工具发布）"
+		};
+		const log = decodeSessionLogFile(session.logPath);
+		const outcome = migrateSessionSourceKind(sessionId, session.logPath, log, runtime.dshHome);
+		const after = buildSessionReport({
+			sessionId,
+			dshHome: runtime.dshHome,
+			logPath: session.logPath,
+			generations: session.generations,
+			...projectionState === void 0 ? {} : { projectionState },
+			attribute: runtime.attribute
+		});
+		runtime.cache?.patch(after);
+		runtime.log(`source-kind migrate ${sessionId}: ok=${outcome.ok} changed=${outcome.changedRows ?? 0}` + (outcome.error === void 0 ? "" : ` error=${outcome.error}`));
+		return {
+			ok: outcome.ok,
+			outcome,
+			after,
+			report: after,
+			error: outcome.error
+		};
+	}
 	const before = reportFor();
 	if (before.level === "ok") {
 		runtime.cache?.patch(before);
@@ -2291,19 +2627,15 @@ async function handleMethod(method, payload, runtime) {
 	};
 }
 /**
-* 插件主体：注册设置命名空间、装配运行时、挂载 fenced 路由。
-* @param ctx - host 插件上下文（webServer / webRuntime / 可选 settings、sessionQuery、sessions、sessionProjections）。
+* 插件主体：装配运行时、挂载 fenced 路由。
+* @param ctx - host 插件上下文（webServer / webRuntime / 可选 sessionQuery、sessions、sessionProjections）。
+* @param config - 组合条目（0.1.7：`.volatile()` 字段为 live ref）。
 */
-function apply(ctx) {
-	let current = () => DEFAULT_CONFIG;
-	installSettingsSection(ctx, STEWARD_SETTINGS_NAMESPACE, Config, DEFAULT_CONFIG, {
-		setSource: (source) => {
-			current = () => ({
-				...DEFAULT_CONFIG,
-				...source()
-			});
-		},
-		onChange: () => {}
+function apply(ctx, config = {}) {
+	const current = () => ({
+		enabled: readVolatileValue(config.enabled) ?? DEFAULT_CONFIG.enabled,
+		historyFiles: readVolatileValue(config.historyFiles) ?? DEFAULT_CONFIG.historyFiles,
+		healthCheck: readVolatileValue(config.healthCheck) ?? DEFAULT_CONFIG.healthCheck
 	});
 	const log = (message) => {
 		try {
@@ -2395,4 +2727,4 @@ function apply(ctx) {
 	}), "dsh-manage-session: /session-steward/api route");
 }
 //#endregion
-export { DEFAULT_CONFIG, HEALTH_METHODS, HISTORY_METHODS, HealthCache, STEWARD_API_PREFIX, STEWARD_SETTINGS_NAMESPACE, apply, assessRepair, buildProjectionOwnerIndex, buildSessionReport, classifyGenerationFilename, countCorpus, createAttributor, decodeSessionLogBytes, decodeSessionLogFile, dirSize, discoverSessions, editWorkspaceDocument, findSession, findSessionLog, firstLosslessViolation, gateColdRead, gateGeneration, gateLogIntegrity, gateLosslessJson, gateProjectionCache, generationLogFilename, handleMethod, indexSessionDirs, inject, isLossless, isMigrationStagingFilename, isSafeChild, latestArtifactMtime, listHistory, locateSessionUsage, methodEnabled, parseGenerationLogFilename, prescribe, projCacheRootFor, pruneArchiveFile, pruneHistory, purgeHistory, quarantineProjectionCache, readArchiveSet, readProjectionCache, readSessionGenerations, readTailFacts, scanSessions, scanZstdFrames, sessionPriority, sessionsRootFor };
+export { Config, DEFAULT_CONFIG, HEALTH_METHODS, HISTORY_METHODS, HealthCache, SOURCE_MIGRATE_BACKUP_SUFFIX, STEWARD_API_PREFIX, STEWARD_SETTINGS_NAMESPACE, V4_HOST_MIN, apply, assessRepair, backupFilesIn, buildProjectionOwnerIndex, buildSessionReport, classifyGenerationFilename, countCorpus, createAttributor, decodeSessionLogBytes, decodeSessionLogFile, dirSize, discoverSessions, editWorkspaceDocument, findSession, findSessionLog, firstLosslessViolation, gateColdRead, gateGeneration, gateLogIntegrity, gateLosslessJson, gateProjectionCache, gateSourceKind, generationLogFilename, handleMethod, indexSessionDirs, inject, isLossless, isMigrationStagingFilename, isSafeChild, isSourceMigrateBackupName, latestArtifactMtime, listHistory, locateSessionUsage, methodEnabled, migrateLegacySource, migrateSessionSourceKind, parseGenerationLogFilename, prescribe, projCacheRootFor, pruneArchiveFile, pruneHistory, purgeHistory, quarantineProjectionCache, readArchiveSet, readProjectionCache, readSessionGenerations, readSourceKindFacts, readTailFacts, scanSessions, scanZstdFrames, sessionPriority, sessionsRootFor };