sage-mem 0.9.6 → 0.9.9

package/README.md

@@ -49,13 +49,21 @@ sage-mem 换一条路：**每条记忆就是一个 Markdown 文件**。用编辑
 
 *文件列表 —— 头部带常显「体检 N 个问题」与「待重启生效」，不用点开就知道该不该处理；灰底条目是已归档，随时可以恢复。*
 
-![工具抽屉：体检 / 归档候选 / 保留名编辑，关着时零占位](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/tools-drawer.png)
+![工具抽屉：归档候选 / 保留名编辑，关着时零占位](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/tools-drawer.png)
 
-*工具抽屉 —— 关着时只占一个按钮，展开后三项各带状态：体检 4 个问题 / 归档候选 2 条 / 保留名 3 个。*
+*工具抽屉 —— 关着时只占一个按钮，展开后两项各带状态：归档候选 2 条 / 保留名 3 个。（体检不在这里：它自己有一页。）*
 
-![体检：硬问题按类报红分节，「指向已归档」只作提示](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/audit.png)
+![锁定：按钮在「编辑」与「归档」之间，锁上后归档被禁用](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/lock-card.png)
 
-*体检 —— 索引悬空、漏索引、断链这类硬问题按类报红；「指向已归档」只作提示、不计入问题，也不提供一键修补按钮（改哪条由你决定）。*
+*锁定 —— 重要记忆（人设、偏好这类）点一下就锁上：**自动归档的候选里不再出现它，手动点归档也会被宿主拒绝**。锁存在状态目录里，不写进记忆自己的 frontmatter —— 那会被自动整理重写掉，锁一丢它又会回到候选里。*
+
+![体检：独立一页，硬问题按类报红分节，「指向已归档」只作提示](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/audit.png)
+
+*体检（独立成一个页签）—— 索引悬空、漏索引、断链这类硬问题按类报红；「指向已归档」只作提示、不计入问题，也不提供一键修补按钮（改哪条由你决定）。从档案馆恢复一条记忆时，插件会顺手把它补回索引 —— 以前只搬文件、不补条目，于是顶层有文件、`MEMORY.md` 里没有，体检一直报「漏索引」。*
+
+![更新提示：只在真有新版本时出现一条横幅](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/update-banner.png)
+
+*更新提示 —— 只在**真有新版本**时出现一条横幅，写明新版本与当前版本；「看更新内容」开新标签页，「×」只是这次不看。查不到 / 被限流 / 网络不通一律静默，不会因为查版本失败而冒红条。*
 
 ![归档候选：每条写清「为什么建议归档」，确认后才执行](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/archive-candidates.png)
 
@@ -69,6 +77,10 @@ sage-mem 换一条路：**每条记忆就是一个 Markdown 文件**。用编辑
 
 *自动做梦 · 设置 —— 运行 / 设置 / 记录 二级分组；五个注入参数两列排开，并写清「当前生效」与「重启后」，不会让人误以为改完立刻生效。*
 
+![自动归档：独立一页，先说清它做什么，三档策略与三个闲置阈值都在这儿](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/archive-settings.png)
+
+*自动归档（独立成一个页签，排在「自动做梦」与「体检」之间）—— 它和自动做梦不是一件事：归档是**确定性规则**（按访问台账的闲置天数算，不调模型），混在模型那套设置里既难找、也容易让人以为归档会花钱。这一页决定「多久算闲置」，以及要不要真的动手；阈值**保存即生效**，不用重启。*
+
 ## 快速开始
 
 需要 DSH `0.1.2-rc.1` 或更高（见[兼容性](#dsh-兼容性)），Node.js `>= 18`。

package/lib/client.js

@@ -1684,6 +1684,30 @@ const StarmapRuntime = (function (require, _react) {
 					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/checkUpdate",
+					service: "memory",
+					namespace: "memory",
+					method: "checkUpdate",
+					invocation: { kind: "direct" },
+					parameters: [],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#UpdateCheck", schema: objCodec, create: () => objCodec },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					// 上锁 / 解锁一条记忆：锁上的记忆拒绝归档（自动与手动都不行）。
+					id: "sage-mem#memory/setLocked",
+					service: "memory",
+					namespace: "memory",
+					method: "setLocked",
+					invocation: { kind: "direct" },
+					parameters: [
+						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#FileName", schema: strSchema, create: () => strSchema } },
+						{ name: "locked", wire: "locked", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#LockFlag", schema: boolSchema, create: () => boolSchema } },
+					],
+					result: { mode: "strict", typeSymbol: "sage-mem/types#LockResult", schema: objCodec, create: () => objCodec },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
 				{
 					id: "sage-mem#memory/archiveCandidates",
 					service: "memory",
@@ -1976,6 +2000,15 @@ const StarmapRuntime = (function (require, _react) {
 			".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-root`（760px）上，这里只要确保它在任何父容器里
+			// 都吃满那个上限 —— 抽屉里的小面板没有这个问题（它外面还套着一层），
+			// 而独立成屏后如果父容器不是 column flex，`align-items:stretch` 就不会发生。
+			".smem-tool-panel--full{width:100%;align-self:stretch;box-sizing:border-box;}",
+			// 已锁定的记忆：卡片上那个按钮要一眼看出「这条现在拒绝归档」，用警示色
+			".smem-btn-locked{border-color:var(--dsw-alias-state-warning-primary,#d97706);color:var(--dsw-alias-state-warning-primary,#d97706);}",
+			// 「自动归档」页签里的天数输入框：窄一点，别让三个数字各占一整行
+			".smem-num{width:88px;}",
 			// 体检 / 候选是「翻清单」的面板：定高 + 内部滚动，列表不被顶出首屏。
 			// 原样编辑器（.smem-ar-editor）不设上限 —— 那是专心改一份文件的界面，给它完整高度。
 			".smem-tool-panel--cap{max-height:320px;overflow-y:auto;}",
@@ -2074,6 +2107,13 @@ const StarmapRuntime = (function (require, _react) {
 			".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;}",
+			// ── 更新提示（有新版本才出现的一条窄横幅）──
+			".smem-update{display:flex;align-items:center;gap:10px;flex-wrap:wrap;border:1px solid var(--dsw-alias-brand-primary,#4d76e6);border-radius:8px;padding:6px 10px;font-size:12px;background:var(--dsw-alias-bg-layer-1);}",
+			".smem-update-link{color:var(--dsw-alias-brand-primary,#4d76e6);text-decoration:underline;}",
+			".smem-update-x{margin-left:auto;border:0;background:transparent;color:inherit;cursor:pointer;font-size:14px;line-height:1;padding:0 2px;}",
+			// ── 底部一行仓库链接（引流，不抢视线）──
+			".smem-star{display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap;font-size:12px;color:var(--dsw-alias-label-tertiary,#8b93a1);padding:2px 2px 0;}",
+			".smem-star-link{color:var(--dsw-alias-brand-primary,#4d76e6);text-decoration:underline;}",
 		].join("\n");
 
 		const TYPE_META = {
@@ -2408,8 +2448,33 @@ const StarmapRuntime = (function (require, _react) {
 										]
 									: [
 											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); } }, "归档"),
+											/**
+											 * 锁定排在「编辑」与「归档」之间（用户 2026-10-11 指定）：
+											 * 它是「别归档这条」的开关，紧挨着归档才说得通。
+											 *
+											 * 锁上的记忆**自动与手动都不许归档** —— 候选计算会跳过它，
+											 * 手动点归档会被宿主拒绝。图标用 🔒 / 🔓 之外还留着文字，
+											 * 因为「锁」在这里是**拒绝归档**，不是「只读」。
+											 */
+											h("button", {
+												type: "button",
+												className: "smem-btn" + (item.locked ? " smem-btn-locked" : ""),
+												key: "lock",
+												title: item.locked
+													? "已锁定：自动归档不会选它，手动归档也会被拒绝。点一下解锁"
+													: "锁定这条记忆：自动与手动归档都不再动它（重要的人设 / 偏好建议锁上）",
+												disabled: props.busy,
+												onClick: function () { props.onToggleLock(item.file, !item.locked); },
+											}, item.locked ? "🔒 已锁定" : "🔓 锁定"),
+											// 归档排在「锁定」和「删除」之间：比编辑轻、比删除温和，且随时可逆。
+											h("button", {
+												type: "button", className: "smem-btn", key: "arch",
+												title: item.locked
+													? "这条已锁定，归档会被拒绝（先解锁）"
+													: "收进档案馆：不再参与检索与星图，随时可以恢复",
+												disabled: props.busy || item.locked === true,
+												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); } }, "删除"),
 										])),
 			]);
@@ -2493,8 +2558,8 @@ const StarmapRuntime = (function (require, _react) {
 		};
 		const autoArchiveOf = (v) => (v === "off" || v === "auto" ? v : "report");
 
-		/** 头部带上的「我在哪」：三个 tab 的中文名（与 .smem-tabs 上的字面一致）。 */
-		const TAB_LABEL = { files: "文件列表", star: "记忆星图", autodream: "自动做梦" };
+		/** 头部带上的「我在哪」：五个 tab 的中文名（与 .smem-tabs 上的字面一致）。 */
+		const TAB_LABEL = { files: "文件列表", star: "记忆星图", autodream: "自动做梦", archive: "自动归档", audit: "体检" };
 
 		/**
 		 * 工具面板头部的「收起」按钮：抽屉里开的工具要能一键收回去 ——
@@ -2513,8 +2578,33 @@ const StarmapRuntime = (function (require, _react) {
 		 * 硬问题与提示**分开渲染**：`archivedLinks` 是提示（归档不是删除，目标还在档案馆里），
 		 * 跟问题一样染红会让人去「修」一条本来正确的链接 —— 那正是审计里那条分界线。
 		 */
+		/**
+		 * 面板底部的一行仓库链接。
+		 *
+		 * 参照手机访问插件那一行的做法：放在不抢视线的地方、语气轻、点开是新标签页。
+		 * 它**是引流不是功能** —— 所以不占一屏、不做成按钮、失败也没有任何副作用；
+		 * 四个 tab 下都在（谁也没必要为看它切页）。
+		 */
+		function StarLine() {
+			return h("div", { className: "smem-star" }, [
+				h("span", { key: "ask" }, "⭐ 顺手留颗 Star，作者能高兴一整天"),
+				h("a", {
+					key: "cta",
+					href: "https://github.com/gezi-wen/sage-mem",
+					target: "_blank",
+					rel: "noreferrer",
+					className: "smem-star-link",
+				}, "行，给你一颗 Star"),
+			]);
+		}
+
 		function AuditPanel(props) {
 			const r = props.report || {};
+			/**
+			 * 独立成 tab 时不套抽屉那层窄框（`--cap` 有 320px 限高）、也不给「收起」按钮 ——
+			 * 它不是「暂时摊开的一层」，它就是这一屏。
+			 */
+			const standalone = props.standalone === true;
 			const rows = (list, render) => (list || []).map(function (x, i) {
 				return h("div", { className: "smem-audit-row", key: String(x.file || "?") + "-" + i }, render(x));
 			});
@@ -2525,7 +2615,7 @@ const StarmapRuntime = (function (require, _react) {
 					])
 				: null);
 			const hints = r.archivedLinks || [];
-			return h("div", { className: "smem-tool-panel smem-tool-panel--cap", key: "audit" }, [
+			return h("div", { className: "smem-tool-panel" + (standalone ? " smem-tool-panel--full" : " 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" },
@@ -2535,7 +2625,7 @@ const StarmapRuntime = (function (require, _react) {
 					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),
+					standalone ? null : toolClose(props),
 				]),
 				r.problems
 					? h("div", { className: "smem-audit-secs", key: "secs" }, [
@@ -2748,7 +2838,6 @@ const StarmapRuntime = (function (require, _react) {
 			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 的依赖数组要在渲染期就能取到值。
@@ -2848,35 +2937,6 @@ const StarmapRuntime = (function (require, _react) {
 				}, 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; }
@@ -3174,28 +3234,9 @@ const StarmapRuntime = (function (require, _react) {
 				]),
 				]) : 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,
-				]),
+				// 自动归档那一段（三档策略 + 三个阈值）**已挪到「自动归档」页签**（v0.9.9）：
+				// 归档是确定性规则、不调模型，和这一页的「让模型整理」不是一件事；
+				// 同一件事只在一处设定，这里不再重复摆一份。
 				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" } }, "记忆注入参数"),
@@ -3411,6 +3452,187 @@ const StarmapRuntime = (function (require, _react) {
 			]);
 		}
 
+		/**
+		 * 「自动归档」面板 —— 独立成一屏（v0.9.9）。
+		 *
+		 * 为什么独立出来（用户 2026-10-11）：这一块原来塞在「自动做梦 → 设置」里，
+		 * 他自己的原话是「扔这里连我都找不到」。而且它确实是**另一件事**：
+		 *   自动做梦 = 让模型读记忆、整理、改写（要调模型、有 token 成本）
+		 *   自动归档 = 按「多久没被注入过」把记忆移进 archive/（纯确定性规则、不调模型）
+		 * 混在模型那套设置里，既难找、也容易让人以为归档会花钱。
+		 *
+		 * 这一页管两件事：
+		 *   1. **三档策略**：关闭 / 只出报告 / 满足条件自动跑
+		 *   2. **三个阈值**（项目 / 参考 / 用户）：多少天没被注入就算闲置
+		 *
+		 * 数据全走 `remote.autodream` 的 `getConfig` / `setConfig` —— 阈值本来就在配置里
+		 * （`lib/autodream/config.js` 的 archiveAfterDays*），只是以前**界面够不着**。
+		 * 所以这一版没有新增任何 remote。
+		 *
+		 * 两处诚实标注：阈值**存完立即生效**（不经过模块加载期固化，与注入参数不同）；
+		 * 保存后**一定回读**（`setConfig` 对非法值是「忽略并保留原值」，只信返回值会骗人）。
+		 */
+		function ArchiveSettingsPanel(props) {
+			const remote = props.ctx && props.ctx.get ? props.ctx.get("remote.autodream") : null;
+			const sCfg = react.useState(null); const cfg = sCfg[0], setCfg = sCfg[1];
+			const sDraft = react.useState(null); const draft = sDraft[0], setDraft = sDraft[1];
+			const sErr = react.useState(null); const err = sErr[0], setErr = sErr[1];
+			const sNotice = react.useState(""); const notice = sNotice[0], setNotice = sNotice[1];
+			const sBusy = react.useState(false); const busy = sBusy[0], setBusy = sBusy[1];
+
+			const TH_KEYS = ["archiveAfterDaysProject", "archiveAfterDaysReference", "archiveAfterDaysUser"];
+			const TH_LABEL = { archiveAfterDaysProject: "项目", archiveAfterDaysReference: "参考", archiveAfterDaysUser: "用户" };
+			const TH_HINT = {
+				archiveAfterDaysProject: "project_* 连续这么多天没被注入 → 进候选",
+				archiveAfterDaysReference: "reference_* 同上（资料一般比项目留得久）",
+				archiveAfterDaysUser: "user_* 同上（人设这类动它要格外谨慎）",
+			};
+
+			/** 阈值 → 输入框草稿。存成字符串：number input 清空时立刻变 0 会很难用。 */
+			const draftOf = function (c) {
+				const src = c || {};
+				const out = {};
+				for (const k of TH_KEYS) out[k] = String(src[k] == null ? "" : src[k]);
+				return out;
+			};
+
+			react.useEffect(function () {
+				if (!remote || typeof remote.getConfig !== "function") {
+					setErr("宿主侧没有 autodream 配置接口（插件版本较旧）");
+					return;
+				}
+				remote.getConfig()
+					.then(function (r) {
+						const d = unwrap(r);
+						const c = d && d.config ? d.config : null;
+						if (!c) { setErr("读不出自动做梦配置"); return; }
+						setCfg(c);
+						setDraft(draftOf(c));
+					})
+					.catch(function (e) { setErr("读配置失败：" + ((e && e.message) || e)); });
+			}, []);
+
+			const c = cfg || {};
+			const mode = autoArchiveOf(c.autoArchive);
+
+			/**
+			 * 存完回读。
+			 * @param {Object} patch 要写的配置
+			 * @param {string} okMsg 成功提示
+			 * @param {Function} failOf (got) => string|null —— 返回 null 表示这次改动真的落进去了
+			 */
+			function save(patch, okMsg, failOf) {
+				setBusy(true); setErr(null); setNotice("");
+				remote.setConfig(patch)
+					.then(function () { return remote.getConfig(); })
+					.then(function (r) {
+						const d = unwrap(r);
+						const got = d && d.config ? d.config : null;
+						if (got) { setCfg(got); setDraft(draftOf(got)); }
+						const bad = failOf(got);
+						if (!bad) { setNotice(okMsg); return; }
+						setErr("保存没生效：" + bad + "。setConfig 对非法值会忽略并保留原值 —— 请重试，或看 DSH 启动日志。");
+					})
+					.catch(function (e) { setErr("保存失败：" + ((e && e.message) || e)); })
+					.then(function () { setBusy(false); });
+			}
+
+			function saveMode(v) {
+				save({ autoArchive: v }, "自动归档已设为「" + AUTO_ARCHIVE_LABEL[v] + "」", function (got) {
+					const g = got ? autoArchiveOf(got.autoArchive) : null;
+					return g === v ? null : ("配置里仍是「" + (g ? AUTO_ARCHIVE_LABEL[g] : "读不出来") + "」");
+				});
+			}
+
+			/** 越界/非整数**本地先拦**（host 也会拒），别让它白跑一趟。 */
+			function saveThresholds() {
+				const d = draft || {};
+				const patch = {};
+				for (const k of TH_KEYS) {
+					const n = Number(d[k]);
+					if (!Number.isFinite(n) || n < 1 || n > 3650) {
+						setErr(TH_LABEL[k] + "的阈值要是 1~3650 之间的天数（现在是「" + d[k] + "」）");
+						return;
+					}
+					patch[k] = Math.round(n);
+				}
+				save(patch, "归档条件已保存", function (got) {
+					const bad = TH_KEYS.filter(function (k) { return !got || Number(got[k]) !== patch[k]; });
+					if (!bad.length) return null;
+					return bad.map(function (k) { return TH_LABEL[k] + " 仍是 " + (got ? got[k] : "读不出来"); }).join("、");
+				});
+			}
+
+			return h("div", { className: "smem-seg" }, [
+				// ── ① 它做什么（这一屏存在的理由写在最前面）──
+				h("div", { className: "smem-autodream-sec", key: "what" }, [
+					h("div", { className: "smem-autodream-row", key: "h" }, [
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "自动归档做什么"),
+					]),
+					h("div", { className: "smem-autodream-note", key: "p1" },
+						"闲置太久没被注入过的记忆，会被移进 archive/ —— 不删除，随时能恢复。这一页决定「多久算闲置」，以及要不要真的动手。"),
+					h("div", { className: "smem-autodream-note", key: "p2" },
+						"它不调模型：候选完全按访问台账的天数算，同一份输入每次算出来都一样。"),
+					h("div", { className: "smem-autodream-note", key: "p3" },
+						"想现在看看会被收走哪些：文件列表 →「工具 ▾」→ 归档候选。"),
+				]),
+				// ── ② 三档策略 ──
+				h("div", { className: "smem-autodream-sec", key: "mode" }, [
+					h("div", { className: "smem-autodream-row", key: "r" }, [
+						h("span", { className: "smem-autodream-key", key: "k" }, "自动归档"),
+						h(Seg, {
+							key: "v", value: mode,
+							options: [
+								{ value: "off", label: AUTO_ARCHIVE_LABEL.off },
+								{ value: "report", label: AUTO_ARCHIVE_LABEL.report },
+								{ value: "auto", label: AUTO_ARCHIVE_LABEL.auto },
+							],
+							onChange: function (v) { if (v !== mode) saveMode(v); },
+						}),
+						busy ? h("span", { className: "smem-status", key: "s" }, "保存中…") : null,
+					]),
+					h("div", { className: "smem-autodream-note", key: "cost" }, AUTO_ARCHIVE_COST[mode]),
+					mode === "auto" && !c.apply
+						? h("div", { className: "smem-autodream-note smem-ad-warn", key: "deg" },
+								"注意：「自动做梦 → 改动方式」现在是只出报告 —— 这一档会自动降级成只出报告，不会动文件。")
+						: null,
+				]),
+				// ── ③ 三个阈值 ──
+				h("div", { className: "smem-autodream-sec", key: "th" }, [
+					h("div", { className: "smem-autodream-row", key: "h" }, [
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, "闲置多少天算可以归档"),
+					]),
+					draft
+						? h("div", { key: "rows" }, TH_KEYS.map(function (k) {
+								return h("div", { className: "smem-autodream-row", key: k }, [
+									h("span", { className: "smem-autodream-key", key: "k" }, TH_LABEL[k]),
+									h("input", {
+										className: "smem-input smem-num", key: "i", type: "number", min: 1, max: 3650,
+										value: draft[k],
+										onChange: function (e) {
+											const nx = Object.assign({}, draft);
+											nx[k] = e.target.value;
+											setDraft(nx);
+										},
+									}),
+									h("span", { className: "smem-muted", key: "u" }, TH_HINT[k]),
+								]);
+							}))
+						: h("div", { className: "smem-muted", key: "loading" }, "读配置中…"),
+					h("div", { className: "smem-autodream-row", key: "btns" }, [
+						h("button", {
+							type: "button", className: "smem-btn smem-btn-primary", key: "save",
+							disabled: busy || !draft, onClick: saveThresholds,
+						}, busy ? "保存中…" : "保存归档条件"),
+						h("span", { className: "smem-muted", key: "n" }, "保存即生效，不用重启 DSH"),
+					]),
+					h("div", { className: "smem-autodream-note", key: "note" },
+						"天数按访问台账算（这条记忆上次被注入给模型是什么时候）。feedback_* 永不入选；锁定的记忆也不会被选中。"),
+				]),
+				err ? h("div", { className: "smem-err", key: "err" }, "⚠ " + err) : null,
+				notice ? h("div", { className: "smem-ok", key: "ok" }, "✓ " + notice) : null,
+			]);
+		}
 		function Section(props) {
 			const remote = props.ctx.get("remote.memory");
 			const sItems = react.useState([]);
@@ -3504,6 +3726,9 @@ const StarmapRuntime = (function (require, _react) {
 			const audit = sAudit[0], setAudit = sAudit[1];
 			const sAuditBusy = react.useState(false);
 			const auditBusy = sAuditBusy[0], setAuditBusy = sAuditBusy[1];
+			// 更新提示：只在**确实有新版本**时才被赋值（查不到/限流/网络错都不赋值）
+			const sUpdate = react.useState(null);
+			const updateInfo = sUpdate[0], setUpdateInfo = sUpdate[1];
 			const sCand = react.useState(null);
 			const cand = sCand[0], setCand = sCand[1];
 			const sCandBusy = react.useState(false);
@@ -3558,6 +3783,19 @@ const StarmapRuntime = (function (require, _react) {
 				// 头部带的两个徽标要有数据才立得住：体检（只读扫描）与待重启项。
 				runAudit();
 				loadSettings();
+				/**
+				 * 更新检查：**静默**跑，失败一律不打扰 ——
+				 * 网络不通、被 GitHub 限流、仓库还没建 release，都不该在面板上冒一条红。
+				 * 只有 `updateAvailable` 为真才把结果放进 state，界面才有一条横幅。
+				 */
+				if (remote && typeof remote.checkUpdate === "function") {
+					remote.checkUpdate()
+						.then(function (r) {
+							const d = unwrap(r);
+							if (d && d.updateAvailable) setUpdateInfo(d);
+						})
+						.catch(function () { /* 查版本失败不是用户的事 */ });
+				}
 			}, []);
 
 			/**
@@ -3699,9 +3937,33 @@ const StarmapRuntime = (function (require, _react) {
 					.then(function () { setBusy(false); });
 			}
 
+			/**
+			 * 上锁 / 解锁一条记忆。
+			 *
+			 * 锁定 = **拒绝归档**（自动归档的候选里不出现、手动点归档也被宿主拒绝），
+			 * **不是「只读」** —— 文案必须按这个说，否则用户会以为锁上就不能编辑了。
+			 */
+			function toggleLock(file, locked) {
+				if (typeof remote.setLocked !== "function") {
+					setError("宿主侧还没有 setLocked 接口（插件版本较旧）");
+					return;
+				}
+				setBusy(true); setError(null); setNotice("");
+				remote.setLocked(file, locked)
+					.then(function (r) {
+						const d = unwrap(r);
+						if (d && d.ok === false) { setError(d.error || "锁定操作被拒绝"); return; }
+						setNotice(locked
+							? ("已锁定 " + file + " —— 自动归档不会再选它，手动归档也会被拒绝")
+							: ("已解锁 " + file));
+						load();
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setBusy(false); });
+			}
+
 			/** 从档案馆捞回来：文件移回记忆目录，归档留痕被抹掉。 */
-			function restoreFile(file) {
-				if (typeof remote.restore !== "function") {
+			function restoreFile(file) {				if (typeof remote.restore !== "function") {
 					setError("宿主侧还没有 restore 接口（插件版本较旧）");
 					return;
 				}
@@ -3710,7 +3972,8 @@ const StarmapRuntime = (function (require, _react) {
 				remote.restore(file)
 					.then(function (r) {
 						if (r && r.ok === false) { setError(r.error || "恢复被拒绝"); return; }
-						setNotice("已恢复 " + file + " —— 它回到了活动记忆里");
+						// 恢复会顺带把这条补进索引：说清楚，否则用户不知道「漏索引」是怎么好的
+						setNotice("已恢复 " + file + " —— 它回到了活动记忆里" + (r && r.indexed ? "，并补进了索引" : ""));
 						load();
 					})
 					.catch(function (e) { setError(String((e && e.message) || e)); })
@@ -3810,16 +4073,27 @@ const StarmapRuntime = (function (require, _react) {
 				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 openAuditTab() {
+				setTab("audit");
+				setError(null);
+				if (!audit) runAudit();
+			}
+
+			/** 打开某个工具（抽屉里点进来时用）。 */
 			function openTool(name) {
 				setTool(name);
 				setError(null);
-				if (name === "audit" && !audit) runAudit();
 				if (name === "candidates" && !cand) loadCandidates();
 				if (name === "raw" && !settings) loadSettings();
 			}
@@ -4013,6 +4287,7 @@ const StarmapRuntime = (function (require, _react) {
 						onAskArchive: function (file) { setArchiving(file); setArchiveReason(""); setDeleting(null); },
 						onCancelArchive: function () { setArchiving(null); setArchiveReason(""); },
 						onConfirmArchive: confirmArchive,
+						onToggleLock: toggleLock,
 						onToggle: function (file) {
 							const nx = {};
 							nx[file] = !expanded[file];
@@ -4039,8 +4314,15 @@ const StarmapRuntime = (function (require, _react) {
 					h("button", { type: "button", className: "smem-tab" + (tab === "files" ? " smem-tab--on" : ""), key: "f", onClick: function () { setTab("files"); } }, "文件列表"),
 					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"); } }, "自动做梦"),
+					// 「自动归档」排在自动做梦之后：归档是**确定性规则**（按闲置天数算，不调模型），
+					// 和「让模型整理记忆」是两件事。塞在自动做梦的设置里用户找不到
+					// （2026-10-11 用户原话：「扔这里连我都找不到」）。
+					h("button", { type: "button", className: "smem-tab" + (tab === "archive" ? " smem-tab--on" : ""), key: "ar", onClick: function () { setTab("archive"); } }, "自动归档"),
+					// 体检再排在「自动归档」之后、独立成一屏：它只报告不修改，和「文件列表」里的
+					// 增删改是两件事，塞在工具抽屉里会让人以为它是个动作按钮。
+					h("button", { type: "button", className: "smem-tab" + (tab === "audit" ? " smem-tab--on" : ""), key: "a", onClick: openAuditTab }, "体检"),
 				]),
-				// 三个 tab 共用的一条头部带：我在哪 · 目录状态 · 活动/归档计数 · 体检徽标 · 待重启徽标 · 主操作。
+				// 四个 tab 共用的一条头部带：我在哪 · 目录状态 · 活动/归档计数 · 体检徽标 · 待重启徽标 · 主操作。
 				// 层级形状固定：导航＝下划线（.smem-tabs）、筛选＝chip、动作＝按钮，三种不混用。
 				h("div", { className: "smem-head", key: "head" }, [
 					h("span", { className: "smem-title", key: "t" }, "记忆管理"),
@@ -4048,13 +4330,12 @@ const StarmapRuntime = (function (require, _react) {
 					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" }, 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"); },
+						title: audit ? (audit.problems ? "切到体检看是哪几条" : "体检没有发现问题") : "跑一次体检（只读）",
+						onClick: openAuditTab,
 					}, audit ? (audit.problems ? ("体检 " + audit.problems + " 个问题") : "体检 通过") : "体检 · 未跑"),
 					restartPending
 						? h("button", {
@@ -4069,6 +4350,22 @@ const StarmapRuntime = (function (require, _react) {
 						h("button", { type: "button", className: "smem-btn smem-btn-primary", key: "add", onClick: openAdd }, "+ 添加记忆"),
 					] : null),
 				]),
+				// 更新提示：四个 tab 共用一条，只在真有新版时出现；「×」只是这次不看
+				updateInfo
+					? h("div", { className: "smem-update", key: "update" }, [
+							h("span", { key: "t" }, "发现新版本 v" + String(updateInfo.latest) + "（当前 v" + String(updateInfo.current) + "）"),
+							h("a", {
+								key: "l", className: "smem-update-link",
+								href: updateInfo.releasesUrl || "https://github.com/gezi-wen/sage-mem/releases",
+								target: "_blank", rel: "noreferrer",
+							}, "看更新内容"),
+							h("button", {
+								type: "button", key: "x", className: "smem-update-x",
+								title: "这次不看了（下次进面板还会提示）",
+								onClick: function () { setUpdateInfo(null); },
+							}, "×"),
+						])
+					: null,
 				// 工具栏只剩「搜索 + 工具 ▾」：刷新与添加已经收进头部带的主操作位。
 				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); } }),
@@ -4078,15 +4375,11 @@ const StarmapRuntime = (function (require, _react) {
 							type: "button", key: "btn",
 							className: "smem-btn" + (drawer ? " smem-btn-primary" : ""),
 							"aria-expanded": drawer ? "true" : "false",
-							title: "体检 / 归档候选 / 保留名编辑",
+							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 + " 个问题") : "通过") : "未跑")]),
+							// 体检独立成 tab 之后，抽屉里只剩这两件「要动手」的事。
 							h("button", {
 								type: "button", className: "smem-drawer-item", key: "c",
 								"data-on": tool === "candidates" ? "1" : "0",
@@ -4100,8 +4393,8 @@ const StarmapRuntime = (function (require, _react) {
 						]) : null,
 					]),
 				]) : null,
-				tab === "files" && tool === "audit"
-					? h(AuditPanel, { report: audit, busy: auditBusy, onRun: runAudit, onClose: function () { setTool(null); } })
+				tab === "audit"
+					? h(AuditPanel, { report: audit, busy: auditBusy, onRun: runAudit, standalone: true })
 					: null,
 				tab === "files" && tool === "candidates"
 					? h(CandidatePanel, {
@@ -4232,7 +4525,15 @@ const StarmapRuntime = (function (require, _react) {
 					: tab === "star"
 					? h("div", { className: "smem-starmap", key: "starmap" },
 							h(StarmapRuntime.StarMap, { ctx: props.ctx }))
+					: tab === "archive"
+					? h(ArchiveSettingsPanel, { key: "archive", ctx: props.ctx })
+					: tab === "audit"
+					// 体检面板在上面已经渲染过了 —— 这里必须显式给 null，
+					// 否则会落进下面那个 `filesView` 兜底分支，变成「体检 + 一整套文件列表」同屏。
+					? null
 					: filesView,
+				// 底部一行仓库链接（四个 tab 都在，不抢视线）
+				h(StarLine, { key: "star-line" }),
 			]);
 		}
 

package/lib/index.js

@@ -29,6 +29,8 @@ import { warnLog, writeFileAtomic } from './memory/util.js'
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol'
 import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises'
 import { basename, join } from 'node:path'
+import { checkUpdate as checkUpdateImpl } from './update.js'
+import { readLockSet, setLocked as setLockedImpl } from './memory/lock.js'
 
 /**
  * `SAGE_MEM_DEBUG=1` 才出声的注入链调试出口。
@@ -377,9 +379,20 @@ export class MemoryGateway extends TypertRemoteService {
     })
   }
 
-  /** 列出 memory 目录全部记忆文件（文件名 + 类型 + 描述 + 大小 + 自定义标签）。 */
+  /**
+   * 查有没有新版本（面板进入时静默调一次）。
+   *
+   * 实现全在 `lib/update.js`：**当前版本运行时读自己的 `package.json`**（不内联常量 ——
+   * 内联会在「构建早于 bump」时停留在旧版本，插件于是永远对自己报「有新版本」）；
+   * 查不到一律降级为「不提示」，绝不在界面上冒红条。
+   */
+  async checkUpdate() {
+    return await checkUpdateImpl()
+  }
+
+  /** 列出 memory 目录全部记忆文件（文件名 + 类型 + 描述 + 大小 + 自定义标签 + 是否锁定）。 */
   async listFiles() {
-    const files = await scanMemoryFiles(this.ctx, '')
+    const [files, locked] = await Promise.all([scanMemoryFiles(this.ctx, ''), readLockSet(MEMORY_DIR)])
     return files.map(f => {
       const meta = parseFrontmatter(f.content)
       return {
@@ -388,6 +401,8 @@ export class MemoryGateway extends TypertRemoteService {
         description: meta.description || '',
         size: f.content.length,
         tags: meta.tags,
+        // 锁定状态跟着每条一起给：卡片上的「锁定 / 已锁定」按钮要据此渲染
+        locked: locked.has(nameKey(f.file)),
       }
     })
   }
@@ -616,17 +631,40 @@ export class MemoryGateway extends TypertRemoteService {
    * 复用 `memory/access.js` 的台账与候选计算，与 autodream 引擎跑的是同一份逻辑。
    * 先强制 flush 台账：面板看到的候选不能比引擎少（内存里还压着的那批注入必须算进去）。
    */
+  /**
+   * 上锁 / 解锁一条记忆。锁上的记忆**拒绝归档**（自动与手动都不行）。
+   *
+   * 落点是**状态目录**（`.sage-mem/locked.json`），不写进记忆自己的 frontmatter ——
+   * 理由见 `lib/memory/lock.js` 的头注：frontmatter 会被「自动做梦」重写，锁写在里面
+   * 可能被整理过程擦掉，而锁一丢那条记忆就重新进了自动归档候选（正是这功能要防的事）。
+   */
+  async setLocked(name, locked) {
+    return await setLockedImpl(MEMORY_DIR, name, locked === true)
+  }
+
   async archiveCandidates() {
     await flushAccess(MEMORY_DIR)
-    const [ledger, files] = await Promise.all([readAccessLedger(), scanMemoryFiles(this.ctx, '')])
+    const [ledger, files, locked] = await Promise.all([
+      readAccessLedger(),
+      scanMemoryFiles(this.ctx, ''),
+      readLockSet(MEMORY_DIR),
+    ])
     const cfg = await autodreamConfigSnapshot()
     const thresholds = {
       project: cfg.archiveAfterDaysProject,
       reference: cfg.archiveAfterDaysReference,
       user: cfg.archiveAfterDaysUser,
     }
-    const candidates = pickArchiveCandidates(files, ledger, { thresholds })
-    return { count: candidates.length, candidates, autoArchive: cfg.autoArchive, thresholds }
+    // 锁表交给候选计算：锁上的记忆一个都不选（用户对**单条**记忆说的话优先于阈值）。
+    const candidates = pickArchiveCandidates(files, ledger, { thresholds, locked })
+    return {
+      count: candidates.length,
+      candidates,
+      autoArchive: cfg.autoArchive,
+      thresholds,
+      // 面板要显示「哪些锁着」，所以把锁表也带回去（已按 nameKey 归一）
+      locked: [...locked],
+    }
   }
 
   /**
@@ -784,6 +822,8 @@ markRemote(MemoryGateway, 'listArchived', 'listArchived')
 markRemote(MemoryGateway, 'readArchived', 'readArchived')
 markRemote(MemoryGateway, 'writeArchived', 'writeArchived')
 markRemote(MemoryGateway, 'audit', 'audit')
+markRemote(MemoryGateway, 'checkUpdate', 'checkUpdate')
+markRemote(MemoryGateway, 'setLocked', 'setLocked')
 markRemote(MemoryGateway, 'archiveCandidates', 'archiveCandidates')
 markRemote(MemoryGateway, 'getSettings', 'getSettings')
 markRemote(MemoryGateway, 'setSettings', 'setSettings')

package/lib/memory/access.js

@@ -19,6 +19,7 @@ import { parseFrontmatter } from './frontmatter.js'
 import { writeFileAtomic } from './util.js'
 import { mkdir, readFile, readdir } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
+import { nameKey } from './naming.js'
 
 /** 台账文件：状态根下，与记忆文件分开。 */
 export const ACCESS_LEDGER_FILE = join(STATE_ROOT, 'access.json')
@@ -192,14 +193,18 @@ export function idleDays(f, ledger = {}, now = Date.now()) {
  *
  * @param {Array} files — `scanMemoryFiles` 的结果（**只有根目录**，所以归档区天然不在内）
  * @param {Object} ledger — 访问台账
- * @param {{thresholds?: Object}} opts — 按类型的阈值（天）；缺阈值＝该类型永不候选
+ * @param {{thresholds?: Object, locked?: Set<string>}} opts — 按类型的阈值（天；缺阈值＝该类型永不候选）
+ *        与**锁表**（`lib/memory/lock.js` 的 `readLockSet`，键已按 `nameKey` 归一）
  * @returns {Array<{file:string,type:string,days:number,limit:number,reason:string}>} 按闲置天数降序
  */
 export function pickArchiveCandidates(files, ledger = {}, opts = {}, now = Date.now()) {
   const thresholds = opts.thresholds ?? {}
+  const locked = opts.locked ?? null
   const out = []
   for (const f of files ?? []) {
     if (!f?.file || f.archived === true) continue
+    // 锁定的记忆一个都不选：这是用户对**单条**记忆说的「别动它」，优先于阈值。
+    if (locked && locked.has(nameKey(f.file))) continue
     const type = fileType(f)
     if (NEVER_ARCHIVE_TYPES.has(type)) continue
     // baseline 是「每场会话必读」的那几条：它们本来就不靠检索命中，闲置天数没有意义。

package/lib/memory/archive.js

@@ -18,6 +18,8 @@
 import { ARCHIVE_DIR_NAME, addArchiveMeta, inspectDir, inspectMemoryEntry, localStamp, stripArchiveMeta } from './scan.js'
 import { isReserved, nameKey, safeName } from './naming.js'
 import { writeFileAtomic } from './util.js'
+import { isLocked } from './lock.js'
+import { ensureIndexEntry } from './index-file.js'
 import { mkdir, readFile, stat, unlink } from 'node:fs/promises'
 import { join } from 'node:path'
 
@@ -47,6 +49,13 @@ export async function archiveMemory(memoryDir, name, reason, at = localStamp())
   const gate = checkName(name, 'archive')
   if (!gate.ok) return gate
   const safe = gate.safe
+  /**
+   * 「锁定」优先于一切：锁上的记忆**自动与手动都不许归档**。
+   * 放在最前面判 —— 名字合法之后立刻拒绝，不读目录、不算理由。
+   */
+  if (await isLocked(memoryDir, safe)) {
+    return { ok: false, code: 'locked', error: `sage-mem: locked, refusing to archive: ${safe}（先在界面里解锁）` }
+  }
   const src = join(memoryDir, safe)
   const dst = join(archiveDirOf(memoryDir), safe)
   /**
@@ -118,5 +127,13 @@ export async function restoreMemory(memoryDir, name) {
   const content = await readFile(src, 'utf8')
   await writeFileAtomic(dst, stripArchiveMeta(content))
   await unlink(src)
-  return { ok: true, file: safe }
+  /**
+   * **注册回索引**：移回文件不等于这条记忆又存在了 —— 索引里没有它，
+   * 面板与检索都看不见，体检会报「漏索引」（真实事故见 lib/memory/index-file.js 的头注）。
+   *
+   * 幂等（索引里已有指向它的一行就什么都不做）；索引缺失或写不进去**不算恢复失败** ——
+   * 文件已经回到顶层了，那才是主要结果，索引只是补账。
+   */
+  const indexed = await ensureIndexEntry(memoryDir, safe).catch(() => null)
+  return { ok: true, file: safe, indexed: !!(indexed && indexed.added) }
 }

package/lib/memory/index-file.js

@@ -0,0 +1,61 @@
+/**
+ * 索引（`MEMORY.md`）的**写入侧** —— 只有一件事：确保某条记忆在索引里有一行。
+ *
+ * 为什么要单独一个文件：索引是**用户手写**的东西（「改动记忆时同步改这里」这条就写在
+ * 索引自己的说明段里）。所以这里只做**追加**，绝不重排、绝不删用户已有的行、绝不重建
+ * 整个文件 —— 索引被整份覆盖就等于用户的维护成果没了。
+ *
+ * 起因（2026-10-11 在一次真实使用中确认）：恢复归档记忆时只把文件搬回顶层、
+ * 不补索引，于是顶层有文件、索引里没有 → 体检报「漏索引」。
+ */
+import { readFile, readdir } from 'node:fs/promises'
+import { basename, join } from 'node:path'
+import { parseFrontmatter } from './frontmatter.js'
+import { nameKey } from './naming.js'
+import { writeFileAtomic } from './util.js'
+
+const INDEX_KEY = 'memory.md'
+/** 条目里的描述上限：索引是清单，不是内容堆。 */
+const DESC_MAX = 120
+
+/**
+ * 索引文件的**磁盘真名**（大小写不敏感地找）。
+ * 不假设盘上是 `MEMORY.md` —— 系统盘是 Windows、用户可能就写成了小写。
+ */
+export async function findIndexFile(memoryDir) {
+  const names = await readdir(memoryDir).catch(() => [])
+  return names.find((n) => nameKey(n) === INDEX_KEY) ?? null
+}
+
+/** 索引里有没有指向该文件的条目（`](file.md)` 或 `](file.md#L12)`，大小写不敏感）。 */
+function hasEntry(indexText, name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  return new RegExp(`\\]\\(\\s*${escaped}(?:#[^)]*)?\\s*\\)`, 'i').test(indexText)
+}
+
+/**
+ * 确保索引里有指向 `name` 的一行；已经有就**什么都不做**（幂等）。
+ *
+ * 条目形状与索引自己声明的约定一致：`- [标题](文件.md) — 一句话`。
+ * 标题取 frontmatter 的 `name`（没有就用文件名），描述取 `description`。
+ *
+ * @returns {Promise<{ok:boolean, added:boolean, file?:string, line?:string, error?:string}>}
+ */
+export async function ensureIndexEntry(memoryDir, name) {
+  const indexName = await findIndexFile(memoryDir)
+  // 没有索引是**正常状态**（索引是可选件）：不崩、不建、不当失败。
+  if (!indexName) return { ok: true, added: false, error: 'no-index' }
+  const indexPath = join(memoryDir, indexName)
+  const indexText = await readFile(indexPath, 'utf8').catch(() => '')
+  if (hasEntry(indexText, name)) return { ok: true, added: false }
+
+  const content = await readFile(join(memoryDir, name), 'utf8').catch(() => '')
+  const fm = parseFrontmatter(content)
+  const title = fm.name || basename(name, '.md')
+  const desc = (fm.description || '').trim().slice(0, DESC_MAX)
+  const line = `- [${title}](${name})${desc ? ' — ' + desc : ''}`
+  // 追加到末尾。文件末尾没换行就先补一个，别把新条目粘到上一行的尾巴上。
+  const head = indexText === '' || indexText.endsWith('\n') ? indexText : indexText + '\n'
+  await writeFileAtomic(indexPath, head + line + '\n')
+  return { ok: true, added: true, file: name, line }
+}

package/lib/memory/lock.js

@@ -0,0 +1,68 @@
+/**
+ * 「锁定」—— 让一条记忆拒绝归档。
+ *
+ * 为什么用**状态文件**而不是写进记忆自己的 frontmatter：
+ *   1. frontmatter 是用户的正文，而「自动做梦」会重写它 —— 锁写在里面可能被整理过程擦掉，
+ *      而锁一旦丢失，那条记忆就会重新进入自动归档候选（**正是这个功能要防的事**）
+ *   2. 状态根 `.sage-mem/` 已经是访问台账、快照、回滚点的家，锁放同一层语义一致
+ * 代价要说清楚：锁不在记忆文件里，**跟着文件单独拷贝时不会跟走**。别把它当文件属性。
+ *
+ * 锁表按 `nameKey()` 归一存放：NTFS 不区分大小写，`User_Persona.MD` 与 `user_persona.md`
+ * 是同一个文件 —— 锁必须认得出这一点（与保留名保护同一套判据）。
+ */
+import { mkdir, readFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { nameKey } from './naming.js'
+import { writeFileAtomic } from './util.js'
+
+/** 锁表文件：状态根下，与记忆文件分开。 */
+export function lockFileOf(memoryDir) {
+  return join(dirname(memoryDir), '.sage-mem', 'locked.json')
+}
+
+/**
+ * 读锁表。读不到 / JSON 坏 / 不是对象 / 值不是 `true` → 一律当空表。
+ * **绝不抛**：锁表坏了最坏是「锁没生效」，不该升级成「读不了记忆」。
+ */
+export async function readLockSet(memoryDir) {
+  try {
+    const parsed = JSON.parse(await readFile(lockFileOf(memoryDir), 'utf8'))
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return new Set()
+    const out = new Set()
+    for (const [k, v] of Object.entries(parsed)) {
+      if (v === true) out.add(nameKey(k))
+    }
+    return out
+  } catch {
+    return new Set()
+  }
+}
+
+/** 这条记忆锁上了吗。 */
+export async function isLocked(memoryDir, name) {
+  return (await readLockSet(memoryDir)).has(nameKey(name))
+}
+
+/**
+ * 上锁 / 解锁。
+ *
+ * 读-改-写：两张并发的锁操作理论上会互相覆盖（丢一次锁）。这里**不引入锁**：
+ * 代价是「同时锁两条记忆时可能少一条」，而这远轻于给一个状态文件加一套锁 ——
+ * 重按一次就好，用户看得见结果。
+ */
+export async function setLocked(memoryDir, name, locked) {
+  const key = nameKey(name)
+  const file = lockFileOf(memoryDir)
+  let table = {}
+  try {
+    const parsed = JSON.parse(await readFile(file, 'utf8'))
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) table = parsed
+  } catch {
+    table = {}
+  }
+  if (locked) table[key] = true
+  else delete table[key]
+  await mkdir(dirname(file), { recursive: true })
+  await writeFileAtomic(file, JSON.stringify(table, null, 2) + '\n')
+  return { ok: true, file: name, locked: !!locked }
+}

package/lib/typert.host.js

@@ -49,6 +49,9 @@ const fileSchema = z.object({
 	// strict 模式下 host 多返回的字段会被剥掉，所以「列表页要能按标签筛」这件事
 	// 必须在这里显式声明，否则前端永远拿到 undefined。
 	'tags': z.array(z.string()).readonly(),
+	// 锁定状态（拒绝归档）跟着每条一起给 —— strict 会把没声明的字段剥掉，
+	// 不在这里声明，卡片上的「锁定 / 已锁定」按钮就永远拿到 undefined。
+	'locked': z.boolean().readonly(),
 }).readonly()
 
 const listResultSchema = z.array(fileSchema)
@@ -116,6 +119,16 @@ const archivedWriteResultSchema = z.object({
 }).readonly()
 
 // ── 面板 API（v0.9.0 D1）：体检 / 归档候选 / 设置 / 保留名原样读写 ──────────────
+// 更新检查：只回答「有没有更新的正式版」。失败一律降级为「不提示」（error / rateLimited
+// 只是给日志与调试看的，界面不该因为查版本失败而冒红条）。
+const updateCheckSchema = z.object({
+	'current': z.string().readonly(),
+	'latest': z.string().readonly().nullable(),
+	'updateAvailable': z.boolean().readonly(),
+	'rateLimited': z.boolean().readonly(),
+	'error': z.string().readonly(),
+	'releasesUrl': z.string().readonly(),
+}).readonly()
 // 审计报告：字段面就是 `auditMemoryDir()` 的返回，逐项在这里钉住 —— strict 会把没声明的
 // 字段剥掉，面板看到的清单必须与模型看到的一致。
 const auditItemSchema = z.object({ 'file': z.string().readonly() }).readonly()
@@ -161,6 +174,14 @@ const archiveCandidatesResultSchema = z.object({
 		'reference': z.number().readonly(),
 		'user': z.number().readonly(),
 	}).readonly(),
+	// 锁定的记忆（已按 nameKey 归一）：面板要显示「哪些锁着」
+	'locked': z.array(z.string().readonly()).readonly(),
+}).readonly()
+// 上锁 / 解锁的结果
+const lockResultSchema = z.object({
+	'ok': z.boolean().readonly(),
+	'file': z.string().readonly(),
+	'locked': z.boolean().readonly(),
 }).readonly()
 
 // 设置：limits = 当前**已生效**的值（模块加载时读的），pendingLimits = 待生效值
@@ -528,6 +549,31 @@ export const TYPERT = {
 			result: { mode: 'strict', typeSymbol: 'sage-mem/types#AuditReport', schema: auditReportSchema, create: () => auditReportSchema },
 			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
 		},
+		{
+			// 面板进入时静默查一次；只有「有新版本」才在界面上提醒。
+			id: 'sage-mem#memory/checkUpdate',
+			service: 'memory',
+			namespace: 'memory',
+			method: 'checkUpdate',
+			invocation: { kind: 'direct' },
+			parameters: [],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#UpdateCheck', schema: updateCheckSchema, create: () => updateCheckSchema },
+			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+		},
+		{
+			// 上锁 / 解锁一条记忆：锁上的记忆拒绝归档（自动与手动都不行）。
+			id: 'sage-mem#memory/setLocked',
+			service: 'memory',
+			namespace: 'memory',
+			method: 'setLocked',
+			invocation: { kind: 'direct' },
+			parameters: [
+				{ name: 'name', wire: 'name', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#FileName', schema: fileNameSchema, create: () => fileNameSchema } },
+				{ name: 'locked', wire: 'locked', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#LockFlag', schema: z.boolean().readonly(), create: () => z.boolean().readonly() } },
+			],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#LockResult', schema: lockResultSchema, create: () => lockResultSchema },
+			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+		},
 		{
 			id: 'sage-mem#memory/archiveCandidates',
 			service: 'memory',

package/lib/update.js

@@ -0,0 +1,103 @@
+/**
+ * 版本检查（宿主侧）。
+ *
+ * 为什么放在宿主侧查、而不是界面里 fetch：
+ *   - 跨域与限流都按用户的浏览器出口 IP 算（未认证 60 次/小时），宿主侧可以带
+ *     `GITHUB_TOKEN` 把额度提到 5000 次/小时
+ *   - 界面拿不到进程环境里的凭据，宿主侧拿得到
+ *
+ * ⚠️ **当前版本一律运行时读自己的 `package.json`**，绝不内联常量：
+ * 客户端 bundle 是构建期产物，如果版本号在构建时被写死，那么「先 build 再 bump」
+ * 的发布流程会让插件永远拿旧常量去比最新 release —— 于是它**对自己报「有新版本」**，
+ * 而其实已经是最新的。运行时读文件没有这个时间差。
+ */
+import { readFile } from 'node:fs/promises'
+
+/** 仓库与接口（单一事实源：界面上的「看更新内容」也指向它）。 */
+export const REPO_SLUG = 'gezi-wen/sage-mem'
+export const REPO_URL = `https://github.com/${REPO_SLUG}`
+export const RELEASES_URL = `${REPO_URL}/releases`
+export const RELEASES_LATEST_API = `https://api.github.com/repos/${REPO_SLUG}/releases/latest`
+
+/** 当前安装的版本；读不到就回空串（宁可不提示，也不误报）。 */
+export async function currentVersion() {
+  try {
+    const raw = await readFile(new URL('../package.json', import.meta.url), 'utf8')
+    const pkg = JSON.parse(raw)
+    return typeof pkg?.version === 'string' ? pkg.version : ''
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * 简易版本比较：数字段逐位比，忽略 `v` 前缀与预发布后缀（`-rc.1` 这种不参与）。
+ *
+ * **故意不引 semver 依赖**：这里只回答「有没有更新的正式版」，
+ * 预发布前缀的比较规则（`1.0.0-rc.1 < 1.0.0`）不在这个问题的范围内。
+ * @returns {number} a > b 返回正数，a < b 返回负数，相等返回 0
+ */
+export function compareVersions(a, b) {
+  const parts = (v) =>
+    String(v ?? '')
+      .replace(/^v/i, '')
+      .split('-')[0]
+      .split('.')
+      .map((n) => parseInt(n, 10) || 0)
+  const pa = parts(a)
+  const pb = parts(b)
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0)
+    if (diff !== 0) return diff
+  }
+  return 0
+}
+
+/**
+ * 查有没有新版本。
+ *
+ * 失败一律**降级为「不提示」**，并把原因放在 `error` / `rateLimited` 里 ——
+ * 网络不可达、被限流、仓库还没建 release，都不该在面板上冒一个红条打断人。
+ *
+ * @param {{fetchImpl?: Function, timeoutMs?: number}} [opts] — `fetchImpl` 只为测试注入
+ * @returns {Promise<{current:string, latest:string|null, updateAvailable:boolean, rateLimited:boolean, error:string}>}
+ */
+export async function checkUpdate(opts = {}) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch
+  const current = await currentVersion()
+  const base = { current, latest: null, updateAvailable: false, rateLimited: false, error: '', releasesUrl: RELEASES_URL }
+  if (typeof fetchImpl !== 'function') return { ...base, error: '当前运行时不支持 fetch' }
+
+  // 手动 AbortController + finally 清理：AbortSignal.timeout 的隐式定时器在 Windows 上
+  // 退出时可能触发 libuv 断言（UV_HANDLE_CLOSING）。
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 10000)
+  try {
+    const token = String(process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? '').trim()
+    const res = await fetchImpl(RELEASES_LATEST_API, {
+      headers: {
+        Accept: 'application/vnd.github+json',
+        'User-Agent': 'sage-mem',
+        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+      },
+      redirect: 'follow',
+      signal: controller.signal,
+    })
+    if (res.status === 403 || res.status === 429) {
+      await res.body?.cancel?.().catch?.(() => {})
+      return { ...base, rateLimited: true, error: 'GitHub API 限流' }
+    }
+    if (!res.ok) {
+      await res.body?.cancel?.().catch?.(() => {})
+      return { ...base, error: `GitHub API ${res.status}` }
+    }
+    const data = await res.json().catch(() => undefined)
+    const tag = typeof data?.tag_name === 'string' ? data.tag_name.replace(/^v/i, '') : ''
+    if (!tag) return { ...base, error: 'release 里没有 tag_name' }
+    return { ...base, latest: tag, updateAvailable: current !== '' && compareVersions(tag, current) > 0 }
+  } catch (err) {
+    return { ...base, error: err?.message ?? String(err) }
+  } finally {
+    clearTimeout(timer)
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sage-mem",
   "description": "File-based memory plugin for DeepSeek Harness (DSH) — cross-session memory in plain markdown files, with a memory star-map view, type/tag filtering, retrieval aliases, and an optional autodream pass that consolidates memories on demand or on a schedule — with per-run rollback points, a per-file change declaration (what changed and why), and a separately selectable model for the consolidation pass",
-  "version": "0.9.6",
+  "version": "0.9.9",
   "type": "module",
   "main": "lib/index.js",
   "exports": {