sage-mem 0.8.0 → 0.9.0

package/lib/client.js

@@ -205,7 +205,12 @@ const StarmapRuntime = (function (require, _react) {
 			return { W: W, H: H, pts: pts };
 		}
 
-		function starVisible(p, kindsOn, q) {
+		/**
+		 * 一颗星此刻画不画：归档开关 → 类型开关 → 搜索词，三层依次收窄。
+		 * 归档开关放最前面：关掉「显示档案馆」时，归档星连图例计数都不该占到。
+		 */
+		function starVisible(p, kindsOn, q, showArchived) {
+			if (p.star.archived === true && showArchived === false) return false;
 			if (!kindsOn[p.star.kind]) return false;
 			if (q) {
 				const hay = (p.star.title + " " + p.star.desc + " " + p.star.file).toLowerCase();
@@ -215,9 +220,9 @@ const StarmapRuntime = (function (require, _react) {
 		}
 
 		/** 可见性标记 + 同类最近邻星座连线。 */
-		function buildVisibility(lay, kindsOn, q) {
+		function buildVisibility(lay, kindsOn, q, showArchived) {
 			const flags = [];
-			for (let i = 0; i < lay.pts.length; i++) flags.push(starVisible(lay.pts[i], kindsOn, q));
+			for (let i = 0; i < lay.pts.length; i++) flags.push(starVisible(lay.pts[i], kindsOn, q, showArchived));
 			const byKind = {};
 			for (let i = 0; i < lay.pts.length; i++) {
 				if (!flags[i]) continue;
@@ -389,6 +394,12 @@ const StarmapRuntime = (function (require, _react) {
 			".smap-search::placeholder{color:rgba(219,228,245,.35);}",
 			".smap-btn{background:rgba(255,255,255,.07);border:1px solid rgba(150,170,230,.25);border-radius:8px;color:#dbe4f5;font-size:12px;padding:4px 10px;cursor:pointer;font-family:inherit;}",
 			".smap-btn:hover{background:rgba(255,255,255,.13);}",
+			// 开态（档案馆开关）与主按钮（恢复）：沿用同一套夜色调，不新增色板。
+			// 「显示档案馆」的开/关要一眼看出来：开 = 亮边 + 蓝调底 + 亮字，关 = 整体压暗。
+			".smap-btn.on{border-color:rgba(150,170,230,.78);background:rgba(122,158,255,.20);color:#eef3ff;}",
+			'.smap-ar-toggle[aria-pressed="false"]{opacity:.60;}',
+			".smap-btn:disabled{opacity:.5;cursor:default;}",
+			".smap-btn-primary{border-color:rgba(150,170,230,.55);background:rgba(122,158,255,.20);}",
 			".smap-wrap{position:relative;flex:1;min-height:0;}",
 			".smap-canvas{position:absolute;inset:0;width:100%;height:100%;display:block;border-radius:10px;cursor:crosshair;}",
 			".smap-tip{position:absolute;z-index:5;pointer-events:none;max-width:280px;background:rgba(10,14,30,.95);border:1px solid rgba(150,170,230,.35);border-radius:8px;padding:8px 10px;font-size:12px;line-height:1.55;box-shadow:0 6px 24px rgba(0,0,0,.45);}",
@@ -399,6 +410,7 @@ const StarmapRuntime = (function (require, _react) {
 			".smap-panel-head{display:flex;align-items:flex-start;gap:8px;margin-bottom:4px;}",
 			".smap-panel-title{font-weight:600;font-size:14px;flex:1;}",
 			".smap-panel-meta{font-size:11px;opacity:.6;margin-bottom:8px;}",
+			".smap-panel-arch{display:flex;flex-direction:column;gap:6px;border:1px solid rgba(150,170,230,.28);border-radius:8px;padding:8px 10px;background:rgba(255,255,255,.03);}",
 			".smap-meta-dot{display:inline-block;width:7px;height:7px;border-radius:50%;margin-right:4px;vertical-align:-1px;}",
 			".smap-legend{display:flex;flex-wrap:wrap;gap:14px;margin-top:10px;font-size:12px;align-items:center;}",
 			".smap-lg-item{cursor:pointer;user-select:none;}",
@@ -426,6 +438,8 @@ const StarmapRuntime = (function (require, _react) {
 			".smap-timeline{position:absolute;inset:0;overflow-y:auto;display:flex;flex-direction:column;gap:6px;padding:4px 6px 4px 2px;}",
 			".smap-tl-item{display:flex;align-items:baseline;gap:8px;background:rgba(255,255,255,.035);border:1px solid rgba(150,170,230,.16);border-radius:8px;padding:7px 10px;cursor:pointer;flex:none;}",
 			".smap-tl-item:hover{background:rgba(255,255,255,.08);border-color:rgba(150,170,230,.35);}",
+			".smap-tl-item--arch{opacity:.75;}",
+			".smap-ar-badge{font-size:10.5px;opacity:.65;border:1px solid rgba(150,170,230,.3);border-radius:5px;padding:0 5px;flex:none;align-self:center;}",
 			".smap-tl-date{font-size:11px;opacity:.5;font-variant-numeric:tabular-nums;flex:none;}",
 			".smap-tl-title{font-size:13px;font-weight:600;flex:none;max-width:40%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}",
 			".smap-tl-desc{font-size:12px;opacity:.55;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;flex:1;}",
@@ -448,6 +462,22 @@ const StarmapRuntime = (function (require, _react) {
 			return [((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255];
 		}
 
+		// 归档星（暗星）的用色：把类型色往石板灰上压 —— 它得「还在图上、一眼数得出来」，
+		// 又要一眼看出不是活记忆。亮度靠 shader 那一档（0.52），这里负责色相：冷、灰、不饱和。
+		const ARCHIVE_GREY = [0.46, 0.50, 0.58];
+		function dimRgb(hex) {
+			const c = hexToRgb(hex);
+			return [
+				c[0] * 0.26 + ARCHIVE_GREY[0] * 0.74,
+				c[1] * 0.26 + ARCHIVE_GREY[1] * 0.74,
+				c[2] * 0.26 + ARCHIVE_GREY[2] * 0.74,
+			];
+		}
+		function dimCss(hex) {
+			const c = dimRgb(hex);
+			return "rgb(" + Math.round(c[0] * 255) + "," + Math.round(c[1] * 255) + "," + Math.round(c[2] * 255) + ")";
+		}
+
 		const SMAP_BG_VS = "attribute vec2 aPos; void main(){ gl_Position = vec4(aPos, 0.0, 1.0); }";
 		// 底色（重做过一版）。旧版是四层 fbm 噪声算出来的蓝紫星云，还带 uTime 动画 ——
 		// 「会呼吸的彩色底」正是廉价感的一大来源，而且每帧都要重算噪声。
@@ -509,11 +539,15 @@ const StarmapRuntime = (function (require, _react) {
 			"  if (vMeta1.z < -0.5){",
 			"    alpha = smoothstep(0.55, 0.0, d) * vColor.a;",
 			"  } else {",
-			"    float aFresh = mix(0.60, 1.0, vMeta1.y);",
+			"    // 归档星（vMeta1.y = -1）单独一档 0.52：核心小而暗；外圈的存在感由另画的一层",
+			"    // 淡底盘负责（见 uploadStars），所以这里不用改辉光形状。",
+			"    float aFresh = vMeta1.y < -0.5 ? 0.52 : mix(0.60, 1.0, vMeta1.y);",
+			"    float hov = abs(vMeta1.z - uHoverIdx) < 0.5 ? 1.0 : 0.0;",
+			"    if (hov > 0.5 && vMeta1.y < -0.5) aFresh = 1.0;", // 悬停把暗星临时点亮
 			"    float core = smoothstep(0.30, 0.04, d);",
 			"    float glow = exp(-d * 3.8) * 0.30;",
 			"    alpha = (core + glow) * aFresh;",
-			"    if (abs(vMeta1.z - uHoverIdx) < 0.5){",
+			"    if (hov > 0.5){",
 			"      alpha += smoothstep(0.10, 0.0, abs(d - 0.62)) * 0.55;",
 			"    }",
 			"    alpha = clamp(alpha, 0.0, 1.0);",
@@ -648,9 +682,20 @@ const StarmapRuntime = (function (require, _react) {
 						if (!visBox.flags[i]) continue;
 						const p = layout.pts[i];
 						const meta = KIND_META[p.star.kind] || KIND_META.special;
+						const arch = p.star.archived === true;
 						const fresh = p.star.mtimeMs > 0 && nowMs - p.star.mtimeMs < FRESH_MS ? 1 : 0;
 						const birth = p.star.mtimeMs > 0 ? p.star.mtimeMs : 0;
-						pushStarQuad(arr, p.x, p.y, p.r * 5.4, hexToRgb(meta.color), 1, p.tw, fresh, i, birth);
+						if (arch) {
+							// 归档星 = 暗星，两层画：
+							//   ① 一层很淡的冷色底盘（走 dust 分支：不带星芒、不参与 hover），
+							//      负责「深空底上一眼数得出来」——只画一个小点是数不出来的；
+							//   ② 一颗小核心（走普通分支，fresh 传 -1 = 归档档 0.52），负责
+							//      「看得出是颗星」，并且 hover 时整颗点亮 + 出环。
+							pushStarQuad(arr, p.x, p.y, p.r * 6.0, dimRgb(meta.color), 0.26, p.tw, 0, -1, birth);
+							pushStarQuad(arr, p.x, p.y, p.r * 4.4, dimRgb(meta.color), 1, p.tw, -1, i, birth);
+						} else {
+							pushStarQuad(arr, p.x, p.y, p.r * 5.4, hexToRgb(meta.color), 1, p.tw, fresh, i, birth);
+						}
 					}
 					gl.bindBuffer(gl.ARRAY_BUFFER, starBuf);
 					gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(arr), gl.DYNAMIC_DRAW);
@@ -800,6 +845,35 @@ const StarmapRuntime = (function (require, _react) {
 						if (rv <= 0) continue;
 					}
 					const tw = 0.72 + 0.28 * Math.sin(phase * 2.1 + p.tw * Math.PI * 2);
+					if (p.star.archived === true) {
+						// 暗星（canvas2d 兜底路径）：与 webgl 同一档 —— 核心小而暗、外面一圈很淡的冷辉光。
+						// 有辉光才「数得出来」；hover 时整颗点亮 + 描边环，这是它能被发现的关键。
+						const hot = hoverBox.idx === i;
+						const dc = dimRgb(meta.color);
+						const rgba = (a) => "rgba(" + Math.round(dc[0] * 255) + "," + Math.round(dc[1] * 255) + "," + Math.round(dc[2] * 255) + "," + a.toFixed(3) + ")";
+						const haloR = p.r * 3.4;
+						const hg = c2d.createRadialGradient(p.x, p.y, 0, p.x, p.y, haloR);
+						hg.addColorStop(0, rgba((hot ? 0.50 : 0.26) * rv));
+						hg.addColorStop(1, rgba(0));
+						c2d.fillStyle = hg;
+						c2d.beginPath();
+						c2d.arc(p.x, p.y, haloR, 0, Math.PI * 2);
+						c2d.fill();
+						c2d.globalAlpha = (hot ? 0.95 : 0.52) * rv;
+						c2d.fillStyle = dimCss(meta.color);
+						c2d.beginPath();
+						c2d.arc(p.x, p.y, Math.max(1.2, p.r * 0.7), 0, Math.PI * 2);
+						c2d.fill();
+						c2d.globalAlpha = 1;
+						if (hot) {
+							c2d.strokeStyle = dimCss(meta.color);
+							c2d.lineWidth = 1;
+							c2d.beginPath();
+							c2d.arc(p.x, p.y, p.r + 5, 0, Math.PI * 2);
+							c2d.stroke();
+						}
+						continue;
+					}
 					if (p.star.mtimeMs > 0 && nowMs - p.star.mtimeMs < FRESH_MS) {
 						const pr = p.r + 5 + 3 * (0.5 + 0.5 * Math.sin(phase * 1.4 + p.tw * 6.28));
 						c2d.strokeStyle = hexA(meta.color, 0.4 * rv);
@@ -890,6 +964,14 @@ const StarmapRuntime = (function (require, _react) {
 			const replayDateS = react.useState(null);
 			const replayDate = replayDateS[0];
 			const setReplayDate = replayDateS[1];
+			// 档案馆开关：默认**开** —— 关着的默认值等于用户不知道图上有归档星。
+			// 关掉只改本地可见性，不重新取数（数据一次拿全，过滤在客户端做）。
+			const showArchS = react.useState(true);
+			const showArchive = showArchS[0];
+			const setShowArchive = showArchS[1];
+			const restoringS = react.useState(null);
+			const restoring = restoringS[0];
+			const setRestoring = restoringS[1];
 
 			const hoverBox = react.useRef({ idx: -1 }).current;
 			const visBox = react.useRef({ flags: [], lines: [] }).current;
@@ -921,7 +1003,7 @@ const StarmapRuntime = (function (require, _react) {
 					setBusy(false);
 					setErr("拉取超时：starmap 服务 20 秒无响应——Host 端服务大概率未激活，需要重启 DSH 让插件行重新装载");
 				}, 20000);
-				remote.listStars().then((r) => {
+				remote.listStars(true).then((r) => {
 					if (!alive || settled) return;
 					settled = true;
 					clearTimeout(guard);
@@ -1000,7 +1082,7 @@ const StarmapRuntime = (function (require, _react) {
 			react.useEffect(() => {
 				if (!data || !layout || !kindsOn) return;
 				const q = query.trim().toLowerCase();
-				const vis = buildVisibility(layout, kindsOn, q);
+				const vis = buildVisibility(layout, kindsOn, q, showArchive);
 				visBox.flags = vis.flags;
 				visBox.lines = vis.lines;
 				let anyVis = false;
@@ -1012,7 +1094,7 @@ const StarmapRuntime = (function (require, _react) {
 					if (drawBox.markDirty) drawBox.markDirty();
 					else drawBox.renderer.render((Date.now() - drawBox.t0) / 1000);
 				}
-			}, [data, layout, kindsOn, query]);
+			}, [data, layout, kindsOn, query, showArchive]);
 
 			function hitTest(e) {
 				if (!layout) return -1;
@@ -1021,14 +1103,17 @@ const StarmapRuntime = (function (require, _react) {
 				const sx = (e.clientX - rect.left) * (layout.W / rect.width);
 				const sy = (e.clientY - rect.top) * (layout.H / rect.height);
 				let best = -1;
-				let bestD = 144;
+				let bestD = Infinity;
 				for (let i = 0; i < layout.pts.length; i++) {
 					if (!visBox.flags[i]) continue;
 					const p = layout.pts[i];
 					const dx = p.x - sx;
 					const dy = p.y - sy;
 					const d = dx * dx + dy * dy;
-					if (d < bestD) { bestD = d; best = i; }
+					// 每颗星有自己的热区：暗星画得小，热区反而要更大（16px），否则
+					// 就成了「看得见但点不中」。活星仍是 12px。
+					const lim = p.star.archived === true ? 256 : 144;
+					if (d < lim && d < bestD) { bestD = d; best = i; }
 				}
 				return best;
 			}
@@ -1060,8 +1145,14 @@ const StarmapRuntime = (function (require, _react) {
 				setHover(null);
 			}
 
+			/**
+			 * 打开详情。归档星不在这里展开正文：starmap.readFile 只读记忆根目录，
+			 * 归档那份在 archive/ 下取不到 —— 与其弹一句「读取失败」，不如面板直接
+			 * 给归档信息 + 「恢复」；恢复之后远程自然读得到它。
+			 */
 			function openStar(st) {
 				setSelected({ star: st, text: null });
+				if (st.archived === true) return;
 				const remote = ctx.get("remote.starmap");
 				if (!remote) return;
 				remote.readFile(st.file).then((r) => {
@@ -1077,6 +1168,26 @@ const StarmapRuntime = (function (require, _react) {
 				});
 			}
 
+			/** 从星图直接恢复一颗归档星：成功后重新取数，星回到活星区。 */
+			function restoreStar(st) {
+				const remote = ctx.get("remote.memory");
+				if (!remote || typeof remote.restore !== "function") {
+					setErr("宿主侧没有 restore 接口（插件版本较旧）");
+					return;
+				}
+				setErr("");
+				setRestoring(st.file);
+				remote.restore(st.file).then((r) => {
+					setRestoring(null);
+					if (r && r.ok === false) { setErr(r.error || "恢复被拒绝"); return; }
+					setSelected(null);
+					refresh();
+				}, (e) => {
+					setRestoring(null);
+					setErr(detail(e));
+				});
+			}
+
 			function onClick(e) {
 				const best = hitTest(e);
 				if (best < 0 || !layout) return;
@@ -1091,7 +1202,8 @@ const StarmapRuntime = (function (require, _react) {
 				setSelected(null);
 				setErr("");
 				setBusy(true);
-				remote.listStars().then((r) => {
+				// 连归档星一起取：暗星是背景，不该为它再跑一次请求。
+				remote.listStars(true).then((r) => {
 					setBusy(false);
 					const d = unwrap(r);
 					if (d && Array.isArray(d.stars)) setData(d);
@@ -1152,15 +1264,20 @@ const StarmapRuntime = (function (require, _react) {
 				replayBox.raf = window.requestAnimationFrame(tick);
 			}
 
+			// 归档星数（数据一次取全，含归档）：头部开关与图例计数都要用。
+			const archivedN = data ? data.stars.filter((s) => s.archived === true).length : 0;
+
 			let body;
 			if (err) {
 				body = h("div", { className: "smap-status" }, "点亮失败：" + err);
 			} else if (!data || !layout || !kindsOn) {
 				body = h("div", { className: "smap-status" }, busy ? "正在点亮星空…" : "整理星图…");
 			} else {
+				// 「显示档案馆」关掉时，图例计数也只算活星 —— 屏幕上没有的东西不该占数字。
+				const viewStars = showArchive ? data.stars : data.stars.filter((s) => s.archived !== true);
 				const legendKids = [];
 				for (const k of KIND_ORDER) {
-					const n = data.stars.filter((s) => s.kind === k).length;
+					const n = viewStars.filter((s) => s.kind === k).length;
 					if (n === 0) continue;
 					legendKids.push(h("span", {
 						key: k,
@@ -1173,12 +1290,14 @@ const StarmapRuntime = (function (require, _react) {
 				}
 				let totalBytes = 0;
 				let newest = 0;
-				for (const s of data.stars) {
+				for (const s of viewStars) {
 					totalBytes += s.bytes || 0;
 					if (s.mtimeMs > newest) newest = s.mtimeMs;
 				}
 				legendKids.push(h("span", { key: "count", className: "smap-count" },
-					data.count + " 条 · " + fmtBytes(totalBytes) + (newest ? " · 最近更新 " + fmtDate(newest) : "") + " · 单击看全文"));
+					viewStars.length + " 条 · " + fmtBytes(totalBytes) + (newest ? " · 最近更新 " + fmtDate(newest) : "") +
+					(showArchive && archivedN ? " · 档案馆 " + archivedN + " 颗暗星" : "") +
+					" · 单击看" + (showArchive && archivedN ? "详情" : "全文")));
 
 				const tip = hover ? (() => {
 					const meta = KIND_META[hover.star.kind] || KIND_META.special;
@@ -1187,6 +1306,12 @@ const StarmapRuntime = (function (require, _react) {
 						h("div", { key: "k", className: "smap-tip-kind" },
 							meta.label + " · " + hover.star.file + " · " + fmtBytes(hover.star.bytes)),
 					];
+					if (hover.star.archived === true) {
+						// 悬浮也要说清它是档案馆里的：暗星外表已经不同，别让人猜。
+						kids.push(h("div", { key: "arch", className: "smap-tip-kind" },
+							"已归档" + (hover.star.archivedAt ? " · " + hover.star.archivedAt : "") +
+							(hover.star.archivedReason ? " · " + hover.star.archivedReason : "")));
+					}
 					if (hover.star.desc) {
 						const d = hover.star.desc.length > 90 ? hover.star.desc.slice(0, 90) + "…" : hover.star.desc;
 						kids.push(h("div", { key: "d", className: "smap-tip-desc" }, d));
@@ -1204,9 +1329,27 @@ const StarmapRuntime = (function (require, _react) {
 						h("div", { key: "meta", className: "smap-panel-meta" },
 							h("span", { className: "smap-meta-dot", style: { background: meta.color } }),
 							meta.label + " · " + selected.star.file + " · " + fmtBytes(selected.star.bytes) +
-							(selected.star.mtimeMs ? " · " + fmtDate(selected.star.mtimeMs) : "")),
+							// 归档星的 mtime 是「当年写下」的时间，跟「什么时候收起来的」不是一回事 ——
+							// 这里只留「已归档」，具体时间在下面的归档块里给。
+							(selected.star.archived === true
+								? " · 已归档"
+								: (selected.star.mtimeMs ? " · " + fmtDate(selected.star.mtimeMs) : ""))),
 					];
-					if (selected.text === null) panelKids.push(h("div", { key: "loading", className: "smap-status" }, "展开中…"));
+					if (selected.star.archived === true) {
+						// 归档星：不展开正文（远程读不到 archive/），给归档信息 + 一键恢复。
+						// 恢复了就能正常读 —— 面板给出的是一条出路，不是一个死状态。
+						panelKids.push(h("div", { key: "arch", className: "smap-panel-arch" }, [
+							h("div", { key: "at" }, "已归档于 " + (selected.star.archivedAt || "（时间未知）")),
+							h("div", { key: "why" }, "理由：" + (selected.star.archivedReason || "（没写）")),
+							h("div", { key: "hint", className: "smap-panel-meta" },
+								"归档的记忆不参与检索与星图；原文仍在记忆目录的 archive/ 下，恢复后即可正常阅读。"),
+							h("button", {
+								key: "restore", className: "smap-btn smap-btn-primary",
+								disabled: restoring === selected.star.file,
+								onClick: () => restoreStar(selected.star),
+							}, restoring === selected.star.file ? "恢复中…" : "恢复到活动记忆"),
+						]));
+					} else if (selected.text === null) panelKids.push(h("div", { key: "loading", className: "smap-status" }, "展开中…"));
 					else panelKids.push(h("div", { key: "body" }, renderMarkdown(selected.text)));
 					panel = h("div", { className: "smap-panel" }, panelKids);
 				}
@@ -1215,19 +1358,20 @@ const StarmapRuntime = (function (require, _react) {
 				if (viewMode === "timeline") {
 					const q2 = query.trim().toLowerCase();
 					const sorted = data.stars
-						.filter((s) => starVisible({ star: s }, kindsOn, q2))
+						.filter((s) => starVisible({ star: s }, kindsOn, q2, showArchive))
 						.sort((a, b) => (b.mtimeMs || 0) - (a.mtimeMs || 0) || a.file.localeCompare(b.file));
 					mainView = h("div", { className: "smap-wrap", key: "wrap" },
 						h("div", { className: "smap-timeline" },
 							sorted.length === 0
 								? h("div", { className: "smap-status" }, "这片天区安静了")
 								: sorted.map((s) => h("div", {
-										className: "smap-tl-item",
+										className: "smap-tl-item" + (s.archived === true ? " smap-tl-item--arch" : ""),
 										key: s.file,
 										onClick: () => openStar(s),
-										title: "展开全文",
+										title: s.archived === true ? "归档案：点开看归档信息并恢复" : "展开全文",
 									},
-									h("span", { className: "smap-meta-dot", style: { background: (KIND_META[s.kind] || KIND_META.special).color, flex: "none", alignSelf: "center" } }),
+									h("span", { className: "smap-meta-dot", style: { background: s.archived === true ? dimCss((KIND_META[s.kind] || KIND_META.special).color) : (KIND_META[s.kind] || KIND_META.special).color, flex: "none", alignSelf: "center" } }),
+									s.archived === true ? h("span", { className: "smap-ar-badge" }, "已归档") : null,
 									h("span", { className: "smap-tl-date", title: s.mtimeMs ? fmtDate(s.mtimeMs) : "" }, s.mtimeMs ? fmtRel(s.mtimeMs) : "—"),
 									h("span", { className: "smap-tl-title" }, s.title),
 									h("span", { className: "smap-tl-desc" }, s.desc || "")))),
@@ -1252,13 +1396,24 @@ const StarmapRuntime = (function (require, _react) {
 			}
 
 			return h("div", { className: "smap-card" },
+				// 卡片里不再重复「记忆星图 / sage-mem memory」这一行 —— 标题已经在面板顶部
+				// 那条共用头部带里（「我在哪」），这里只留控件，少一行噪音。
 				h("div", { className: "smap-head" },
-					h("span", { className: "smap-title" }, "记忆星图"),
-					h("span", { className: "smap-sub" }, "sage-mem memory · 每颗星是一条记忆"),
 					h("span", { className: "smap-spacer" }),
 					h("span", { className: "smap-viewtoggle" },
 						h("button", { className: "smap-vt-btn" + (viewMode === "sky" ? " on" : ""), onClick: () => setViewMode("sky"), title: "空间视角：星座分布" }, "星空"),
 						h("button", { className: "smap-vt-btn" + (viewMode === "timeline" ? " on" : ""), onClick: () => setViewMode("timeline"), title: "时间视角：最近更新在前" }, "时间线")),
+					// 档案馆开关：默认开。关掉只是本地不再画暗星，不重新取数。
+					// 只留文字，不挂数字（计数归脚注的「档案馆 N 颗暗星」）；开/关靠 on 态
+					// 与 aria-pressed 的样式差，别让人猜现在是开还是关。
+					h("button", {
+						className: "smap-btn smap-ar-toggle" + (showArchive ? " on" : ""),
+						"aria-pressed": showArchive ? "true" : "false",
+						onClick: () => setShowArchive(!showArchive),
+						title: showArchive
+							? "开着：已归档的记忆画成暗星。点一下只留活星（不重新取数）"
+							: "关着：图上只有活星。点一下把已归档的记忆也画成暗星",
+					}, "显示档案馆"),
 					viewMode === "sky" ? h("button", {
 						className: "smap-btn" + (replaying ? " smap-replay-on" : ""),
 						onClick: () => (replaying ? stopReplay() : startReplay()),
@@ -1366,6 +1521,28 @@ const StarmapRuntime = (function (require, _react) {
 		const starmapListSchema = { parse(v) { if (!v || typeof v !== "object") throw new Error("expected object"); if (!Array.isArray(v.stars)) throw new Error("expected stars array"); v.stars.forEach((f) => starmapStarSchema.parse(f)); return v; } };
 		const starmapReadSchema = parseSchema({ "name": isStr, "content": isStr });
 
+		// ── 归档区（v0.9.0 档案馆）──
+		// 客户端只声明 remote 面：面板上的「已归档」区由后续 UI 任务接。
+		// 结果 codec 与宿主 manifest 逐字段对齐（ArchiveResult 的 file / error 都可选，
+		// 成功回 file、失败回 error，所以这里只硬校 ok）。
+		const boolSchema = { parse(v) { isBool(v); return v; } };
+		const archiveSchema = parseSchema({ "ok": isBool });
+		const archivedFileSchema = parseSchema({
+			"file": isStr, "type": isStr, "description": isStr, "size": isNum,
+			"archivedAt": isStr, "archivedReason": isStr,
+		});
+		const archivedListSchema = {
+			parse(v) {
+				if (!v || typeof v !== "object") throw new Error("sage-mem: expected object");
+				if (!Array.isArray(v.files)) throw new Error("sage-mem: expected files array");
+				v.files.forEach((f) => archivedFileSchema.parse(f));
+				return v;
+			},
+		};
+		// 归档文件的读 / 写（B1b）：形状与活跃记忆那套的 readSchema / writeSchema 对称。
+		const archivedReadSchema = parseSchema({ "name": isStr, "content": isStr });
+		const archivedWriteSchema = parseSchema({ "ok": isBool, "file": isStr });
+
 		// ── autodream 的 codec ──
 		// 刻意写得宽：这几个方法返回的是配置 / 状态对象，字段会随版本增删。
 		// 用 parseSchema 逐字段硬写一遍的代价是 —— host 那边加一个字段，client 的旧
@@ -1434,13 +1611,145 @@ const StarmapRuntime = (function (require, _react) {
 					result: { mode: "strict", typeSymbol: "sage-mem/types#DeleteResult", schema: deleteSchema, create: () => deleteSchema },
 					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
 				},
+				{
+					id: "sage-mem#memory/archive",
+					service: "memory",
+					namespace: "memory",
+					method: "archive",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#FileName", schema: strSchema, create: () => strSchema } },
+						{ name: "reason", wire: "reason", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#ArchiveReason", schema: strSchema, create: () => strSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#ArchiveResult", schema: archiveSchema, create: () => archiveSchema },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/restore",
+					service: "memory",
+					namespace: "memory",
+					method: "restore",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#FileName", schema: strSchema, create: () => strSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#ArchiveResult", schema: archiveSchema, create: () => archiveSchema },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/listArchived",
+					service: "memory",
+					namespace: "memory",
+					method: "listArchived",
+					invocation: { kind: "direct" },
+					parameters: [],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#ArchivedList", schema: archivedListSchema, create: () => archivedListSchema },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/readArchived",
+					service: "memory",
+					namespace: "memory",
+					method: "readArchived",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#ArchivedFileName", schema: strSchema, create: () => strSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#ArchivedFileContent", schema: archivedReadSchema, create: () => archivedReadSchema },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/writeArchived",
+					service: "memory",
+					namespace: "memory",
+					method: "writeArchived",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#ArchivedFileName", schema: strSchema, create: () => strSchema } },
+						{ name: "content", wire: "content", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#ArchivedFileContent", schema: strSchema, create: () => strSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#ArchivedWriteResult", schema: archivedWriteSchema, create: () => archivedWriteSchema },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				// ── 面板 API（D1）：体检 / 归档候选 / 设置 / 保留名原样读写 ──
+				// 结果形状都在演进（审计清单、候选表、设置项），顶层用 objCodec 接住、
+				// 内部宽松 —— 与 autodream 那几个 codec 同一套理由：host 加字段不该让旧界面整体报错。
+				{
+					id: "sage-mem#memory/audit",
+					service: "memory",
+					namespace: "memory",
+					method: "audit",
+					invocation: { kind: "direct" },
+					parameters: [],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#AuditReport", schema: objCodec, create: () => objCodec },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/archiveCandidates",
+					service: "memory",
+					namespace: "memory",
+					method: "archiveCandidates",
+					invocation: { kind: "direct" },
+					parameters: [],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#ArchiveCandidates", schema: objCodec, create: () => objCodec },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/getSettings",
+					service: "memory",
+					namespace: "memory",
+					method: "getSettings",
+					invocation: { kind: "direct" },
+					parameters: [],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#MemorySettings", schema: objCodec, create: () => objCodec },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/setSettings",
+					service: "memory",
+					namespace: "memory",
+					method: "setSettings",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "patch", wire: "patch", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#MemorySettingsPatch", schema: objCodec, create: () => objCodec } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#MemorySettingsResult", schema: objCodec, create: () => objCodec },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/readRaw",
+					service: "memory",
+					namespace: "memory",
+					method: "readRaw",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#ReservedFileName", schema: strSchema, create: () => strSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#RawFileContent", schema: objCodec, create: () => objCodec },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					id: "sage-mem#memory/writeRaw",
+					service: "memory",
+					namespace: "memory",
+					method: "writeRaw",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#ReservedFileName", schema: strSchema, create: () => strSchema } },
+						{ name: "content", wire: "content", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#RawFileContent", schema: strSchema, create: () => strSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#RawWriteResult", schema: objCodec, create: () => objCodec },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
 				{
 					id: "sage-mem#starmap/listStars",
 					service: "starmap",
 					namespace: "starmap",
 					method: "listStars",
 					invocation: { kind: "direct" },
-					parameters: [],
+					parameters: [
+						{ name: "includeArchived", wire: "includeArchived", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#StarmapIncludeArchived", schema: boolSchema, create: () => boolSchema } },
+					],
 					result: { mode: "strict", typeSymbol: "sage-mem/types#StarmapList", schema: starmapListSchema, create: () => starmapListSchema },
 					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
 				},
@@ -1628,6 +1937,79 @@ const StarmapRuntime = (function (require, _react) {
 			".smem-narrative{color:var(--dsw-alias-label-secondary);font-size:12.5px;white-space:pre-wrap;overflow-wrap:anywhere;}",
 			'.smem-narrative[data-clamp="1"]{display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden;cursor:pointer;}',
 			".smem-card-foot{display:flex;justify-content:flex-end;}",
+			// ── 档案馆（文件列表）──
+			// 归档条目整体「退役」：虚线边框 + 灰底 + 内容压灰。
+			// ⚠️ 灰的只许是**内容**（下面这几条只点标题/类型章/标签/正文的字色）。
+			// 绝不给整张卡片加 opacity / filter —— 那会把里面的「编辑 / 恢复」按钮一起灰掉，
+			// 用户会以为按钮不可按（同类误读已经栽过一次）。
+			".smem-card--archived{border-style:dashed;background:var(--dsw-alias-bg-layer-2);}",
+			".smem-card--archived .smem-card-title,.smem-card--archived .smem-badge,.smem-card--archived .smem-tag,.smem-card--archived .smem-narrative{color:var(--dsw-alias-label-secondary);}",
+			".smem-card--archived .smem-badge,.smem-card--archived .smem-tag{opacity:.78;}",
+			// 归档文件的「原样文本」编辑器：等宽字体，正文一字不改。
+			// 选择器写两个类是为了压过后面那条 .smem-textarea{min-height:72px}——
+			// 同一个权重时后定义的赢，单类写法会被它盖掉（截图走查时发现的）。
+			".smem-ar-edit{border-top:1px dashed var(--dsw-alias-border-l2);padding-top:8px;display:flex;flex-direction:column;gap:6px;}",
+			".smem-textarea.smem-ar-editor{min-height:220px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px;line-height:1.6;}",
+			".smem-ar-hint{font-size:11.5px;color:var(--dsw-alias-label-secondary);}",
+			".smem-ar-meta{font-size:11.5px;color:var(--dsw-alias-label-secondary);white-space:nowrap;}",
+			".smem-ar-reason{font-size:12px;color:var(--dsw-alias-label-secondary);border-left:2px solid var(--dsw-alias-border-l2);padding-left:8px;white-space:pre-wrap;overflow-wrap:anywhere;}",
+			".smem-ar-confirm{border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:8px 10px;background:var(--dsw-alias-bg-layer-2);display:flex;flex-direction:column;gap:6px;font-size:12px;line-height:1.55;}",
+			".smem-ar-banner{font-size:12px;color:var(--dsw-alias-label-secondary);border:1px solid var(--dsw-alias-border-l1);border-radius:8px;padding:6px 10px;}",
+			// ── 工具行 + 工具面板（体检 / 归档候选 / 保留名原样编辑）──
+			// 三个新入口收在一行**轻量**文字按钮里：不跟主工具栏抢重量级，也不各占一块版面。
+			// 面板一次只开一个（Section 里一个 tool 状态），否则文件列表会被顶到屏幕外。
+			".smem-tools{display:flex;align-items:center;gap:4px;flex-wrap:wrap;}",
+			".smem-tool-btn{border:0;background:transparent;color:var(--dsw-alias-label-secondary);font-size:12px;font-family:inherit;cursor:pointer;padding:2px 8px;border-radius:6px;}",
+			".smem-tool-btn:hover{color:var(--dsw-alias-label-primary);}",
+			'.smem-tool-btn[data-on="1"]{color:var(--dsw-alias-brand-primary,#4d76e6);background:var(--dsw-alias-bg-layer-2);}',
+			// 工具抽屉：关着时**零占位**（工具栏里只有一个「工具 ▾」），点开才占版面。
+			// ⚠️ 可发现性不靠抽屉本身，靠头部带常显的「体检 N 个问题」徽标 —— 那是整个
+			// 抽屉方案能成立的前提（否则三个能力就退回「藏起来」了）。
+			".smem-drawer{position:relative;flex:none;}",
+			".smem-drawer-pop{position:absolute;right:0;top:calc(100% + 6px);z-index:6;min-width:236px;background:var(--dsw-alias-bg-base);border:1px solid var(--dsw-alias-border-l2);border-radius:10px;box-shadow:0 8px 24px rgba(0,0,0,.10);padding:6px;display:flex;flex-direction:column;gap:2px;}",
+			".smem-drawer-item{display:flex;align-items:center;gap:8px;border:0;background:transparent;font-family:inherit;font-size:12.5px;color:var(--dsw-alias-label-primary);text-align:left;padding:6px 8px;border-radius:8px;cursor:pointer;}",
+			".smem-drawer-item:hover{background:var(--dsw-alias-bg-layer-2);}",
+			'.smem-drawer-item[data-on="1"]{background:var(--dsw-alias-bg-layer-2);font-weight:600;}',
+			".smem-drawer-item .smem-status{margin-left:auto;}",
+			".smem-status--bad{color:var(--dsw-alias-state-error-primary,#dc2626);font-weight:600;}",
+			// 头部带：三个 tab 共用的一条「我在哪 + 现在什么状态 + 主操作」。
+			".smem-head-job{font-size:12.5px;font-weight:600;}",
+			".smem-head-actions{margin-left:auto;display:flex;align-items:center;gap:6px;}",
+			".smem-tool-panel{border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-1);padding:10px 12px;display:flex;flex-direction:column;gap:8px;}",
+			// 体检 / 候选是「翻清单」的面板：定高 + 内部滚动，列表不被顶出首屏。
+			// 原样编辑器（.smem-ar-editor）不设上限 —— 那是专心改一份文件的界面，给它完整高度。
+			".smem-tool-panel--cap{max-height:320px;overflow-y:auto;}",
+			".smem-tool-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap;}",
+			".smem-tool-title{font-weight:600;font-size:13px;}",
+			".smem-tool-badge{display:inline-flex;align-items:center;font-size:11px;color:var(--dsw-alias-label-secondary);border:1px solid var(--dsw-alias-border-l1);border-radius:6px;padding:0 6px;white-space:nowrap;}",
+			".smem-tool-badge--bad{color:var(--dsw-alias-state-error-primary,#dc2626);border-color:var(--dsw-alias-state-error-primary,#dc2626);}",
+			".smem-tool-foot{display:flex;align-items:center;gap:8px;flex-wrap:wrap;}",
+			// 体检：硬问题用红标题分节；提示区单独一块虚线框（**不染红**）。
+			".smem-audit-sec{display:flex;flex-direction:column;gap:3px;}",
+			".smem-audit-h{font-size:12px;font-weight:600;}",
+			".smem-audit-h--hard{color:var(--dsw-alias-state-error-primary,#dc2626);}",
+			".smem-audit-row{font-size:12px;color:var(--dsw-alias-label-secondary);padding-left:10px;overflow-wrap:anywhere;}",
+			".smem-audit-hint{border:1px dashed var(--dsw-alias-border-l2);border-radius:8px;padding:7px 9px;display:flex;flex-direction:column;gap:3px;}",
+			".smem-empty--ok{color:var(--dsw-alias-state-success-primary,#16a34a);border-color:var(--dsw-alias-state-success-primary,#16a34a);}",
+			// 归档候选：每一条都把「为什么建议归档」写出来。
+			".smem-cand-list{display:flex;flex-direction:column;gap:6px;}",
+			".smem-cand-note{font-size:11.5px;color:var(--dsw-alias-label-secondary);line-height:1.5;}",
+			".smem-cand{border:1px solid var(--dsw-alias-border-l1);border-radius:8px;padding:7px 9px;display:flex;flex-direction:column;gap:5px;}",
+			".smem-cand-main{display:flex;align-items:center;gap:8px;flex-wrap:wrap;cursor:pointer;}",
+			".smem-cand-reason{font-size:12px;color:var(--dsw-alias-label-secondary);border-left:2px solid var(--dsw-alias-border-l2);padding-left:8px;overflow-wrap:anywhere;}",
+			".smem-cand-act{display:flex;justify-content:flex-end;}",
+			".smem-cand-confirm{display:flex;align-items:center;gap:8px;flex-wrap:wrap;font-size:12px;border-top:1px dashed var(--dsw-alias-border-l2);padding-top:6px;}",
+			".smem-raw-names{display:flex;gap:6px;flex-wrap:wrap;}",
+			// 自动做梦的二级分组：导航用**下划线**（跟筛选 chip、动作按钮区分开，三种层级三种形状）。
+			".smem-subtabs{display:flex;gap:16px;border-bottom:1px solid var(--dsw-alias-border-l2);margin:2px 0 8px;}",
+			".smem-subtab{background:none;border:0;padding:5px 1px 7px;font-size:12.5px;font-family:inherit;color:var(--dsw-alias-label-secondary);cursor:pointer;position:relative;}",
+			".smem-subtab--on{color:var(--dsw-alias-label-primary);font-weight:600;}",
+			'.smem-subtab--on:after{content:"";position:absolute;left:0;right:0;bottom:-1px;height:2px;border-radius:2px 2px 0 0;background:var(--dsw-alias-label-primary);}',
+			".smem-subtab-n{opacity:.6;margin-left:5px;font-variant-numeric:tabular-nums;}",
+			// 五个注入参数排两列：一行放两个，扫读反而更清楚（吸收方案 A 的做法）。
+			".smem-ad-grid2{display:grid;grid-template-columns:repeat(auto-fit,minmax(330px,1fr));gap:4px 18px;}",
+			".smem-ad-field{display:flex;align-items:center;gap:8px;min-width:0;}",
+			".smem-ad-field .smem-autodream-key{min-width:96px;}",
 			".smem-actions{display:flex;gap:6px;}",
 			".smem-form{border:1px solid var(--dsw-alias-border-l2);border-radius:10px;padding:12px;background:var(--dsw-alias-bg-layer-2);display:flex;flex-direction:column;gap:8px;}",
 			".smem-form-title{font-weight:600;font-size:13px;}",
@@ -1688,6 +2070,10 @@ const StarmapRuntime = (function (require, _react) {
 			".smem-ad-run:hover{border-color:var(--dsw-alias-border-l2);}",
 			'.smem-ad-run[data-on="1"]{border-color:var(--dsw-alias-brand-primary,#4d76e6);}',
 			".smem-ad-md{max-height:360px;overflow:auto;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;padding:10px 12px;background:var(--dsw-alias-bg-layer-2);font-size:12px;white-space:pre-wrap;overflow-wrap:anywhere;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;line-height:1.6;}",
+			// ── 注入参数 / 保留名名单（自动做梦 tab）──
+			".smem-ad-warn{color:var(--dsw-alias-state-warning-primary,#d97706);}",
+			".smem-chip--fixed{opacity:.72;cursor:default;}",
+			".smem-chip-x{border:0;background:transparent;color:inherit;cursor:pointer;font-size:11px;font-family:inherit;padding:0 0 0 5px;}",
 		].join("\n");
 
 		const TYPE_META = {
@@ -1995,16 +2381,296 @@ const StarmapRuntime = (function (require, _react) {
 						}, String(item.description))
 					: null,
 				h("div", { className: "smem-card-foot", key: "foot" },
-					h("div", { className: "smem-actions", key: "acts" },
-						props.deleting
-							? [
-									h("button", { type: "button", className: "smem-btn smem-btn-danger", key: "yes", onClick: function () { props.onConfirmDelete(item.file); } }, "确认删除"),
-									h("button", { type: "button", className: "smem-btn", key: "no", onClick: function () { props.onCancelDelete(); } }, "取消"),
-								]
-							: [
-									h("button", { type: "button", className: "smem-btn", key: "edit", onClick: function () { props.onEdit(item.file); } }, "编辑"),
-									h("button", { type: "button", className: "smem-btn smem-btn-danger-ghost", key: "del", onClick: function () { props.onAskDelete(item.file); } }, "删除"),
-								])),
+					props.archiving
+						? h("div", { className: "smem-ar-confirm", key: "ar" }, [
+								h("div", { key: "what" }, "把「" + item.file + "」收进档案馆：它不再参与检索与星图，文件移进 archive/，随时可以恢复。"),
+								// 「可留空」必须跟输入框贴在一起、并且独立成行 —— 它是这一块最容易
+								// 被误读成「必须填才能按」的地方。
+								h("label", { className: "smem-label", key: "lb" }, "归档理由（可留空）"),
+								h("input", {
+									className: "smem-input", key: "in",
+									value: props.archiveReason || "",
+									placeholder: "例如：结论已被 project_beta 取代",
+									onChange: function (e) { props.onArchiveReason(e.target.value); },
+								}),
+								h("div", { className: "smem-ar-hint", key: "hint" },
+									"写下当时的判断，以后翻到它时就知道这条还值不值得捞回来。"),
+								h("div", { className: "smem-row", key: "btns" }, [
+									h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "ok", disabled: props.busy, onClick: function () { props.onConfirmArchive(item.file); } }, "确认归档"),
+									h("button", { type: "button", className: "smem-btn", key: "no", disabled: props.busy, onClick: props.onCancelArchive }, "取消"),
+								]),
+							])
+						: h("div", { className: "smem-actions", key: "acts" },
+								props.deleting
+									? [
+											h("button", { type: "button", className: "smem-btn smem-btn-danger", key: "yes", onClick: function () { props.onConfirmDelete(item.file); } }, "确认删除"),
+											h("button", { type: "button", className: "smem-btn", key: "no", onClick: function () { props.onCancelDelete(); } }, "取消"),
+										]
+									: [
+											h("button", { type: "button", className: "smem-btn", key: "edit", onClick: function () { props.onEdit(item.file); } }, "编辑"),
+											// 归档排在「编辑」和「删除」之间：比编辑轻、比删除温和，且随时可逆。
+											h("button", { type: "button", className: "smem-btn", key: "arch", title: "收进档案馆：不再参与检索与星图，随时可以恢复", onClick: function () { props.onAskArchive(item.file); } }, "归档"),
+											h("button", { type: "button", className: "smem-btn smem-btn-danger-ghost", key: "del", onClick: function () { props.onAskDelete(item.file); } }, "删除"),
+										])),
+			]);
+		}
+
+		/**
+		 * 归档区的一条。与活动卡片共用骨架（类型章 / 标题 / 标签 / 描述），刻意的差异：
+		 * 虚线边框 + 整体压灰（退役感）、多一行归档留痕、动作是「编辑 / 恢复」。
+		 *
+		 * ⚠️ 灰的只有**内容**（`.smem-card--archived` 那几条只点标题/类型章/标签/正文的字色）。
+		 * 按钮一律保持原样 —— 按钮一灰，用户就以为不能按。
+		 *
+		 * ⚠️ 编辑走**原样文本**：readArchived 拿到的全文直接进 textarea，保存时原样交回
+		 * writeArchived。绝不走活跃记忆那套 buildFrontmatter 重建 —— 重建会吞字段，
+		 * 归档文件里还有 archived_at / archived_reason 这种留痕，更动不得。
+		 * 也不提供删除：归档 = 不删，host 侧也没有那条 remote。
+		 */
+		function ArchivedCard(props) {
+			const item = props.item;
+			const meta = TYPE_META[item.type] || TYPE_META.reference;
+			return h("div", { className: "smem-card smem-card--archived", key: item.file }, [
+				h("div", { className: "smem-card-head", key: "head" }, [
+					h("span", { className: "smem-badge", key: "badge", title: "类型 " + String(item.type) }, meta[0] + " " + meta[1]),
+					h("span", { className: "smem-card-title", key: "title" }, item.file),
+					h("span", { className: "smem-ar-meta", key: "at", title: "归档时间" }, "已归档 " + (item.archivedAt || "（时间未知）")),
+					h("span", { className: "smem-muted", key: "size" }, fmtSize(item.size)),
+				]),
+				(item.tags && item.tags.length)
+					? h("div", { className: "smem-taglist", key: "tags" }, item.tags.map(function (t) {
+							return h("span", { className: "smem-tag", key: t }, "#" + t);
+						}))
+					: null,
+				// 描述留在活动卡片里的同一个位置（标签下面），归档留痕块再往下 ——
+				// 否则「归档理由」像卡片结尾，后面孤零零一行描述没人认得它是什么。
+				item.description
+					? h("div", { className: "smem-narrative", key: "desc" }, String(item.description))
+					: null,
+				h("div", { className: "smem-ar-reason", key: "why" }, "归档理由：" + (item.archivedReason || "（没写）")),
+				props.editing
+					? h("div", { className: "smem-ar-edit", key: "edit" }, [
+							h("div", { className: "smem-ar-hint", key: "note" },
+								"原样文本编辑：下面就是这份文件的全文（含 frontmatter 与归档留痕），保存时原样写回，不会被重新生成。"),
+							props.loading
+								? h("div", { className: "smem-status", key: "loading" }, "读取中…")
+								: h("textarea", {
+										className: "smem-textarea smem-ar-editor", key: "ta",
+										value: props.text || "",
+										spellCheck: false,
+										onChange: function (e) { props.onText(e.target.value); },
+									}),
+							h("div", { className: "smem-row", key: "btns" }, [
+								h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "save", disabled: props.busy || props.loading, onClick: function () { props.onSave(item.file); } }, props.saving ? "保存中…" : "保存"),
+								h("button", { type: "button", className: "smem-btn", key: "cancel", disabled: props.busy, onClick: props.onCancel }, "取消"),
+							]),
+						])
+					: h("div", { className: "smem-card-foot", key: "foot" },
+							h("div", { className: "smem-actions", key: "acts" }, [
+								h("button", {
+									type: "button", className: "smem-btn", key: "edit",
+									disabled: props.busy,
+									onClick: function () { props.onEdit(item.file); },
+								}, "编辑"),
+								h("button", {
+									type: "button", className: "smem-btn smem-btn-primary", key: "restore",
+									disabled: props.busy,
+									onClick: function () { props.onRestore(item.file); },
+								}, props.restoring ? "恢复中…" : "恢复"),
+							])),
+			]);
+		}
+
+		// ── 自动归档三档的**唯一**一套措辞 ──
+		// 文件列表的「归档候选」与自动做梦 tab 的开关都从这里取词：同一件事在两处出现，
+		// 用两套说法等于让用户以为它们是两回事。
+		const AUTO_ARCHIVE_LABEL = { off: "关闭", report: "只出报告", auto: "满足条件自动跑" };
+		const AUTO_ARCHIVE_COST = {
+			off: "关闭：一个文件都不动 —— 候选只列在清单里，等你手点。",
+			report: "只出报告：候选写进整理报告，一个文件都不动。默认档，最保守。",
+			auto: "满足条件自动跑：会真的把候选移进 archive/（只移不删，随时可恢复）；" +
+				"若「改动方式」是只出报告，这一档会自动降级成只出报告。",
+		};
+		const autoArchiveOf = (v) => (v === "off" || v === "auto" ? v : "report");
+
+		/** 头部带上的「我在哪」：三个 tab 的中文名（与 .smem-tabs 上的字面一致）。 */
+		const TAB_LABEL = { files: "文件列表", star: "记忆星图", autodream: "自动做梦" };
+
+		/**
+		 * 工具面板头部的「收起」按钮：抽屉里开的工具要能一键收回去 ——
+		 * 面板不收，列表就还在下面被顶着。
+		 */
+		const toolClose = (props) => (props.onClose
+			? h("button", { type: "button", className: "smem-btn", key: "close", onClick: props.onClose }, "收起")
+			: null);
+
+		/**
+		 * 「体检」结果面板。
+		 *
+		 * 只读：这里**不提供任何「顺手修一下」的按钮** —— 修哪条、怎么修由用户决定，
+		 * 走列表里那条记忆自己的编辑入口。
+		 *
+		 * 硬问题与提示**分开渲染**：`archivedLinks` 是提示（归档不是删除，目标还在档案馆里），
+		 * 跟问题一样染红会让人去「修」一条本来正确的链接 —— 那正是审计里那条分界线。
+		 */
+		function AuditPanel(props) {
+			const r = props.report || {};
+			const rows = (list, render) => (list || []).map(function (x, i) {
+				return h("div", { className: "smem-audit-row", key: String(x.file || "?") + "-" + i }, render(x));
+			});
+			const section = (title, list, render) => ((list && list.length)
+				? h("div", { className: "smem-audit-sec", key: title }, [
+						h("div", { className: "smem-audit-h smem-audit-h--hard", key: "h" }, title + "（" + list.length + "）"),
+						rows(list, render),
+					])
+				: null);
+			const hints = r.archivedLinks || [];
+			return h("div", { className: "smem-tool-panel smem-tool-panel--cap", key: "audit" }, [
+				h("div", { className: "smem-tool-head", key: "head" }, [
+					h("span", { className: "smem-tool-title", key: "t" }, "体检"),
+					h("span", { className: "smem-muted", key: "s" },
+						"扫了 " + String(r.fileCount == null ? "?" : r.fileCount) + " 个记忆 · 索引 " +
+						String(r.indexEntries == null ? "?" : r.indexEntries) + " 条 · 档案馆 " +
+						String(r.archivedCount == null ? "?" : r.archivedCount) + " 条"),
+					h("span", { className: "smem-tool-badge" + (r.problems ? " smem-tool-badge--bad" : ""), key: "p" },
+						r.problems ? ("问题 " + r.problems) : "没有问题"),
+					h("button", { type: "button", className: "smem-btn", key: "again", disabled: props.busy, onClick: props.onRun }, props.busy ? "体检中…" : "重新体检"),
+					toolClose(props),
+				]),
+				r.problems
+					? h("div", { className: "smem-audit-secs", key: "secs" }, [
+							section("索引悬空（索引里有、文件没了）", r.dangling, (x) => x.file),
+							section("漏索引（文件在、索引里没有）", r.unlisted, (x) => x.file),
+							section("type 与前缀对不上", r.typeMismatch, (x) => x.file + " · type=" + x.type + "，文件名前缀=" + x.prefix),
+							section("行尾是 CRLF", r.crlf, (x) => x.file),
+							section("双链断链", r.brokenLinks, (x) => x.file + " → [[" + x.target + "]]"),
+							section("未加引号的「空格+#」", r.hashHazards, (x) => x.file + " · " + x.line),
+							section("没有 frontmatter", r.noFrontmatter, (x) => x.file),
+							section("读不出来", r.unreadable, (x) => x.file),
+						])
+					: h("div", { className: "smem-empty smem-empty--ok", key: "ok" },
+							"没有发现问题 —— 索引、双链、frontmatter 与行尾都对得上。"),
+				hints.length
+					? h("div", { className: "smem-audit-hint", key: "hint" }, [
+							h("div", { className: "smem-audit-h", key: "h" }, "指向已归档（提示，不计入问题）"),
+							h("div", { className: "smem-ar-hint", key: "n" },
+								"归档不是删除：这些链接的目标还在档案馆里躺着，恢复它链接就活了 —— 不用改。"),
+							rows(hints, (x) => x.file + " → [[" + x.target + "]]"),
+						])
+					: null,
+				h("div", { className: "smem-ar-hint", key: "ro" }, "这里只报告、不修改 —— 要改哪条，用那条记忆自己的编辑入口。"),
+			]);
+		}
+
+		/**
+		 * 「归档候选」面板。
+		 *
+		 * 每一条都必须把**为什么建议归档**写出来（`reason` 就是干这个的）——
+		 * 只列文件名等于让人凭感觉点。执行前一律过一道确认，逐条与批量都要过。
+		 */
+		function CandidatePanel(props) {
+			const c = props.data || {};
+			const cands = Array.isArray(c.candidates) ? c.candidates : [];
+			const th = c.thresholds || {};
+			const pickedN = cands.filter((x) => props.picked[x.file]).length;
+			const mode = autoArchiveOf(c.autoArchive);
+			const allPicked = cands.length > 0 && pickedN === cands.length;
+			return h("div", { className: "smem-tool-panel smem-tool-panel--cap", key: "cand" }, [
+				h("div", { className: "smem-tool-head", key: "head" }, [
+					h("span", { className: "smem-tool-title", key: "t" }, "归档候选"),
+					h("span", { className: "smem-muted", key: "s" },
+						"自动归档：" + AUTO_ARCHIVE_LABEL[mode] + " · 阈值：项目 " + String(th.project == null ? "?" : th.project) + " 天 / 参考 " +
+						String(th.reference == null ? "?" : th.reference) + " 天 / 用户 " +
+						String(th.user == null ? "?" : th.user) + " 天"),
+					h("span", { className: "smem-tool-badge", key: "n" }, "候选 " + cands.length),
+					h("button", { type: "button", className: "smem-btn", key: "again", disabled: props.busy, onClick: props.onLoad }, props.busy ? "刷新中…" : "刷新"),
+					toolClose(props),
+				]),
+				cands.length === 0
+					? h("div", { className: "smem-empty", key: "empty" },
+							"按当前阈值没有可归档的 —— 要么闲置天数还没到该类型的阈值，要么台账里还没有访问记录。")
+					: h("div", { className: "smem-cand-list", key: "list" }, [
+							h("div", { className: "smem-cand-note", key: "note" },
+								"候选只按「多久没被注入过」算。归档 = 移进 archive/（不删），随时可以恢复。"),
+							cands.map((x) => h("div", { className: "smem-cand", key: x.file }, [
+								h("label", { className: "smem-cand-main", key: "m" }, [
+									h("input", { type: "checkbox", key: "cb", checked: !!props.picked[x.file], onChange: function () { props.onPick(x.file); } }),
+									h("span", { className: "smem-card-title", key: "f" }, x.file),
+									h("span", { className: "smem-badge", key: "ty" }, TYPE_LABEL[x.type] || x.type || "—"),
+									h("span", { className: "smem-muted", key: "d" }, "闲置 " + String(x.days) + " 天 / 阈值 " + String(x.limit) + " 天"),
+								]),
+								h("div", { className: "smem-cand-reason", key: "why" },
+									"为什么建议归档：" + (x.reason || ("闲置 " + String(x.days) + " 天，超过该类型阈值 " + String(x.limit) + " 天"))),
+								props.confirm === x.file
+									? h("div", { className: "smem-cand-confirm", key: "cf" }, [
+											h("span", { key: "t" }, "确认把「" + x.file + "」移进档案馆？它不再参与检索与星图，随时可以恢复。"),
+											h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "yes", disabled: props.busy, onClick: function () { props.onArchiveOne(x); } }, "确认归档"),
+											h("button", { type: "button", className: "smem-btn", key: "no", disabled: props.busy, onClick: props.onCancelConfirm }, "取消"),
+										])
+									: h("div", { className: "smem-cand-act", key: "act" },
+											h("button", { type: "button", className: "smem-btn", key: "one", disabled: props.busy, onClick: function () { props.onAskOne(x.file); } }, "归档这一条")),
+							])),
+						]),
+				cands.length
+					? h("div", { className: "smem-tool-foot", key: "foot" }, [
+							h("button", { type: "button", className: "smem-btn", key: "all", disabled: props.busy, onClick: props.onPickAll }, allPicked ? "全不选" : "全选"),
+							props.confirm === "__batch__"
+								? [
+										h("span", { className: "smem-ar-hint", key: "t" }, "确认把选中的 " + pickedN + " 条一起移进档案馆？"),
+										h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "yes", disabled: props.busy || !pickedN, onClick: props.onArchivePicked }, "确认归档"),
+										h("button", { type: "button", className: "smem-btn", key: "no", disabled: props.busy, onClick: props.onCancelConfirm }, "取消"),
+									]
+								: h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "go", disabled: props.busy || !pickedN, onClick: props.onAskPicked }, "执行归档（选中 " + pickedN + " 条）"),
+						])
+					: null,
+			]);
+		}
+
+		/**
+		 * 保留名（索引 / 流水）的**原样文本**编辑。
+		 *
+		 * readRaw 拿到的全文直接进 textarea，保存时逐字节交回 writeRaw —— 不解析、不重建。
+		 * 这是那次数据事故（表单重建 frontmatter 把 baseline / node_type 抹掉）的解药，
+		 * 所以这里刻意不复用上面的记忆表单。
+		 */
+		function RawPanel(props) {
+			const names = Array.isArray(props.reserved) ? props.reserved : [];
+			return h("div", { className: "smem-tool-panel", key: "raw" }, [
+				h("div", { className: "smem-tool-head", key: "head" }, [
+					h("span", { className: "smem-tool-title", key: "t" }, "保留名原样编辑"),
+					h("span", { className: "smem-muted", key: "s" },
+						"索引与流水这类文件不走记忆表单：读到的全文直接给你，保存时逐字节写回，" +
+						"不解析、也不重建 frontmatter（普通记忆才走表单）。"),
+				]),
+				names.length
+					? h("div", { className: "smem-raw-names", key: "names" }, names.map((n) =>
+							h("button", {
+								type: "button", key: n, className: "smem-chip",
+								"data-on": props.name === n ? "1" : "0",
+								onClick: function () { props.onOpen(n); },
+							}, n)))
+					: h("div", { className: "smem-ar-hint", key: "nonames" }, "宿主没给出保留名清单。"),
+				props.name
+					? h("div", { className: "smem-ar-edit", key: "edit" }, [
+							h("div", { className: "smem-ar-hint", key: "n" }, "正在编辑 " + props.name + " —— 保存就是覆盖这一份文件。"),
+							props.isNew
+								? h("div", { className: "smem-ar-hint smem-ad-warn", key: "new" },
+										"⚠ 这个文件还不存在 —— 保存会新建它。")
+								: null,
+							props.loading
+								? h("div", { className: "smem-status", key: "l" }, "读取中…")
+								: h("textarea", {
+										className: "smem-textarea smem-ar-editor", key: "ta",
+										value: props.text || "",
+										spellCheck: false,
+										onChange: function (e) { props.onText(e.target.value); },
+									}),
+							h("div", { className: "smem-row", key: "btns" }, [
+								h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "save", disabled: props.busy || props.loading, onClick: function () { props.onSave(props.name); } }, props.saving ? "保存中…" : (props.isNew ? "新建并保存" : "保存")),
+								h("button", { type: "button", className: "smem-btn", key: "close", disabled: props.busy, onClick: props.onClose }, "关闭"),
+							]),
+						])
+					: h("div", { className: "smem-ar-hint", key: "pick" }, "选一个文件名开始编辑。"),
 			]);
 		}
 
@@ -2053,6 +2719,8 @@ const StarmapRuntime = (function (require, _react) {
 		 */
 		function AutodreamPanel(props) {
 			const remote = props.ctx && props.ctx.get ? props.ctx.get("remote.autodream") : null;
+			// 注入设置走 memory 那半边（autodream 只管整理那趟）
+			const memRemote = props.ctx && props.ctx.get ? props.ctx.get("remote.memory") : null;
 			const sCfg = react.useState(null); const cfg = sCfg[0], setCfg = sCfg[1];
 			const sSt = react.useState(null); const st = sSt[0], setSt = sSt[1];
 			const sErr = react.useState(null); const err = sErr[0], setErr = sErr[1];
@@ -2074,6 +2742,14 @@ const StarmapRuntime = (function (require, _react) {
 			const sRbMsg = react.useState(null); const rbMsg = sRbMsg[0], setRbMsg = sRbMsg[1];
 			const sListErr = react.useState(null); const listErr = sListErr[0], setListErr = sListErr[1];
 			const sWasRunning = react.useState(false); const wasRunning = sWasRunning[0], setWasRunning = sWasRunning[1];
+			// ── 记忆注入设置（memory.getSettings / setSettings）──
+			// limits = **当前生效**（模块加载时固化）；pendingLimits = **重启后才生效**。
+			// 两个都必须在界面上，且看得出差别 —— 只显示一个就等于骗人。
+			const sMemSet = react.useState(null); const memSet = sMemSet[0], setMemSet = sMemSet[1];
+			const sLimitsDraft = react.useState(null); const limitsDraft = sLimitsDraft[0], setLimitsDraft = sLimitsDraft[1];
+			const sSaveBusy = react.useState(false); const saveBusy = sSaveBusy[0], setSaveBusy = sSaveBusy[1];
+			const sAutoSaving = react.useState(false); const autoSaving = sAutoSaving[0], setAutoSaving = sAutoSaving[1];
+			const sReservedNew = react.useState(""); const reservedNew = sReservedNew[0], setReservedNew = sReservedNew[1];
 
 			// 派生量放在 effect 之前：下面几个 effect 的依赖数组要在渲染期就能取到值。
 			const c = cfg || {};
@@ -2081,6 +2757,13 @@ const StarmapRuntime = (function (require, _react) {
 			const last = (st && st.lastResult) || null;
 			const route = (st && st.route) || null;
 			const rollbackScope = c.rollbackScope === "all" ? "all" : "files";
+			// 保留名名单：reserved = 生效清单（含内置两个），reservedExtra = 用户自己声明的那部分。
+			// 内置的两个 = 生效清单里不属于 reservedExtra 的那些 —— 不写死名字，host 那边改了这边跟着变。
+			const extraReserved = Array.isArray(memSet && memSet.reservedExtra) ? memSet.reservedExtra : [];
+			const extraLower = extraReserved.map(function (x) { return String(x).toLowerCase(); });
+			const fixedReserved = ((memSet && memSet.reserved) || []).filter(function (n) {
+				return extraLower.indexOf(String(n).toLowerCase()) < 0;
+			});
 
 			react.useEffect(function () {
 				if (!remote) { setErr("remote.autodream 不可用 —— 插件的 宿主侧可能没加载成功，看 DSH 启动日志"); return undefined; }
@@ -2095,6 +2778,7 @@ const StarmapRuntime = (function (require, _react) {
 				pull();
 				refreshLists();
 				loadModels();
+				loadMemSettings();
 				const id = setInterval(pull, 2000);
 				return function () { alive = false; clearInterval(id); };
 			}, [remote]);
@@ -2137,6 +2821,128 @@ const StarmapRuntime = (function (require, _react) {
 				}, function (m) { setErr(m); });
 			}
 
+			// ── 注入设置：5 项上限 + 保留名名单 ─────────────────────────────
+			// 边界与 host 的 LIMIT_SPECS 一一对应（那边是权威，这里只是提前拦明显笔误）。
+			const LIMIT_FIELDS = [
+				{ key: "maxResults", label: "一次注入条数", lo: 1, hi: 30, unit: "条" },
+				{ key: "maxChars", label: "单条字符上限", lo: 200, hi: 20000, unit: "字符" },
+				{ key: "maxBaseline", label: "baseline 名额", lo: 1, hi: 50, unit: "条" },
+				{ key: "maxSessionBytes", label: "单会话字节预算", lo: 4096, hi: 524288, unit: "字节" },
+				{ key: "staleDays", label: "新鲜度门槛", lo: 0, hi: 365, unit: "天" },
+			];
+
+			/** 把一份 limits 对象摊成输入框用的字符串草稿（输入期间允许非法，保存时再校验）。 */
+			function limitsDraftOf(src) {
+				const out = {};
+				for (const f of LIMIT_FIELDS) out[f.key] = src && src[f.key] != null ? String(src[f.key]) : "";
+				return out;
+			}
+
+			function loadMemSettings(onOk) {
+				if (!memRemote || typeof memRemote.getSettings !== "function") return;
+				Promise.resolve(memRemote.getSettings()).then(function (res) {
+					const d = unwrap(res) || {};
+					setMemSet(d);
+					setLimitsDraft(limitsDraftOf(d.pendingLimits || d.limits || {}));
+					if (onOk) onOk(d);
+				}, function (e) { setErr(detail(e)); });
+			}
+
+			/**
+			 * 自动归档三档：保存后**回读校验**。
+			 *
+			 * `setConfig` 对非法值沿用的是「忽略、保留原值」的语义（没有 `{ok:false}` 通道），
+			 * 所以不能只看它返回的 config —— 必须再 `getConfig()` 一次，确认那个值真的落在
+			 * 配置里。没变就报错：**不能让用户点了保存以为成了、实际什么都没发生**。
+			 */
+			function saveAutoArchive(v) {
+				setErr(null); setNotice(""); setAutoSaving(true);
+				callRemote("setConfig", [{ autoArchive: v }], function (d) {
+					if (d && d.config && d.config.autoArchive === v) {
+						setCfg(d.config);
+						setAutoSaving(false);
+						setNotice("自动归档已设为「" + AUTO_ARCHIVE_LABEL[v] + "」");
+						return;
+					}
+					// 返回的 config 里没看到新值 → 回读一次再定论
+					callRemote("getConfig", [], function (d2) {
+						const next = d2 && d2.config ? d2.config : null;
+						setAutoSaving(false);
+						if (next) setCfg(next);
+						const got = next ? autoArchiveOf(next.autoArchive) : null;
+						if (got === v) { setNotice("自动归档已设为「" + AUTO_ARCHIVE_LABEL[v] + "」"); return; }
+						setErr("保存没生效：配置里仍是「" + (got ? AUTO_ARCHIVE_LABEL[got] : "读不出来") +
+							"」。setConfig 对非法值会忽略并保留原值 —— 请重试，或看 DSH 启动日志。");
+					}, function (m) { setAutoSaving(false); setErr("保存后回读失败：" + m); });
+				}, function (m) { setAutoSaving(false); setErr(m); });
+			}
+
+			/** 保存 5 项上限。越界/非整数**本地先拦**（host 也是直接拒绝），别让它白跑一趟。 */
+			function saveLimits() {
+				if (!memRemote || typeof memRemote.setSettings !== "function") { setErr("宿主侧还没有 setSettings 接口（插件版本较旧）"); return; }
+				const draft = limitsDraft || {};
+				const limits = {};
+				const bad = [];
+				for (const f of LIMIT_FIELDS) {
+					const raw = String(draft[f.key] == null ? "" : draft[f.key]).trim();
+					const n = Number(raw);
+					if (raw === "" || !Number.isFinite(n) || !Number.isInteger(n)) { bad.push(f.label + "要整数"); continue; }
+					if (n < f.lo || n > f.hi) { bad.push(f.label + " 要在 " + f.lo + "–" + f.hi + " 之间"); continue; }
+					limits[f.key] = n;
+				}
+				if (bad.length) { setErr("没保存 —— " + bad.join("；")); return; }
+				setSaveBusy(true); setErr(null); setNotice("");
+				Promise.resolve(memRemote.setSettings({ limits: limits })).then(function (out) {
+					setSaveBusy(false);
+					// setSettings 是 {ok:true, settings, restartRequired} 形状：不要过 unwrap
+					// （unwrap 只认 {ok, value}，这里会把 settings 吃掉）。
+					if (out && out.ok === false) { setErr(out.error || "保存被拒绝"); return; }
+					if (out && out.settings) { setMemSet(out.settings); setLimitsDraft(limitsDraftOf(out.settings.pendingLimits)); }
+					else loadMemSettings();
+					setNotice("已保存 —— 需重启 DSH 才生效");
+				}, function (e) { setSaveBusy(false); setErr(detail(e)); });
+			}
+
+			/**
+			 * 保存保留名名单（用户声明的那部分）。
+			 *
+			 * 两个内置名（memory.md / session-log.md）**不在**这份名单里，也不在界面上给删除入口 ——
+			 * 那是生效清单里固定的两个，删不掉。这里管的只是用户自己加的那些。
+			 */
+			function saveReserved(list) {
+				if (!memRemote || typeof memRemote.setSettings !== "function") { setErr("宿主侧还没有 setSettings 接口（插件版本较旧）"); return; }
+				setSaveBusy(true); setErr(null); setNotice("");
+				Promise.resolve(memRemote.setSettings({ reserved: list })).then(function (out) {
+					setSaveBusy(false);
+					if (out && out.ok === false) { setErr(out.error || "名单被拒绝"); return; }
+					if (out && out.settings) setMemSet(out.settings);
+					else loadMemSettings();
+					setNotice("保留名名单已保存 —— 需重启 DSH 才生效");
+				}, function (e) { setSaveBusy(false); setErr(detail(e)); });
+			}
+
+			function addReserved() {
+				const name = String(reservedNew || "").trim();
+				const extra = Array.isArray(memSet && memSet.reservedExtra) ? memSet.reservedExtra : [];
+				if (!name) { setErr("先写一个文件名，例如 project_notes.md"); return; }
+				// 与 host 的校验同一套：单个 .md 文件名、不许带路径
+				if (!name.endsWith(".md") || name.includes("/") || name.includes("\\") || name.startsWith("..")) {
+					setErr("保留名要是一个 .md 文件名（不能带路径）：" + name);
+					return;
+				}
+				if (extra.some(function (x) { return String(x).toLowerCase() === name.toLowerCase(); })) {
+					setErr("名单里已经有 " + name + " 了");
+					return;
+				}
+				setReservedNew("");
+				saveReserved(extra.concat([name]));
+			}
+
+			function removeReserved(name) {
+				const extra = Array.isArray(memSet && memSet.reservedExtra) ? memSet.reservedExtra : [];
+				saveReserved(extra.filter(function (x) { return x !== name; }));
+			}
+
 			/** 报告 / 回滚点 / 整理记录三份列表一起刷。 */
 			function refreshLists() {
 				callRemote("listReports", [], function (d) {
@@ -2226,7 +3032,24 @@ const StarmapRuntime = (function (require, _react) {
 				return encodeRoute(r.provider, r.model) === modelValue;
 			});
 
+			// 二级分组：**运行 / 设置 / 记录**。
+			// 这三类东西原来混在一条滚动里（实测约 1760px）：跑一次要用的、要调的、回头看历史的
+			// 全叠在一起，找什么东西都得滚。分段之后每段都落在一屏内（标尺：可视高度约 1000px）。
+			// ⚠️ 分段状态放在 Section 里（props.seg），因为头部带的「待重启生效」徽标要能一步切到「设置」。
+			const segOf = (props.seg === "settings" || props.seg === "records") ? props.seg : "run";
+			const subtab = (name, label, note) => h("button", {
+				type: "button", key: name, className: "smem-subtab" + (segOf === name ? " smem-subtab--on" : ""),
+				"aria-current": segOf === name ? "true" : "false",
+				onClick: function () { if (props.onSeg) props.onSeg(name); },
+			}, [label, note ? h("span", { className: "smem-subtab-n", key: "n" }, note) : null]);
+
 			return h("div", { className: "smem-autodream" }, [
+				h("div", { className: "smem-subtabs", key: "segs" }, [
+					subtab("run", "运行"),
+					subtab("settings", "设置"),
+					subtab("records", "记录", String(snaps.length + runs.length + reports.length)),
+				]),
+				segOf === "run" ? h("div", { className: "smem-seg", key: "seg-run" }, [
 				h("div", { className: "smem-autodream-sec", key: "top" }, [
 					h("div", { className: "smem-autodream-row", key: "r" }, [
 						h("button", {
@@ -2322,30 +3145,6 @@ const StarmapRuntime = (function (require, _react) {
 						? h("div", { className: "smem-autodream-note", key: "mnote" }, String(models.note))
 						: null,
 				]),
-				h("details", { className: "smem-autodream-adv", key: "adv", open: true }, [
-					h("summary", { key: "s" }, "高级设置"),
-					h("div", { key: "d" }, [
-						c.trigger === "auto" ? h("div", { className: "smem-autodream-row", key: "gate" }, [
-							h("span", { className: "smem-autodream-key", key: "k" }, "自动触发"),
-							h("span", { className: "smem-status", key: "a" }, "距上次 ≥"),
-							h("input", { className: "smem-num", key: "h", type: "number", min: "1", max: "720", value: c.minHours, onChange: function (e) { patch({ minHours: Number(e.target.value) }); } }),
-							h("span", { className: "smem-status", key: "b" }, "小时，且期间 ≥"),
-							h("input", { className: "smem-num", key: "m", type: "number", min: "1", max: "200", value: c.minSessions, onChange: function (e) { patch({ minSessions: Number(e.target.value) }); } }),
-							h("span", { className: "smem-status", key: "c" }, "个会话有更新"),
-						]) : null,
-						h("div", { className: "smem-autodream-row", key: "steps" }, [
-							h("span", { className: "smem-autodream-key", key: "k" }, "最多轮数"),
-							h("input", { className: "smem-num", key: "v", type: "number", min: "1", max: "80", value: c.maxSteps, onChange: function (e) { patch({ maxSteps: Number(e.target.value) }); } }),
-							h("span", { className: "smem-status", key: "s" }, "一轮 = 一次模型调用 + 它要的工具调用"),
-						]),
-						h("div", { className: "smem-autodream-row", key: "keep" }, [
-							h("span", { className: "smem-autodream-key", key: "k" }, "保留快照"),
-							h("input", { className: "smem-num", key: "v", type: "number", min: "1", max: "50", value: c.maxSnapshotKeep, onChange: function (e) { patch({ maxSnapshotKeep: Number(e.target.value) }); } }),
-							h("span", { className: "smem-status", key: "s" }, "份"),
-						]),
-						h("div", { className: "smem-status", key: "paths" }, "配置与状态：" + ((st && st.paths && st.paths.configPath) || "—")),
-					]),
-				]),
 				h("div", { className: "smem-autodream-sec", key: "run" }, [
 					h("div", { className: "smem-autodream-row", key: "r" }, [
 						h("button", {
@@ -2373,8 +3172,128 @@ const StarmapRuntime = (function (require, _react) {
 								(last.report ? " · 报告 " + last.report : ""))
 						: null,
 				]),
+				]) : null,
+				segOf === "settings" ? h("div", { className: "smem-seg", key: "seg-set" }, [
+				h("div", { className: "smem-autodream-sec", key: "autoarchive" }, [
+					h("div", { className: "smem-autodream-row", key: "r" }, [
+						h("span", { className: "smem-autodream-key", key: "k" }, "自动归档"),
+						h(Seg, {
+							key: "v", value: autoArchiveOf(c.autoArchive),
+							options: [
+								{ value: "off", label: AUTO_ARCHIVE_LABEL.off },
+								{ value: "report", label: AUTO_ARCHIVE_LABEL.report },
+								{ value: "auto", label: AUTO_ARCHIVE_LABEL.auto },
+							],
+							// 点一档就存一档，但**存完要回读**：setConfig 对非法值是静默忽略，
+							// 只信返回值不够（见 saveAutoArchive 的注释）。
+							onChange: function (v) { if (v !== autoArchiveOf(c.autoArchive)) saveAutoArchive(v); },
+						}),
+						autoSaving ? h("span", { className: "smem-status", key: "s" }, "保存中…") : null,
+					]),
+					h("div", { className: "smem-autodream-note", key: "cost" }, AUTO_ARCHIVE_COST[autoArchiveOf(c.autoArchive)]),
+					autoArchiveOf(c.autoArchive) === "auto" && !c.apply
+						? h("div", { className: "smem-autodream-note smem-ad-warn", key: "deg" },
+								"注意：现在「改动方式」是只出报告 —— 这一档会自动降级成只出报告，不会动文件。")
+						: null,
+				]),
+				h("div", { className: "smem-autodream-sec", key: "limits" }, [
+					h("div", { className: "smem-autodream-row", key: "h" }, [
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "记忆注入参数"),
+						memSet && memSet.restartRequired
+							? h("span", { className: "smem-ad-badge smem-ad-badge--warn", key: "w" }, "有改动待生效")
+							: null,
+					]),
+					memSet && memSet.restartRequired
+						? h("div", { className: "smem-autodream-note smem-ad-warn", key: "rw" },
+								"⚠ 这些值在 DSH 启动时就固化了 —— 要重启 DSH 才生效。下面每行都写清「当前 → 重启后」。")
+						: h("div", { className: "smem-autodream-note", key: "rn" },
+								"这些值在 DSH 启动时固化：保存后要重启 DSH 才生效 —— 所以每行都会标出「当前生效」与「重启后」。"),
+					// 五个参数排两列（一行两个）：同样的信息，行数少一半，扫读反而更清楚。
+					h("div", { className: "smem-ad-grid2", key: "grid" }, LIMIT_FIELDS.map(function (f) {
+						const cur = memSet && memSet.limits ? memSet.limits[f.key] : null;
+						const pend = memSet && memSet.pendingLimits ? memSet.pendingLimits[f.key] : null;
+						const diff = cur != null && pend != null && cur !== pend;
+						return h("div", { className: "smem-ad-field", key: f.key }, [
+							h("span", { className: "smem-autodream-key", key: "k", title: f.unit + " · 范围 " + f.lo + "–" + f.hi }, f.label),
+							h("input", {
+								className: "smem-num", key: "v", type: "number",
+								min: String(f.lo), max: String(f.hi),
+								title: "范围 " + f.lo + "–" + f.hi + " " + f.unit,
+								value: limitsDraft && limitsDraft[f.key] != null ? limitsDraft[f.key] : "",
+								onChange: function (e) {
+									const nx = Object.assign({}, limitsDraft);
+									nx[f.key] = e.target.value;
+									setLimitsDraft(nx);
+								},
+							}),
+							diff
+								? h("span", { className: "smem-ad-badge smem-ad-badge--warn", key: "d" }, "当前 " + String(cur) + " → 重启后 " + String(pend))
+								: h("span", { className: "smem-status", key: "d" }, "范围 " + f.lo + "–" + f.hi + (cur == null ? "" : (" · 当前生效 " + String(cur)))),
+						]);
+					})),
+					h("div", { className: "smem-autodream-row", key: "save" }, [
+						h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "s", disabled: saveBusy, onClick: saveLimits }, saveBusy ? "保存中…" : "保存注入参数"),
+						h("span", { className: "smem-status", key: "n" }, "保存后需重启 DSH 才生效"),
+					]),
+				]),
+				h("div", { className: "smem-autodream-sec", key: "reserved" }, [
+					h("div", { className: "smem-autodream-row", key: "h" }, [
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "保留名保护名单"),
+						h("span", { className: "smem-status", key: "c" }, "名单里的文件不参与注入"),
+					]),
+					h("div", { className: "smem-autodream-note", key: "n" },
+						"内置的两个固定不可删；下面可以再加自己的（只写文件名，不要带路径）。改完需重启 DSH 才生效。"),
+					h("div", { className: "smem-raw-names", key: "fixed" }, fixedReserved.map(function (n) {
+						return h("span", { className: "smem-chip smem-chip--fixed", key: n, title: "内置固定，不可删除" }, n + " · 固定");
+					})),
+					h("div", { className: "smem-raw-names", key: "extra" },
+						extraReserved.length
+							? extraReserved.map(function (n) {
+									return h("span", { className: "smem-chip", key: n, "data-on": "1" }, [
+										n,
+										h("button", { type: "button", className: "smem-chip-x", key: "x", title: "从名单里移除 " + n, onClick: function () { removeReserved(n); } }, "✕"),
+									]);
+								})
+							: h("span", { className: "smem-status", key: "none" }, "（还没有自己加的保留名）")),
+					h("div", { className: "smem-autodream-row", key: "add" }, [
+						h("input", {
+							className: "smem-input", key: "i",
+							style: { flex: "1", minWidth: "150px" },
+							value: reservedNew,
+							placeholder: "例如 project_notes.md（要 .md 文件名）",
+							onChange: function (e) { setReservedNew(e.target.value); },
+						}),
+						h("button", { type: "button", className: "smem-btn", key: "a", disabled: saveBusy, onClick: addReserved }, "加入名单"),
+					]),
+				]),
+				h("details", { className: "smem-autodream-adv", key: "adv", open: true }, [
+					h("summary", { key: "s" }, "高级设置"),
+					h("div", { key: "d" }, [
+						c.trigger === "auto" ? h("div", { className: "smem-autodream-row", key: "gate" }, [
+							h("span", { className: "smem-autodream-key", key: "k" }, "自动触发"),
+							h("span", { className: "smem-status", key: "a" }, "距上次 ≥"),
+							h("input", { className: "smem-num", key: "h", type: "number", min: "1", max: "720", value: c.minHours, onChange: function (e) { patch({ minHours: Number(e.target.value) }); } }),
+							h("span", { className: "smem-status", key: "b" }, "小时，且期间 ≥"),
+							h("input", { className: "smem-num", key: "m", type: "number", min: "1", max: "200", value: c.minSessions, onChange: function (e) { patch({ minSessions: Number(e.target.value) }); } }),
+							h("span", { className: "smem-status", key: "c" }, "个会话有更新"),
+						]) : null,
+						h("div", { className: "smem-autodream-row", key: "steps" }, [
+							h("span", { className: "smem-autodream-key", key: "k" }, "最多轮数"),
+							h("input", { className: "smem-num", key: "v", type: "number", min: "1", max: "80", value: c.maxSteps, onChange: function (e) { patch({ maxSteps: Number(e.target.value) }); } }),
+							h("span", { className: "smem-status", key: "s" }, "一轮 = 一次模型调用 + 它要的工具调用"),
+						]),
+						h("div", { className: "smem-autodream-row", key: "keep" }, [
+							h("span", { className: "smem-autodream-key", key: "k" }, "保留快照"),
+							h("input", { className: "smem-num", key: "v", type: "number", min: "1", max: "50", value: c.maxSnapshotKeep, onChange: function (e) { patch({ maxSnapshotKeep: Number(e.target.value) }); } }),
+							h("span", { className: "smem-status", key: "s" }, "份"),
+						]),
+						h("div", { className: "smem-status", key: "paths" }, "配置与状态：" + ((st && st.paths && st.paths.configPath) || "—")),
+					]),
+				]),
+				]) : null,
 				// ── 回滚点（新）──────────────────────────────────────────────
 				// 只改这一个文件、只用既有 h() 写法；数据全走 remote.autodream。
+				segOf === "records" ? h("div", { className: "smem-seg", key: "seg-rec" }, [
 				h("div", { className: "smem-autodream-sec", key: "snap" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
 						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "回滚点"),
@@ -2485,6 +3404,7 @@ const StarmapRuntime = (function (require, _react) {
 							})),
 					open && body ? h("pre", { className: "smem-report-pre", key: "body" }, body) : null,
 				]),
+				]) : null,
 				listErr && !err ? h("div", { className: "smem-err", key: "lerr" }, "⚠ " + listErr) : null,
 				err ? h("div", { className: "smem-err", key: "err" }, "⚠ " + err) : null,
 				notice && !err ? h("div", { className: "smem-ok", key: "ok" }, "✓ " + notice) : null,
@@ -2545,6 +3465,65 @@ const StarmapRuntime = (function (require, _react) {
 			const dirOk = sOk[0], setDirOk = sOk[1];
 			const sTab = react.useState("files");
 			const tab = sTab[0], setTab = sTab[1];
+			// ── 档案馆（v0.9.0）──
+			// 归档不是「另一个视图」，而是和类型 / 标签并列的**筛选维度**：
+			// 状态（全部 / 活动中 / 已归档）。三组筛选组内 OR、组间 AND，再与搜索框 AND。
+			const sStatus = react.useState("all");
+			const statusFilter = sStatus[0], setStatusFilter = sStatus[1];
+			const sArchive = react.useState([]);
+			const archiveItems = sArchive[0], setArchiveItems = sArchive[1];
+			const sArchiving = react.useState(null);
+			const archiving = sArchiving[0], setArchiving = sArchiving[1];
+			const sArchiveReason = react.useState("");
+			const archiveReason = sArchiveReason[0], setArchiveReason = sArchiveReason[1];
+			const sRestoring = react.useState(null);
+			const restoring = sRestoring[0], setRestoring = sRestoring[1];
+			// 归档文件的「原样文本」编辑器：正在编辑谁、编辑框里是什么、读/存进行中
+			const sArchEdit = react.useState(null);
+			const archEdit = sArchEdit[0], setArchEdit = sArchEdit[1];
+			const sArchText = react.useState("");
+			const archText = sArchText[0], setArchText = sArchText[1];
+			const sArchLoad = react.useState(false);
+			const archLoad = sArchLoad[0], setArchLoad = sArchLoad[1];
+			const sArchSaving = react.useState(false);
+			const archSaving = sArchSaving[0], setArchSaving = sArchSaving[1];
+			// ── 工具面板（体检 / 归档候选 / 保留名原样编辑）──
+			// 三个入口收进「工具 ▾」抽屉：关着时零占位，点开才占版面。
+			// 面板一次只开一个（tool 状态），列表始终留在下面。
+			// ⚠️ 抽屉本身不负责「可发现」——那是头部带上常显徽标的活。所以 audit / settings
+			// 在面板挂载时就各拉一次（都只读）：体检有几个问题、有没有待重启项，不打开也看得见。
+			const sDrawer = react.useState(false);
+			const drawer = sDrawer[0], setDrawer = sDrawer[1];
+			// 自动做梦的二级分段状态放在这里（不放面板内部）：头部带的「待重启生效」徽标
+			// 点一下就切到自动做梦·设置那一段，需要跨组件指路。
+			const sAdSeg = react.useState("run");
+			const adSeg = sAdSeg[0], setAdSeg = sAdSeg[1];
+			const sTool = react.useState(null);
+			const tool = sTool[0], setTool = sTool[1];
+			const sAudit = react.useState(null);
+			const audit = sAudit[0], setAudit = sAudit[1];
+			const sAuditBusy = react.useState(false);
+			const auditBusy = sAuditBusy[0], setAuditBusy = sAuditBusy[1];
+			const sCand = react.useState(null);
+			const cand = sCand[0], setCand = sCand[1];
+			const sCandBusy = react.useState(false);
+			const candBusy = sCandBusy[0], setCandBusy = sCandBusy[1];
+			const sPicked = react.useState({});
+			const picked = sPicked[0], setPicked = sPicked[1];
+			const sCandConfirm = react.useState(null);
+			const candConfirm = sCandConfirm[0], setCandConfirm = sCandConfirm[1];
+			const sSettings = react.useState(null);
+			const settings = sSettings[0], setSettings = sSettings[1];
+			const sRawName = react.useState(null);
+			const rawName = sRawName[0], setRawName = sRawName[1];
+			const sRawText = react.useState("");
+			const rawText = sRawText[0], setRawText = sRawText[1];
+			const sRawIsNew = react.useState(false);
+			const rawIsNew = sRawIsNew[0], setRawIsNew = sRawIsNew[1];
+			const sRawBusy = react.useState(false);
+			const rawBusy = sRawBusy[0], setRawBusy = sRawBusy[1];
+			const sRawLoading = react.useState(false);
+			const rawLoading = sRawLoading[0], setRawLoading = sRawLoading[1];
 			const renderSlot = props.renderSlot;
 
 			function load() {
@@ -2562,9 +3541,45 @@ const StarmapRuntime = (function (require, _react) {
 					})
 					.catch(function (e) { setError(String((e && e.message) || e)); setDirOk(false); })
 					.then(function () { setLoading(false); });
+				// 归档区与活动列表分开拉：归档区读不到不该拖垮活动列表。
+				// 旧版宿主没有 listArchived → 界面退化成一个空档案馆，不报错。
+				if (typeof remote.listArchived !== "function") return;
+				Promise.resolve()
+					.then(function () { return remote.listArchived(); })
+					.then(function (res) {
+						const d = unwrap(res);
+						setArchiveItems(d && Array.isArray(d.files) ? d.files : []);
+					})
+					.catch(function () { setArchiveItems([]); });
 			}
 
-			react.useEffect(function () { load(); }, []);
+			react.useEffect(function () {
+				load();
+				// 头部带的两个徽标要有数据才立得住：体检（只读扫描）与待重启项。
+				runAudit();
+				loadSettings();
+			}, []);
+
+			/**
+			 * 抽屉「点外部 / Esc 关闭」。
+			 *
+			 * ⚠️ 监听**只在展开时挂**（依赖 [drawer]）：关着时一个 document 监听都没有 ——
+			 * 「点外部关闭」绝不能变成「点哪儿都没反应」。cleanup 里成对摘掉，不留悬挂监听。
+			 * 用 click 而不是 pointerdown：宿主的弹窗里 pointerdown 可能被别的控件的拖拽吃掉。
+			 * 点抽屉里的条目也一样会关（条目自己的 onClick 先把它设成 false，这里再设一次无害）。
+			 */
+			react.useEffect(function () {
+				if (!drawer) return undefined;
+				if (typeof document === "undefined" || !document.addEventListener) return undefined;
+				function onOutside() { setDrawer(false); }
+				function onKey(e) { if (e && (e.key === "Escape" || e.keyCode === 27)) setDrawer(false); }
+				document.addEventListener("click", onOutside);
+				document.addEventListener("keydown", onKey);
+				return function () {
+					document.removeEventListener("click", onOutside);
+					document.removeEventListener("keydown", onKey);
+				};
+			}, [drawer]);
 
 			function closeForm() {
 				setFormOpen(false); setEditingFile(null); setFormName(""); setFormDesc(""); setFormBody(""); setFormType("feedback");
@@ -2660,13 +3675,251 @@ const StarmapRuntime = (function (require, _react) {
 					.then(function () { setBusy(false); });
 			}
 
+			/**
+			 * 归档：把一条记忆移进档案馆。
+			 *
+			 * 与删除的区别要在界面上说清 —— 归档是「静默失效且可回退」，删除是真的没了。
+			 * 所以这一问问的是「为什么」（留痕给以后的自己看），不是「确定吗」。
+			 */
+			function confirmArchive(file) {
+				if (typeof remote.archive !== "function") {
+					setError("宿主侧还没有 archive 接口（插件版本较旧）");
+					return;
+				}
+				setBusy(true); setError(null); setNotice("");
+				remote.archive(file, archiveReason.trim())
+					.then(function (r) {
+						if (r && r.ok === false) { setError(r.error || "归档被拒绝"); return; }
+						setArchiving(null);
+						setArchiveReason("");
+						setNotice("已归档 " + file + " —— 它现在在「已归档」视图里，随时可以恢复");
+						load();
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setBusy(false); });
+			}
+
+			/** 从档案馆捞回来：文件移回记忆目录，归档留痕被抹掉。 */
+			function restoreFile(file) {
+				if (typeof remote.restore !== "function") {
+					setError("宿主侧还没有 restore 接口（插件版本较旧）");
+					return;
+				}
+				setBusy(true); setError(null); setNotice("");
+				setRestoring(file);
+				remote.restore(file)
+					.then(function (r) {
+						if (r && r.ok === false) { setError(r.error || "恢复被拒绝"); return; }
+						setNotice("已恢复 " + file + " —— 它回到了活动记忆里");
+						load();
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setBusy(false); setRestoring(null); });
+			}
+
+			/**
+			 * 打开归档文件的**原样文本**编辑器。
+			 *
+			 * 读回来的 content 一字不改地放进编辑框；保存时也一字不改地交回去。
+			 * 这是刻意的：活跃记忆那套表单会用 buildFrontmatter 重建 frontmatter，
+			 * 它会吞掉自己不认识的字段（曾经的数据事故）；归档文件里还多两行
+			 * archived_at / archived_reason，重建就是丢留痕。
+			 */
+			function openArchEdit(file) {
+				if (typeof remote.readArchived !== "function") {
+					setError("宿主侧还没有 readArchived 接口（插件版本较旧）");
+					return;
+				}
+				setError(null); setNotice("");
+				setArchEdit(file);
+				setArchText("");
+				setArchLoad(true);
+				remote.readArchived(file)
+					.then(function (r) {
+						const d = unwrap(r);
+						setArchText(d && typeof d.content === "string" ? d.content : "");
+						setArchLoad(false);
+					})
+					.catch(function (e) {
+						setError(String((e && e.message) || e));
+						setArchLoad(false);
+						setArchEdit(null);
+					});
+			}
+
+			function saveArchEdit(file) {
+				if (typeof remote.writeArchived !== "function") {
+					setError("宿主侧还没有 writeArchived 接口（插件版本较旧）");
+					return;
+				}
+				setArchSaving(true); setError(null); setNotice("");
+				// 原样交回：不 trim、不补 frontmatter、不做任何「智能」处理。
+				remote.writeArchived(file, archText)
+					.then(function (r) {
+						if (r && r.ok === false) { setError(r.error || "保存被拒绝"); return; }
+						setArchEdit(null);
+						setNotice("已保存 " + file);
+						load();
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setArchSaving(false); });
+			}
+
+			function cancelArchEdit() { setArchEdit(null); setArchText(""); }
+
+			// ── 工具面板的三个数据通道 ──────────────────────────────────────
+
+			function runAudit() {
+				if (typeof remote.audit !== "function") { setError("宿主侧还没有 audit 接口（插件版本较旧）"); return; }
+				setAuditBusy(true); setError(null);
+				remote.audit()
+					.then(function (r) { setAudit(unwrap(r) || null); })
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setAuditBusy(false); });
+			}
+
+			function loadCandidates() {
+				if (typeof remote.archiveCandidates !== "function") { setError("宿主侧还没有 archiveCandidates 接口（插件版本较旧）"); return; }
+				setCandBusy(true); setError(null);
+				remote.archiveCandidates()
+					.then(function (r) {
+						const d = unwrap(r) || {};
+						setCand(d);
+						// 候选没了就把选中项一起清掉，免得留下指向不存在文件的对勾
+						const keep = {};
+						(d.candidates || []).forEach(function (x) { if (picked[x.file]) keep[x.file] = true; });
+						setPicked(keep);
+						setCandConfirm(null);
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setCandBusy(false); });
+			}
+
+			function loadSettings() {
+				if (typeof remote.getSettings !== "function") { setError("宿主侧还没有 getSettings 接口（插件版本较旧）"); return; }
+				remote.getSettings()
+					.then(function (r) { const d = unwrap(r) || {}; setSettings(d); })
+					.catch(function (e) { setError(String((e && e.message) || e)); });
+			}
+
+			/**
+			 * 打开 / 收起一个工具面板。数据只在第一次打开时拉；已经拉过就复用
+			 * （「刷新」「重新体检」是显式动作，别替用户反复扫目录）。
+			 */
+			function toggleTool(name) {
+				const next = tool === name ? null : name;
+				setTool(next);
+				setError(null);
+				if (next === "audit" && !audit) runAudit();
+				if (next === "candidates" && !cand) loadCandidates();
+				if (next === "raw" && !settings) loadSettings();
+			}
+
+			/** 打开某个工具（头部带的徽标点进来时用：不切换、直接开）。 */
+			function openTool(name) {
+				setTool(name);
+				setError(null);
+				if (name === "audit" && !audit) runAudit();
+				if (name === "candidates" && !cand) loadCandidates();
+				if (name === "raw" && !settings) loadSettings();
+			}
+
+			/**
+			 * 执行归档（逐条 / 批量都走这里）。reason 用候选算出来的那个
+			 * —— 归档留痕要写清「为什么」，不能把模型/界面的判断丢掉。
+			 */
+			function archiveCandidates(list) {
+				if (!list.length) return;
+				if (typeof remote.archive !== "function") { setError("宿主侧还没有 archive 接口（插件版本较旧）"); return; }
+				setBusy(true); setError(null); setNotice("");
+				const done = [];
+				const failed = [];
+				const step = function (i) {
+					if (i >= list.length) {
+						setBusy(false);
+						setCandConfirm(null);
+						setPicked({});
+						setNotice(failed.length
+							? ("已归档 " + done.length + " 条，" + failed.length + " 条没成功：" + failed.join("、"))
+							: ("已归档 " + done.length + " 条 —— 它们现在在档案馆里，随时可以恢复"));
+						load();
+						loadCandidates();
+						return;
+					}
+					const c = list[i];
+					Promise.resolve()
+						.then(function () { return remote.archive(c.file, c.reason); })
+						.then(function (r) {
+							if (r && r.ok === false) failed.push(c.file); else done.push(c.file);
+						}, function () { failed.push(c.file); })
+						.then(function () { step(i + 1); });
+				};
+				step(0);
+			}
+
+			function openRaw(name) {
+				if (typeof remote.readRaw !== "function") { setError("宿主侧还没有 readRaw 接口（插件版本较旧）"); return; }
+				setError(null); setNotice("");
+				setRawName(name);
+				setRawText("");
+				setRawIsNew(false);
+				setRawLoading(true);
+				remote.readRaw(name)
+					.then(function (r) {
+						const d = unwrap(r);
+						setRawText(d && typeof d.content === "string" ? d.content : "");
+						setRawLoading(false);
+					})
+					.catch(function (e) {
+						const msg = String((e && e.message) || e);
+						// 文件还不存在 → 允许**新建**（索引/流水这类文件此前只能靠文件工具建，
+						// 那正是「只有模型能操作」的一处）。但必须让用户**看见**这是新建：
+						// 静默开一个空编辑框，用户会以为原文件是空的，一存就把内容顶掉。
+						if (/ENOENT|no such file|not exist/i.test(msg)) {
+							setRawText("");
+							setRawIsNew(true);
+							setRawLoading(false);
+							return;
+						}
+						setError("读不到 " + name + "：" + msg);
+						setRawLoading(false);
+						setRawName(null);
+					});
+			}
+
+			function saveRaw(name) {
+				if (typeof remote.writeRaw !== "function") { setError("宿主侧还没有 writeRaw 接口（插件版本较旧）"); return; }
+				setRawBusy(true); setError(null); setNotice("");
+				// 原样交回：不 trim、不补 frontmatter、不做任何「智能」处理。
+				remote.writeRaw(name, rawText)
+					.then(function (r) {
+						if (r && r.ok === false) { setError(r.error || "保存被拒绝"); return; }
+						setNotice((rawIsNew ? "已新建 " : "已保存 ") + name);
+						setRawIsNew(false);
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setRawBusy(false); });
+			}
 			// ── 筛选条的数据 ──
+			// 状态是筛选维度之一：先按状态取一批，类型 / 标签 / 搜索都在这一批里继续收窄。
+			// 组内 OR、组间 AND —— 与「类型 × 标签」原有的语义完全一致。
+			// 归档条目在这里打一个本地 archived 标记（宿主 listArchived 的形状不动），
+			// 列表渲染靠它决定用哪张卡；顺序是**活动在前、归档在后**。
+			const archivedTagged = archiveItems.map(function (x) {
+				return Object.assign({}, x, { archived: true });
+			});
+			const statusItems = statusFilter === "archived"
+				? archivedTagged
+				: statusFilter === "active"
+					? items
+					: items.concat(archivedTagged);
+			const totalCount = items.length + archiveItems.length;
 			// 计数一律按**全量**算，不随当前筛选变化 —— 否则一筛下去别的类型就都显示 0，
 			// 用户没法知道「换个类型还有多少条」。
 			const typeCounts = {};
 			const tagCounts = {};
-			for (let i = 0; i < items.length; i++) {
-				const it = items[i];
+			for (let i = 0; i < statusItems.length; i++) {
+				const it = statusItems[i];
 				const t = it.type || "reference";
 				typeCounts[t] = (typeCounts[t] || 0) + 1;
 				const tg = Array.isArray(it.tags) ? it.tags : [];
@@ -2686,7 +3939,7 @@ const StarmapRuntime = (function (require, _react) {
 			});
 
 			const q = query.trim().toLowerCase();
-			const filtered = items.filter(function (it) {
+			const filtered = statusItems.filter(function (it) {
 				if (typeFilter.length && typeFilter.indexOf(it.type || "reference") < 0) return false;
 				if (tagFilter.length) {
 					const tg = Array.isArray(it.tags) ? it.tags : [];
@@ -2701,7 +3954,85 @@ const StarmapRuntime = (function (require, _react) {
 					(Array.isArray(it.tags) ? it.tags.join(" ") : "")).toLowerCase();
 				return hay.indexOf(q) >= 0;
 			});
-			const hasFilter = !!(typeFilter.length || tagFilter.length || q);
+			const hasFilter = !!(statusFilter !== "all" || typeFilter.length || tagFilter.length || q);
+			// 两个计数永远一起露脸：用户不必先筛状态才知道档案馆里有没有东西。
+			const headerCount = (hasFilter ? "筛出 " + String(filtered.length) + " / " + String(statusItems.length) + " · " : "") +
+				"活动中 " + String(items.length) + " · 已归档 " + String(archiveItems.length);
+			// 头部带的「待重启生效」徽标：有多少项要重启才生效，从 limits / pendingLimits 的差算出来
+			// （reserved 名单的变化 getSettings 只给 restartRequired 布尔值，数不出来就不写数）。
+			const LIMIT_KEYS = ["maxResults", "maxChars", "maxBaseline", "maxSessionBytes", "staleDays"];
+			const pendingDiff = (settings && settings.limits && settings.pendingLimits)
+				? LIMIT_KEYS.filter(function (k) { return settings.limits[k] !== settings.pendingLimits[k]; }).length
+				: 0;
+			const restartPending = !!(settings && settings.restartRequired);
+
+			// 「文件列表」这一屏：状态筛选决定看哪一批，灰色卡片与留痕块自带「退役」语义。
+			// banner 只在**专门看归档**时出现，切到全部时不重复说一遍。
+			let filesView;
+			if (loading && totalCount === 0) {
+				filesView = h("div", { className: "smem-muted", key: "loading" }, "加载中…");
+			} else if (totalCount === 0) {
+				filesView = h("div", { className: "smem-empty", key: "empty" },
+					"还没有记忆文件。对话中值得记住的事会写到这里，也可以点「添加记忆」手动写入。");
+			} else if (statusFilter === "archived" && archiveItems.length === 0) {
+				filesView = h("div", { className: "smem-empty", key: "empty" },
+					"档案馆是空的 —— 在活动记忆那张卡上点「归档」，它就会收到这里。");
+			} else if (statusFilter === "active" && items.length === 0) {
+				filesView = h("div", { className: "smem-empty", key: "empty" },
+					"活动记忆是空的 —— 状态筛到「已归档」还能捞出 " + archiveItems.length + " 条。");
+			} else if (filtered.length === 0) {
+				filesView = h("div", { className: "smem-empty", key: "empty" }, "没有符合搜索或筛选条件的文件。");
+			} else {
+				const list = h("div", { className: "smem-list", key: "list" }, filtered.map(function (it) {
+					if (it.archived === true) {
+						return h(ArchivedCard, {
+							key: it.file,
+							item: it,
+							busy: busy,
+							restoring: restoring === it.file,
+							editing: archEdit === it.file,
+							loading: archLoad && archEdit === it.file,
+							saving: archSaving && archEdit === it.file,
+							text: archText,
+							onText: setArchText,
+							onEdit: openArchEdit,
+							onSave: saveArchEdit,
+							onCancel: cancelArchEdit,
+							onRestore: restoreFile,
+						});
+					}
+					return h(Card, {
+						key: it.file,
+						item: it,
+						expanded: !!expanded[it.file],
+						deleting: deleting === it.file,
+						archiving: archiving === it.file,
+						archiveReason: archiveReason,
+						busy: busy,
+						onArchiveReason: setArchiveReason,
+						onAskArchive: function (file) { setArchiving(file); setArchiveReason(""); setDeleting(null); },
+						onCancelArchive: function () { setArchiving(null); setArchiveReason(""); },
+						onConfirmArchive: confirmArchive,
+						onToggle: function (file) {
+							const nx = {};
+							nx[file] = !expanded[file];
+							setExpanded(Object.assign({}, expanded, nx));
+						},
+						onEdit: openEdit,
+						onAskDelete: function (file) { setDeleting(file); setArchiving(null); },
+						onCancelDelete: function () { setDeleting(null); },
+						onConfirmDelete: confirmDelete,
+					});
+				}));
+				filesView = statusFilter === "archived"
+					? [
+							h("div", { className: "smem-ar-banner", key: "banner" },
+								"档案馆里的记忆不参与检索与星图，原文仍在记忆目录的 archive/ 下 —— 恢复后它就回到活动列表；" +
+								"「编辑」是原样文本编辑，改完存回同一份文件。"),
+							list,
+						]
+					: list;
+			}
 
 			return h("div", { className: "smem-root" }, [
 				h("div", { className: "smem-tabs", key: "tabs" }, [
@@ -2709,30 +4040,143 @@ const StarmapRuntime = (function (require, _react) {
 					h("button", { type: "button", className: "smem-tab" + (tab === "star" ? " smem-tab--on" : ""), key: "s", onClick: function () { setTab("star"); } }, "记忆星图"),
 					h("button", { type: "button", className: "smem-tab" + (tab === "autodream" ? " smem-tab--on" : ""), key: "d", onClick: function () { setTab("autodream"); } }, "自动做梦"),
 				]),
+				// 三个 tab 共用的一条头部带：我在哪 · 目录状态 · 活动/归档计数 · 体检徽标 · 待重启徽标 · 主操作。
+				// 层级形状固定：导航＝下划线（.smem-tabs）、筛选＝chip、动作＝按钮，三种不混用。
 				h("div", { className: "smem-head", key: "head" }, [
-					h("span", { className: "smem-title", key: "t" }, "记忆文件（sage-mem）"),
+					h("span", { className: "smem-title", key: "t" }, "记忆管理"),
+					h("span", { className: "smem-head-job", key: "job" }, TAB_LABEL[tab] || ""),
 					h("span", { className: "smem-dot" + (dirOk ? "" : " smem-dot--bad"), key: "dot", title: dirOk ? "memory 目录可读" : "memory 目录不可读" }),
 					h("span", { className: "smem-muted", key: "st" }, dirOk ? "目录可读" : "目录不可读"),
-					h("span", { className: "smem-badge", key: "cnt" }, hasFilter
-						? "筛出 " + String(filtered.length) + " / " + String(items.length)
-						: "共 " + String(items.length) + " 个文件"),
+					h("span", { className: "smem-badge", key: "cnt" }, headerCount),
+					// 体检徽标：**抽屉关着也一直看得见**。整个「工具收进抽屉」的方案就靠它成立 ——
+					// 没有这个徽标，三个能力就退回「藏起来」了（上一轮刚把它们做成用户自己的入口）。
+					h("button", {
+						type: "button", key: "aud",
+						className: "smem-tool-badge" + (audit && audit.problems ? " smem-tool-badge--bad" : ""),
+						title: audit ? (audit.problems ? "打开体检看是哪几条" : "体检没有发现问题") : "跑一次体检（只读）",
+						onClick: function () { openTool("audit"); },
+					}, audit ? (audit.problems ? ("体检 " + audit.problems + " 个问题") : "体检 通过") : "体检 · 未跑"),
+					restartPending
+						? h("button", {
+								type: "button", key: "rs", className: "smem-tool-badge smem-ad-badge--warn",
+								title: "有改动要重启 DSH 才生效",
+								onClick: function () { setTab("autodream"); setAdSeg("settings"); },
+							}, (pendingDiff ? (pendingDiff + " 项") : "") + "待重启生效")
+						: null,
+					// 主操作：只放当前 tab 的那一个（星图/自动做梦的主操作在各自面板里，不重复摆一份）。
+					h("span", { className: "smem-head-actions", key: "act" }, tab === "files" ? [
+						h("button", { type: "button", className: "smem-btn", key: "refresh", disabled: busy || loading, onClick: load }, "刷新"),
+						h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "add", onClick: openAdd }, "+ 添加记忆"),
+					] : null),
 				]),
-				// 搜索 / 刷新 / 添加 / 筛选都只属于「文件列表」这个视图。
-				// 放在 tab 分支外面，会让星图和自动做梦页也顶着一排用不上的控件
-				// （走查时发现：「+ 添加记忆」出现在星图页上）。
+				// 工具栏只剩「搜索 + 工具 ▾」：刷新与添加已经收进头部带的主操作位。
 				tab === "files" ? h("div", { className: "smem-toolbar", key: "bar" }, [
 					h("input", { className: "smem-search", key: "q", value: query, placeholder: "搜索文件名 / 描述 / 类型 / 标签…", onChange: function (e) { setQuery(e.target.value); } }),
-					h("button", { type: "button", className: "smem-btn", key: "refresh", disabled: busy || loading, onClick: load }, "刷新"),
-					h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "add", onClick: openAdd }, "+ 添加记忆"),
+					// 工具抽屉：关着时这里只有一个按钮，零占位；面板一次只开一个。
+					h("span", { className: "smem-drawer", key: "drawer" }, [
+						h("button", {
+							type: "button", key: "btn",
+							className: "smem-btn" + (drawer ? " smem-btn-primary" : ""),
+							"aria-expanded": drawer ? "true" : "false",
+							title: "体检 / 归档候选 / 保留名编辑",
+							onClick: function () { setDrawer(!drawer); },
+						}, "工具 ▾"),
+						drawer ? h("div", { className: "smem-drawer-pop", key: "pop" }, [
+							h("button", {
+								type: "button", className: "smem-drawer-item", key: "a",
+								"data-on": tool === "audit" ? "1" : "0",
+								onClick: function () { toggleTool("audit"); setDrawer(false); },
+							}, ["体检", h("span", { className: "smem-status" + (audit && audit.problems ? " smem-status--bad" : ""), key: "s" }, audit ? (audit.problems ? (audit.problems + " 个问题") : "通过") : "未跑")]),
+							h("button", {
+								type: "button", className: "smem-drawer-item", key: "c",
+								"data-on": tool === "candidates" ? "1" : "0",
+								onClick: function () { toggleTool("candidates"); setDrawer(false); },
+							}, ["归档候选", h("span", { className: "smem-status", key: "s" }, cand ? (cand.count + " 条") : "未取")]),
+							h("button", {
+								type: "button", className: "smem-drawer-item", key: "r",
+								"data-on": tool === "raw" ? "1" : "0",
+								onClick: function () { toggleTool("raw"); setDrawer(false); },
+							}, ["保留名编辑", h("span", { className: "smem-status", key: "s" }, settings && settings.reserved ? (settings.reserved.length + " 个") : "")]),
+						]) : null,
+					]),
 				]) : null,
-				tab === "files" && items.length
+				tab === "files" && tool === "audit"
+					? h(AuditPanel, { report: audit, busy: auditBusy, onRun: runAudit, onClose: function () { setTool(null); } })
+					: null,
+				tab === "files" && tool === "candidates"
+					? h(CandidatePanel, {
+							data: cand,
+							busy: candBusy || busy,
+							picked: picked,
+							confirm: candConfirm,
+							onLoad: loadCandidates,
+							onClose: function () { setTool(null); },
+							onPick: function (file) {
+								const nx = Object.assign({}, picked);
+								if (nx[file]) delete nx[file]; else nx[file] = true;
+								setPicked(nx);
+							},
+							onPickAll: function () {
+								const list = (cand && cand.candidates) || [];
+								const all = list.length > 0 && list.every(function (x) { return picked[x.file]; });
+								const nx = {};
+								if (!all) list.forEach(function (x) { nx[x.file] = true; });
+								setPicked(nx);
+							},
+							onAskOne: function (file) { setCandConfirm(file); },
+							onAskPicked: function () { setCandConfirm("__batch__"); },
+							onCancelConfirm: function () { setCandConfirm(null); },
+							onArchiveOne: function (x) { archiveCandidates([x]); },
+							onArchivePicked: function () {
+								const list = ((cand && cand.candidates) || []).filter(function (x) { return picked[x.file]; });
+								archiveCandidates(list);
+							},
+						})
+					: null,
+				tab === "files" && tool === "raw"
+					? h(RawPanel, {
+							reserved: settings && settings.reserved,
+							name: rawName,
+							text: rawText,
+							isNew: rawIsNew,
+							loading: rawLoading,
+							busy: rawBusy,
+							saving: rawBusy,
+							onOpen: openRaw,
+							onText: setRawText,
+							onSave: saveRaw,
+							onClose: function () { setRawName(null); setRawText(""); setRawIsNew(false); },
+						})
+					: null,
+				// 三排筛选：状态 / 类型 / 标签。组内 OR、组间 AND，再与搜索框 AND。
+				tab === "files" && totalCount
 					? h("div", { className: "smem-filters", key: "filters" }, [
+							h("span", { className: "smem-filters-label", key: "lst" }, "状态"),
+							h("button", {
+								type: "button", key: "st-all", className: "smem-chip",
+								"data-on": statusFilter === "all" ? "1" : "0",
+								title: "活动与已归档一起看（归档条走灰色）",
+								onClick: function () { setStatusFilter("all"); },
+							}, ["全部", h("span", { className: "smem-chip-n", key: "n" }, String(totalCount))]),
+							h("button", {
+								type: "button", key: "st-active", className: "smem-chip",
+								"data-on": statusFilter === "active" ? "1" : "0",
+								title: "正在参与检索与星图的记忆",
+								onClick: function () { setStatusFilter("active"); },
+							}, ["活动中", h("span", { className: "smem-chip-n", key: "n" }, String(items.length))]),
+							h("button", {
+								type: "button", key: "st-arch", className: "smem-chip",
+								"data-on": statusFilter === "archived" ? "1" : "0",
+								title: "已收进档案馆：不参与检索与星图，可编辑 / 恢复",
+								onClick: function () { setStatusFilter("archived"); },
+							}, ["已归档", h("span", { className: "smem-chip-n", key: "n" }, String(archiveItems.length))]),
+							h("span", { className: "smem-sep", key: "sep0" }),
 							h("span", { className: "smem-filters-label", key: "lt" }, "类型"),
 							h("button", {
 								type: "button", key: "all", className: "smem-chip",
 								"data-on": typeFilter.length ? "0" : "1",
 								onClick: function () { setTypeFilter([]); },
-							}, ["全部", h("span", { className: "smem-chip-n", key: "n" }, String(items.length))]),
+							}, ["全部", h("span", { className: "smem-chip-n", key: "n" }, String(statusItems.length))]),
 							typeList.map(function (t) {
 								return h("button", {
 									type: "button", key: t, className: "smem-chip",
@@ -2752,7 +4196,7 @@ const StarmapRuntime = (function (require, _react) {
 							hasFilter
 								? h("button", {
 										type: "button", key: "clear", className: "smem-btn",
-										onClick: function () { setTypeFilter([]); setTagFilter([]); setQuery(""); },
+										onClick: function () { setStatusFilter("all"); setTypeFilter([]); setTagFilter([]); setQuery(""); },
 									}, "清除筛选")
 								: null,
 						])
@@ -2784,34 +4228,11 @@ const StarmapRuntime = (function (require, _react) {
 						])
 					: null,
 				tab === "autodream"
-					? h(AutodreamPanel, { key: "autodream", ctx: props.ctx })
+					? h(AutodreamPanel, { key: "autodream", ctx: props.ctx, seg: adSeg, onSeg: setAdSeg })
 					: tab === "star"
 					? h("div", { className: "smem-starmap", key: "starmap" },
 							h(StarmapRuntime.StarMap, { ctx: props.ctx }))
-					: loading && items.length === 0
-						? h("div", { className: "smem-muted", key: "loading" }, "加载中…")
-						: filtered.length === 0
-							? h("div", { className: "smem-empty", key: "empty" },
-									items.length === 0
-										? "还没有记忆文件。对话中值得记住的事会写到这里，也可以点「添加记忆」手动写入。"
-										: "没有符合搜索条件的文件。")
-							: h("div", { className: "smem-list", key: "list" }, filtered.map(function (it) {
-								return h(Card, {
-									key: it.file,
-									item: it,
-									expanded: !!expanded[it.file],
-									deleting: deleting === it.file,
-									onToggle: function (file) {
-										const nx = {};
-										nx[file] = !expanded[file];
-										setExpanded(Object.assign({}, expanded, nx));
-									},
-									onEdit: openEdit,
-									onAskDelete: function (file) { setDeleting(file); },
-									onCancelDelete: function () { setDeleting(null); },
-									onConfirmDelete: confirmDelete,
-								});
-							})),
+					: filesView,
 			]);
 		}