sage-mem 2.6.0 → 2.7.0

package/README.en.md

@@ -12,7 +12,7 @@
 
 **Cross-session memory for DeepSeek Harness — plain markdown files, no database, no worker.**
 
-**Current release: `2.6.0`** — the npm badge above is the dynamic source of truth. **Contract baseline: `1.0.0`** — the first stable release, whose public commitments, the capability boundaries and the list of things it explicitly cannot do are frozen in the
+**Current release: `2.7.0`** — the npm badge above is the dynamic source of truth. **Contract baseline: `1.0.0`** — the first stable release, whose public commitments, the capability boundaries and the list of things it explicitly cannot do are frozen in the
 [frozen contract](https://github.com/gezi-wen/sage-mem/blob/main/docs/1.0.0-contract.md).
 
 If it is useful to you, a Star is the most direct feedback.
@@ -81,10 +81,10 @@ Most memory schemes take the "SQLite + a long-running worker" route: once memori
 
 The UI also carries four more capabilities (all of them optional): the memory management page, type and tag filtering, the timeline (an entries list by default, with an optional star-map view), and audit & archiving.
 
-**Since 1.8.0, memory management is also reachable from the sidebar**: a 「记忆管理」(memory management) icon appears in the sidebar and switches the central panel to this page (with a "back to conversation" control at the top).
-It can be turned off in the settings page under 「记忆管理 → 自动做梦 → 设置」(on by default; applies immediately, no restart);
-**since 1.8.2 the same toggle also lives on the plugin's detail page** (「插件 → sage-mem」card) and applies immediately too;
-**turning it off only removes the sidebar icon — the 「设置 → 记忆管理」 entry always stays**.
+**Since 2.7.0 the interface entry is a three-way choice**: show both (default), sidebar only, or settings only — **at least one entry always stays on**.
+The sidebar entry (1.8.0) switches the central panel to this page with one click (with a "back to conversation" control at the top); the settings entry is 「设置 → 记忆管理」.
+The switch lives in the 「界面入口」 disclosure on the plugin's detail page (「插件 → sage-mem」), and the same options are in the panel under 「自动整理 → 设置」; changes apply immediately, no restart.
+When the host does not support the sidebar slot, "sidebar only" is disabled and the plugin falls back to the settings entry; old settings files migrate automatically (sidebar on → both, off → settings only).
 Since 1.8.2 the plugin also ships its own icon (a golden stack of memory cards) instead of the generic square.
 
 The memory management page's file list also has an **Open memory folder** button: it opens the

package/README.md

@@ -14,7 +14,7 @@
 
 > File-based cross-session memory for DeepSeek Harness — every memory is a plain markdown file you can open, edit and delete. No database, no worker, no port.
 
-**当前发布版本：`2.6.0`** —— 顶部 npm 徽章是动态权威。**契约基线：`1.0.0`** —— 第一个稳定版，公开承诺、能力边界与「明确做不到」的清单冻结在
+**当前发布版本：`2.7.0`** —— 顶部 npm 徽章是动态权威。**契约基线：`1.0.0`** —— 第一个稳定版，公开承诺、能力边界与「明确做不到」的清单冻结在
 [契约冻结](https://github.com/gezi-wen/sage-mem/blob/main/docs/1.0.0-contract.md)。
 
 如果它对你有用，给个 Star 是最直接的反馈。
@@ -83,10 +83,10 @@ sage-mem 补上这一层，做法是：**把该记住的事写成一张张卡片
 
 界面上还有四块能力（都可以不用）：记忆管理页、类型与标签筛选、时间线（默认是条目列表，可切星空视角）、体检与归档。
 
-**1.8.0 起，记忆管理还能从侧栏直接进**：侧栏多一个「记忆管理」图标，点它把中央主区切到本页（页顶有「返回会话」）。
-设置页「记忆管理 → 自动做梦 → 设置」里可以关掉这个入口（默认开，立即生效、不用重启）；
-**1.8.2 起，插件详情页也有同一个开关**（「插件 → sage-mem」那张卡），改完立即生效；
-**关掉只影响侧栏图标，「设置 → 记忆管理」这个入口永远保留**。
+**从 2.7.0 起，记忆管理的界面入口是三选一**：两个都显示（默认）/ 只显示侧栏 / 只显示设置页 —— **至少保留一个**。
+侧栏入口（1.8.0）点一下就把中央主区切到本页（页顶有「返回会话」）；设置页入口是「设置 → 记忆管理」。
+开关在「插件 → sage-mem」的「界面入口」折叠行里，面板「自动整理 → 设置」里也有同一组选项；改完立即生效、不用重启。
+宿主不支持侧栏时「只显示侧栏」自动置灰并回落到设置页；旧设置文件里的「侧栏开 / 关」会按 true → 两个都显示、false → 只显示设置页迁移。
 从 1.8.2 开始，sage-mem 在插件列表里有了自己的图标（金色记忆卡片），不再是默认的通用方图标。
 
 记忆管理页的「文件列表」头部还有一个「打开记忆文件夹」按钮：用系统文件管理器打开当前记忆目录

package/lib/client.js

@@ -2686,14 +2686,20 @@ const StarmapRuntime = (function (require, _react) {
 			".smem-page-top{display:flex;align-items:center;}",
 			".smem-page-back{display:inline-flex;align-items:center;gap:5px;border:0;background:transparent;color:var(--dsw-alias-label-secondary);font-family:inherit;font-size:12.5px;line-height:1.4;padding:3px 6px 3px 2px;border-radius:6px;cursor:pointer;}",
 			".smem-page-back:hover{color:var(--dsw-alias-label-primary,#1f2329);background:var(--dsw-alias-bg-layer-2);}",
-			// ── 1.8.2：插件详情页的「侧栏入口」卡片 ──
+			// ── 1.8.2 / 2.7.0：插件详情页的「界面入口」折叠行 ──
 			// 融入宿主插件页：标题 13px/600、说明 12px 次要色，圆角与分隔线只用宿主 token。
-			// 不抄设置页的大标题 —— 这一块是插件页里的一张紧凑卡片，不是另一个 settings section。
+			// 2.7.0 起默认收起：收起时只露标题 + 当前状态，展开才是三选一。
 			".smem-plugin-card{display:flex;flex-direction:column;gap:8px;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;padding:12px 14px;background:var(--dsw-alias-bg-layer-1,#fafbfc);box-sizing:border-box;}",
-			".smem-plugin-card-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap;}",
+			".smem-entry-summary{display:flex;align-items:center;gap:8px;width:100%;border:0;background:transparent;padding:0;margin:0;font-family:inherit;text-align:left;cursor:pointer;color:inherit;}",
+			".smem-entry-summary:hover .smem-plugin-card-title{color:var(--dsw-alias-brand-primary,#4d76e6);}",
+			".smem-entry-summary:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#4d76e6);outline-offset:3px;border-radius:6px;}",
+			".smem-entry-chevron{flex:none;margin-left:auto;color:var(--dsw-alias-label-tertiary,#8b93a1);transition:transform 180ms cubic-bezier(.2,0,0,1);}",
+			".smem-entry-body{display:flex;flex-direction:column;gap:8px;padding-top:2px;}",
+			".smem-entry-opts{display:flex;flex-direction:column;gap:6px;}",
+			".smem-entry-opt{font-size:12.5px;line-height:1.5;padding:1px 0;}",
+			".smem-entry-opt input:disabled{cursor:not-allowed;opacity:.55;}",
 			".smem-plugin-card-title{font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary,#1f2430);line-height:1.4;}",
 			".smem-plugin-card-status{font-size:12px;color:var(--dsw-alias-label-secondary,#6b7280);line-height:1.4;}",
-			".smem-plugin-card-check{font-size:12.5px;}",
 			".smem-plugin-card-note{font-size:12px;line-height:1.55;color:var(--dsw-alias-label-secondary,#6b7280);}",
 			".smem-plugin-card-err{font-size:12px;line-height:1.5;color:var(--dsw-alias-state-error-primary,#ef4444);overflow-wrap:anywhere;}",
 			// ── 底部一行仓库链接（引流，不抢视线）──
@@ -4188,13 +4194,18 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"star.dismiss": "不再显示（下次打开 DSH 还会出现）",
 			"star.aria": "在 GitHub 上给 gezi-wen/sage-mem 点一颗星",
 
-			"pluginCard.saveFailed": "保存失败（未知原因）",
-			"pluginCard.noSetSettings": "宿主侧还没有 setSettings 接口（插件版本较旧）",
-			"pluginCard.title": "侧栏入口",
-			"pluginCard.on": "已开启",
-			"pluginCard.off": "已关闭",
-			"pluginCard.label": "在侧栏显示「记忆管理」入口",
-			"pluginCard.note": "默认开启；改动立即生效，不需要重启。关闭后「设置 → 记忆管理」入口仍然保留。",
+			"entry.title": "界面入口",
+			"entry.subtitle": "控制「记忆管理」在界面中的入口。至少保留一个。",
+			"entry.opt.both": "两个都显示",
+			"entry.opt.sidebar": "只显示侧栏",
+			"entry.opt.settings": "只显示设置页",
+			"entry.note": "改动立即生效，不需要重启。",
+			"entry.sidebarUnsupported": "当前宿主不支持侧栏入口。",
+			"entry.degraded": "当前宿主不支持侧栏入口，已临时按「只显示设置页」显示。",
+			"entry.legacyHost": "宿主模块还是旧版本，重启 DSH 后可选「只显示侧栏」。",
+			"entry.notice.saved": "界面入口已更新。",
+			"entry.err.noSetSettings": "宿主侧还没有 setSettings 接口（插件版本较旧）",
+			"entry.err.saveFailed": "保存失败（未知原因）",
 
 			"error.remote": "remote 调用失败",
 			"error.listFiles": "listFiles RPC 失败: {message}",
@@ -4389,11 +4400,6 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"ad.last.retried": " · 零正文重试 {count} 次后补齐",
 			"ad.last.continuations": " · 续写 {count} 轮",
 			"ad.last.report": " · 报告 {name}",
-			"ad.sidebar.title": "侧栏入口",
-			"ad.sidebar.on": "已开启",
-			"ad.sidebar.off": "已关闭",
-			"ad.sidebar.note": "在 DSH 侧栏显示「记忆管理」图标，点它把中央主区切到本页。默认开启；关闭后「设置 → 记忆管理」这个入口仍然保留。改动立即生效，不需要重启。",
-			"ad.sidebar.label": "在侧栏显示「记忆管理」入口",
 			"ad.limits.title": "记忆注入参数",
 			"ad.limits.pending": "有改动待生效",
 			"ad.limits.restartWarn": "⚠ 这些值在 DSH 启动时就固化了 —— 要重启 DSH 才生效。下面每行都写清「当前 → 重启后」。",
@@ -4493,8 +4499,6 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"ad.err.notSaved": "没保存 —— {detail}",
 			"ad.err.saveRejected": "保存被拒绝",
 			"ad.notice.limitsSaved": "已保存 —— 需重启 DSH 才生效",
-			"ad.notice.sidebarOn": "侧栏入口已开启（立即生效）",
-			"ad.notice.sidebarOff": "侧栏入口已关闭（设置页入口仍在）",
 			"ad.err.reservedRejected": "名单被拒绝",
 			"ad.notice.reservedSaved": "保留名名单已保存 —— 需重启 DSH 才生效",
 			"ad.err.reservedNeedName": "先写一个文件名，例如 project_notes.md",
@@ -4697,13 +4701,18 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"star.dismiss": "Hide until next launch",
 			"star.aria": "Star gezi-wen/sage-mem on GitHub",
 
-			"pluginCard.saveFailed": "Save failed (unknown reason)",
-			"pluginCard.noSetSettings": "The host has no setSettings API yet (older plugin version)",
-			"pluginCard.title": "Sidebar entry",
-			"pluginCard.on": "On",
-			"pluginCard.off": "Off",
-			"pluginCard.label": "Show the “Memory management” entry in the sidebar",
-			"pluginCard.note": "On by default; changes take effect immediately, no restart needed. Turning it off keeps the Settings → Memory management entry.",
+			"entry.title": "Interface entries",
+			"entry.subtitle": "Choose where Memory management appears. At least one entry stays on.",
+			"entry.opt.both": "Show both",
+			"entry.opt.sidebar": "Sidebar only",
+			"entry.opt.settings": "Settings only",
+			"entry.note": "Changes take effect immediately; no restart needed.",
+			"entry.sidebarUnsupported": "This host does not support the sidebar entry.",
+			"entry.degraded": "The sidebar entry is unavailable on this host, so the Settings entry is shown instead.",
+			"entry.legacyHost": "The host module is still the old version; restart DSH to choose Sidebar only.",
+			"entry.notice.saved": "Interface entries updated.",
+			"entry.err.noSetSettings": "The host has no setSettings API yet (older plugin version)",
+			"entry.err.saveFailed": "Save failed (unknown reason)",
 
 			"error.remote": "remote call failed",
 			"error.listFiles": "listFiles RPC failed: {message}",
@@ -4896,11 +4905,6 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"ad.last.retried": " · completed after {count} zero-body retries",
 			"ad.last.continuations": " · {count} continuation rounds",
 			"ad.last.report": " · report {name}",
-			"ad.sidebar.title": "Sidebar entry",
-			"ad.sidebar.on": "On",
-			"ad.sidebar.off": "Off",
-			"ad.sidebar.note": "Show the “Memory management” icon in the DSH sidebar; clicking it switches the main area to this page. On by default; turning it off keeps the Settings → Memory management entry. Changes take effect immediately, no restart needed.",
-			"ad.sidebar.label": "Show the “Memory management” entry in the sidebar",
 			"ad.limits.title": "Injection limits",
 			"ad.limits.pending": "changes pending",
 			"ad.limits.restartWarn": "⚠ These values are fixed at DSH startup — restart DSH for them to apply. Each row below shows “current → after restart”.",
@@ -5000,8 +5004,6 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"ad.err.notSaved": "Not saved — {detail}",
 			"ad.err.saveRejected": "Save rejected",
 			"ad.notice.limitsSaved": "Saved — restart DSH for it to take effect",
-			"ad.notice.sidebarOn": "Sidebar entry enabled (takes effect immediately)",
-			"ad.notice.sidebarOff": "Sidebar entry disabled (the Settings entry remains)",
 			"ad.err.reservedRejected": "Reserved-name list rejected",
 			"ad.notice.reservedSaved": "Reserved-name list saved — restart DSH for it to take effect",
 			"ad.err.reservedNeedName": "Enter a file name first, e.g. project_notes.md",
@@ -5494,9 +5496,9 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			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 sReservedNew = react.useState(""); const reservedNew = sReservedNew[0], setReservedNew = sReservedNew[1];
-			// ── 1.8.0 侧栏入口开关（客户端行为：改完立刻生效，不需要重启）──
-			const sSidebarBusy = react.useState(false); const sidebarBusy = sSidebarBusy[0], setSidebarBusy = sSidebarBusy[1];
-			const sSidebarErr = react.useState(""); const sidebarErr = sSidebarErr[0], setSidebarErr = sSidebarErr[1];
+			// ── 2.7.0 界面入口三选一（客户端行为：改完立刻生效，不需要重启）──
+			const sEntryBusy = react.useState(false); const entryBusy = sEntryBusy[0], setEntryBusy = sEntryBusy[1];
+			const sEntryErr = react.useState(""); const entryErr = sEntryErr[0], setEntryErr = sEntryErr[1];
 
 			// 派生量放在 effect 之前：下面几个 effect 的依赖数组要在渲染期就能取到值。
 			const c = cfg || {};
@@ -5511,8 +5513,11 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			const fixedReserved = ((memSet && memSet.reserved) || []).filter(function (n) {
 				return extraLower.indexOf(String(n).toLowerCase()) < 0;
 			});
-			// 默认开：宿主没回 ui 字段（旧版本）或值不是布尔，都按「开」显示。
-			const sidebarEntryOn = !(memSet && memSet.ui && memSet.ui.sidebarEntry === false);
+			// 入口模式：新字段优先，旧 sidebarEntry 兜底；坏值 / 旧宿主一律按「两个都显示」。
+			// 存了 sidebar 但当前宿主不支持侧栏时，界面按 settings 显示并给一条降级提示。
+			const entryModeValue = entryModeFromSettings(memSet);
+			const entryShown = entryModeValue === "sidebar" && !sidebarEntryAvailable() ? "settings" : entryModeValue;
+			const entryIsDegraded = entryModeValue === "sidebar" && !sidebarEntryAvailable();
 
 			react.useEffect(function () {
 				if (!remote) { setErr(t("ad.err.remoteUnavailable")); return undefined; }
@@ -5644,28 +5649,29 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			}
 
 			/**
-			 * 侧栏入口开关（1.8.0）。
+			 * 界面入口三选一（2.7.0）。
 			 *
-			 * 顺序是「先写设置、成功后再动槽位」：设置没落盘就不该让界面先变一个样。
-			 * 失败只报错、不改任何东西 —— checkbox 的勾选状态由 memSet 派生，于是自动回到原值。
-			 * 成功后调 `setSidebarEntry`：**立即**增删侧栏槽位，不刷新、不重启。
+			 * 顺序仍是「先写设置、成功后再动槽位」：设置没落盘就不该让界面先变一个样。
+			 * 失败只报错、不改任何东西 —— 选项由 memSet 派生，于是自动回到原值。
+			 * 成功后 saveEntryMode 内部会调 applyEntryMode：**立即**增删槽位，不刷新、不重启。
 			 */
-			function saveSidebarEntry(next) {
+			function saveEntry(next) {
 				if (!memRemote || typeof memRemote.setSettings !== "function") {
-					setSidebarErr(t("ad.err.noSetSettings"));
+					setEntryErr(t("entry.err.noSetSettings"));
 					return;
 				}
-				if (sidebarBusy) return;
-				setSidebarBusy(true); setSidebarErr(""); setNotice("");
-				Promise.resolve(memRemote.setSettings({ ui: { sidebarEntry: !!next } })).then(function (out) {
-					setSidebarBusy(false);
-					// 与 saveLimits 同款：setSettings 是 {ok, settings, restartRequired} 形状，不要过 unwrap。
-					if (out && out.ok === false) { setSidebarErr(out.error || t("ad.err.saveRejected")); return; }
-					if (out && out.settings) setMemSet(out.settings);
+				if (entryBusy) return;
+				setEntryBusy(true); setEntryErr(""); setNotice("");
+				saveEntryMode(memRemote, next).then(function (out) {
+					setEntryBusy(false);
+					if (!out || out.ok === false) {
+						setEntryErr((out && out.error) || t("ad.err.saveRejected"));
+						return;
+					}
+					if (out.settings) setMemSet(out.settings);
 					else loadMemSettings();
-					setSidebarEntry(!!next);
-					setNotice(!!next ? t("ad.notice.sidebarOn") : t("ad.notice.sidebarOff"));
-				}, function (e) { setSidebarBusy(false); setSidebarErr(detail(e)); });
+					setNotice(t("entry.notice.saved"));
+				}, function (e) { setEntryBusy(false); setEntryErr(detail(e)); });
 			}
 
 			/**
@@ -5958,24 +5964,24 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				]),
 				]) : null,
 				segOf === "settings" ? h("div", { key: "seg-set" }, [
-				// 1.8.0：侧栏入口开关。默认开；关掉只影响侧栏那个图标，
-				// 「设置 → 记忆管理」这个入口永远在（它注册在 80-apply，和这个开关无关）。
-				h("div", { className: "smem-autodream-sec", key: "sidebar-entry" }, [
+				// 2.7.0：界面入口三选一。至少保留一个（三选一从类型上就排除了「都不显示」）。
+				// 这里与插件详情页共用同一个 EntryChooser 与 applyEntryMode。
+				h("div", { className: "smem-autodream-sec", key: "entry" }, [
 					h("div", { className: "smem-autodream-row", key: "h" }, [
-						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("ad.sidebar.title")),
-						h("span", { className: "smem-status", key: "s" }, sidebarEntryOn ? t("ad.sidebar.on") : t("ad.sidebar.off")),
-					]),
-					h("div", { className: "smem-autodream-note", key: "n" }, t("ad.sidebar.note")),
-					h("label", { className: "smem-check", key: "row" }, [
-						h("input", {
-							type: "checkbox", key: "c",
-							checked: sidebarEntryOn,
-							disabled: sidebarBusy,
-							onChange: function (e) { saveSidebarEntry(!!(e.target && e.target.checked)); },
-						}),
-						h("span", { key: "l" }, t("ad.sidebar.label")),
+						h("span", { key: "t", style: { fontWeight: "600", fontSize: "12.5px" } }, t("entry.title")),
+						h("span", { className: "smem-status", key: "s" }, entryStatusLabel(entryShown)),
 					]),
-					sidebarErr ? h("div", { className: "smem-autodream-note smem-ad-warn", key: "err" }, sidebarErr) : null,
+					h("div", { className: "smem-autodream-note", key: "n" }, t("entry.subtitle")),
+					h(EntryChooser, {
+						key: "opts", mode: entryShown, busy: entryBusy,
+						sidebarOk: sidebarEntryAvailable(), modernApi: entryApiModern,
+						onPick: saveEntry,
+					}),
+					(entryIsDegraded || entryApiModern === false)
+						? h("div", { className: "smem-autodream-note smem-ad-warn", key: "deg" },
+							t(entryApiModern === false ? "entry.legacyHost" : "entry.degraded"))
+						: null,
+					entryErr ? h("div", { className: "smem-autodream-note smem-ad-warn", key: "err" }, entryErr) : null,
 				]),
 				// 自动归档那一段（三档策略 + 三个阈值）**已挪到「自动归档」页签**（v0.9.9）：
 				// 归档是确定性规则、不调模型，和这一页的「让模型整理」不是一件事；
@@ -8128,7 +8134,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 
 		/** 卡片里的错误文案：remote 可能 reject 一个字符串 / 对象 / Error，尽量展开成人话。 */
 		function pluginCardErr(e) {
-			if (!e) return t("pluginCard.saveFailed");
+			if (!e) return t("entry.err.saveFailed");
 			if (e instanceof Error) return e.message || String(e);
 			try {
 				const s = JSON.stringify(e);
@@ -8154,20 +8160,16 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			const ctx = props && props.ctx;
 			// 必须走 stableRemote：真实宿主里 ctx.get() 每次返回新对象，进依赖数组会无限重跑。
 			const remote = stableRemote(ctx, "remote.memory");
-			const sOn = react.useState(true); const on = sOn[0], setOn = sOn[1];
+			const sOpen = react.useState(false); const open = sOpen[0], setOpen = sOpen[1];
+			const sMode = react.useState("both"); const mode = sMode[0], setMode = sMode[1];
 			const sBusy = react.useState(false); const busy = sBusy[0], setBusy = sBusy[1];
 			const sErr = react.useState(""); const err = sErr[0], setErr = sErr[1];
 
 			react.useEffect(function () {
-				if (!remote || typeof remote.getSettings !== "function") return undefined;
 				let alive = true;
-				Promise.resolve(remote.getSettings()).then(function (out) {
-					if (!alive) return;
-					const loaded = unwrap(out) || {};
-					// 旧宿主没有 ui 字段 / 值不是布尔 → 保持默认「开」，不弹错、不阻塞界面。
-					if (loaded.ui && typeof loaded.ui.sidebarEntry === "boolean") setOn(loaded.ui.sidebarEntry);
-				}, function () {
-					// 读设置失败也按「开」显示：这里只是插件页的一张卡片，不该因为它报红。
+				readEntrySettings(remote).then(function (loaded) {
+					if (!alive || !loaded) return;
+					setMode(entryDisplayMode());
 				});
 				return function () { alive = false; };
 			}, [remote]);
@@ -8177,25 +8179,15 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 
 			function toggle(next) {
 				if (busy) return;
-				if (!remote || typeof remote.setSettings !== "function") {
-					setErr(t("pluginCard.noSetSettings"));
-					return;
-				}
 				setBusy(true); setErr("");
-				Promise.resolve(remote.setSettings({ ui: { sidebarEntry: !!next } })).then(function (out) {
+				// saveEntryMode 负责「先写设置、成功后再动槽位」；失败时界面由服务端返回值派生。
+				saveEntryMode(remote, next).then(function (out) {
 					setBusy(false);
-					// setSettings 是 { ok, settings, restartRequired } 形状，不要过 unwrap。
-					if (out && out.ok === false) {
-						setErr(out.error || t("error.saveRejected"));
+					if (!out || out.ok === false) {
+						setErr((out && out.error) || t("entry.err.saveFailed"));
 						return;
 					}
-					const settings = out && out.settings ? out.settings : null;
-					const applied = settings && settings.ui && typeof settings.ui.sidebarEntry === "boolean"
-						? settings.ui.sidebarEntry
-						: !!next;
-					setOn(applied);
-					// 写盘成功之后才动槽位：设置没落盘时界面不该先变一个样。
-					setSidebarEntry(!!next);
+					setMode(entryDisplayMode());
 				}, function (e) {
 					setBusy(false);
 					setErr(pluginCardErr(e));
@@ -8203,22 +8195,36 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			}
 
 			return h("div", { className: "smem-plugin-card" }, [
-				h("div", { className: "smem-plugin-card-head", key: "h" }, [
-					h("span", { className: "smem-plugin-card-title", key: "t" }, t("pluginCard.title")),
-					h("span", { className: "smem-plugin-card-status", key: "s" }, on ? t("pluginCard.on") : t("pluginCard.off")),
+				h("button", {
+					type: "button", className: "smem-entry-summary", key: "sum",
+					"aria-expanded": open ? "true" : "false",
+					onClick: function () { setOpen(!open); },
+				}, [
+					h("span", { className: "smem-plugin-card-title", key: "t" }, t("entry.title")),
+					h("span", { className: "smem-plugin-card-status", key: "s" }, entryStatusLabel(mode)),
+					h("svg", {
+						key: "i", className: "smem-entry-chevron", width: 14, height: 14,
+						viewBox: "0 0 16 16", fill: "none", "aria-hidden": "true",
+						style: { transform: open ? "rotate(180deg)" : "rotate(0deg)" },
+					}, h("path", {
+						d: "M4 6.5 8 10.5 12 6.5", stroke: "currentColor", strokeWidth: "1.6",
+						strokeLinecap: "round", strokeLinejoin: "round",
+					})),
 				]),
-				h("label", { className: "smem-check smem-plugin-card-check", key: "row" }, [
-					h("input", {
-						type: "checkbox", key: "c",
-						checked: on,
-						disabled: busy,
-						onChange: function (e) { toggle(!!(e.target && e.target.checked)); },
+				open ? h("div", { className: "smem-entry-body", key: "body" }, [
+					h("div", { className: "smem-plugin-card-note", key: "sub" }, t("entry.subtitle")),
+					h(EntryChooser, {
+						key: "opts", mode: mode, busy: busy,
+						sidebarOk: sidebarEntryAvailable(), modernApi: entryApiModern,
+						onPick: toggle,
 					}),
-					h("span", { key: "l" }, t("pluginCard.label")),
-				]),
-				h("div", { className: "smem-plugin-card-note", key: "n" },
-					t("pluginCard.note")),
-				err ? h("div", { className: "smem-plugin-card-err", key: "e" }, err) : null,
+					h("div", { className: "smem-plugin-card-note", key: "note" }, t("entry.note")),
+					(entryDegraded() || entryApiModern === false)
+						? h("div", { className: "smem-plugin-card-note smem-ad-warn", key: "deg" },
+							t(entryApiModern === false ? "entry.legacyHost" : "entry.degraded"))
+						: null,
+					err ? h("div", { className: "smem-plugin-card-err", key: "e" }, err) : null,
+				]) : null,
 			]);
 		}
 
@@ -8257,28 +8263,44 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			]);
 		}
 
-		/** 注册两个槽位（幂等：已经注册就什么都不做）。 */
+		/**
+		 * 注册两个槽位（幂等：已经注册就什么都不做）。
+		 *
+		 * 2.7.0：返回布尔值 —— 侧栏是可选入口，旧宿主没有 sidebar.panellist 时
+		 * inject 会抛错。这里必须自己接住并**反序清理**已经注册成功的槽位，
+		 * 否则会留下「侧栏条目录入了、main 却没注册」的半状态。
+		 */
 		function registerSidebarEntry() {
-			if (sidebarDispose !== null || !sidebarCtx) return true;
+			if (sidebarDispose !== null) return true;
+			if (!sidebarCtx) return false;
 			const ctx = sidebarCtx;
 			const handles = [];
-			// 侧栏 list 槽：只给图标与 label，按钮由宿主自己画。
-			handles.push(ctx.slots.inject("sidebar.panellist", function () {
-				return ctx.slots.register({
-					name: "sidebar.panellist",
-					id: SIDEBAR_ENTRY_ID,
-					order: 20,
-					label: () => t("sidebar.label"),
-				}, SidebarEntryIcon);
-			}));
-			// 中央主区 keyed 槽：key 与侧栏 id 相同；inject 面把「返回会话」交给页面组件。
-			handles.push(ctx.slots.inject("main", function () {
-				return ctx.slots.register({
-					name: "main",
-					key: SIDEBAR_ENTRY_ID,
-					inject: function () { return { backToConversation: backToConversation }; },
-				}, MemoryPanelPage);
-			}));
+			try {
+				// 侧栏 list 槽：只给图标与 label，按钮由宿主自己画。
+				handles.push(ctx.slots.inject("sidebar.panellist", function () {
+					return ctx.slots.register({
+						name: "sidebar.panellist",
+						id: SIDEBAR_ENTRY_ID,
+						order: 20,
+						label: () => t("sidebar.label"),
+					}, SidebarEntryIcon);
+				}));
+				// 中央主区 keyed 槽：key 与侧栏 id 相同；inject 面把「返回会话」交给页面组件。
+				handles.push(ctx.slots.inject("main", function () {
+					return ctx.slots.register({
+						name: "main",
+						key: SIDEBAR_ENTRY_ID,
+						inject: function () { return { backToConversation: backToConversation }; },
+					}, MemoryPanelPage);
+				}));
+			} catch (e) {
+				for (let i = handles.length - 1; i >= 0; i--) {
+					const dispose = handles[i];
+					if (typeof dispose !== "function") continue;
+					try { dispose(); } catch (inner) { /* 清理失败不掩盖原始错误 */ }
+				}
+				return false;
+			}
 			sidebarDispose = handles;
 			return true;
 		}
@@ -8302,6 +8324,255 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			}
 			return true;
 		}
+		// ── 界面入口三选一（2.7.0）──────────────────────────────────────────
+		// 两个入口不是重复：设置页那个是所有宿主版本都有的保底，侧栏那个是可选、
+		// 用户还能在插件详情页关掉。所以「只留一个」必须是**用户选择**，而不是
+		// 默认删掉一个；三选一从类型上就保证不会出现「一个入口都没有」。
+		//
+		// 这一分片负责三件事：
+		//   1. 把服务端的 ui.entry / 旧 ui.sidebarEntry 归一成一个模式；
+		//   2. 按「宿主实际能力」解析出该注册哪一侧（侧栏槽 / 设置页 section）；
+		//   3. 提供两个控制面共用的 EntryChooser（面板 60 与插件页 76 都渲染它）。
+		//
+		// 旧接口（stale host：客户端已更新、宿主模块还是 2.6.0）没有 ui.entry，
+		// 这时只能表达「侧栏开 / 关」，所以「只显示侧栏」置灰，保存退回 sidebarEntry。
+
+		/** 三个合法模式；顺序就是界面里的顺序。 */
+		const ENTRY_MODES = ["both", "sidebar", "settings"];
+
+		/** 当前存储值（canonical）；apply 时从 getSettings 读入。 */
+		let entryMode = "both";
+		/** 宿主是否认识 ui.entry；false = stale host，只能写 sidebarEntry。 */
+		let entryApiModern = true;
+		/** 侧栏槽能力：null = 还没探测，true / false = 探测结果。 */
+		let sidebarSupported = null;
+		/** 设置页 section 能力：null = 还没注册过，true / false = 结果。 */
+		let settingsSupported = null;
+		/** settings.section 的注销句柄（null = 当前没注册）。 */
+		let settingsSectionDispose = null;
+
+		/** 合法模式原样返回，其余（含旧布尔）交给调用方回落。 */
+		function normalizeEntryMode(value) {
+			return ENTRY_MODES.indexOf(value) >= 0 ? value : null;
+		}
+
+		/** 从 getSettings 返回值里取模式：新字段优先，旧字段按 true→both / false→settings。 */
+		function entryModeFromSettings(settings) {
+			const ui = settings && settings.ui;
+			const next = normalizeEntryMode(ui && ui.entry);
+			if (next) return next;
+			if (ui && typeof ui.sidebarEntry === "boolean") return ui.sidebarEntry ? "both" : "settings";
+			return "both";
+		}
+
+		/** 宿主模块是不是 2.7.0：有 ui.entry 才算认识三选一。 */
+		function hasModernEntryApi(settings) {
+			return !!(settings && settings.ui && normalizeEntryMode(settings.ui.entry));
+		}
+
+		/** 选项文案（三处共用：折叠行状态、面板状态、radio label）。 */
+		function entryStatusLabel(mode) {
+			return t(mode === "sidebar" ? "entry.opt.sidebar" : mode === "settings" ? "entry.opt.settings" : "entry.opt.both");
+		}
+
+		/**
+		 * 某宿主上「实际会显示哪一个」。
+		 *
+		 * - 存 sidebar 但侧栏不可用 → 回落 settings（绝不两个都不显示）；
+		 * - 存 settings 但设置页不可用 → 回落 sidebar；
+		 * - 两个都不可用（极旧宿主）→ 交给插件页卡片兜底，这里不抛错。
+		 */
+		function resolveEntryVisibility(mode, support) {
+			const sidebarOk = support.sidebar !== false;
+			const settingsOk = support.settings !== false;
+			if (mode === "sidebar") {
+				if (sidebarOk) return { sidebar: true, settings: false };
+				return { sidebar: false, settings: settingsOk };
+			}
+			if (mode === "settings") {
+				if (settingsOk) return { sidebar: false, settings: true };
+				return { sidebar: sidebarOk, settings: false };
+			}
+			return { sidebar: sidebarOk, settings: settingsOk };
+		}
+
+		/** 界面上展示的模式：降级时把 sidebar 显示成 settings，避免控件与实际不符。 */
+		function entryDisplayMode() {
+			if (entryMode === "sidebar" && (sidebarSupported === false || entryApiModern === false)) return "settings";
+			return entryMode;
+		}
+
+		/** 降级提示是否要出现（存了 sidebar、当前宿主却显示设置页）。 */
+		function entryDegraded() {
+			return entryMode === "sidebar" && (sidebarSupported === false || entryApiModern === false);
+		}
+
+		/** 「只显示侧栏」这一项能不能选：宿主支持侧栏，且认识 ui.entry。 */
+		function sidebarEntryAvailable() {
+			return sidebarSupported !== false && entryApiModern !== false;
+		}
+
+		/** 探测侧栏槽能力：真实注册一次，失败时 registerSidebarEntry 自己清干净半注册。 */
+		function detectSidebarSupport() {
+			if (sidebarSupported !== null) return sidebarSupported;
+			sidebarSupported = !!registerSidebarEntry();
+			return sidebarSupported;
+		}
+
+		/** 注册设置页 section（幂等）。失败返回 false —— 旧外壳 / 没有设置面的宿主。 */
+		function registerSettingsSection() {
+			if (settingsSectionDispose !== null) return true;
+			if (!sidebarCtx) return false;
+			const ctx = sidebarCtx;
+			try {
+				settingsSectionDispose = ctx.slots.inject("settings.section", function () {
+					return ctx.slots.register({
+						name: "settings.section",
+						id: "sage-mem",
+						order: 20,
+						label: function () { return t("section.label"); },
+						// 声明「记忆星图」子槽（沿用 1.8.0 的契约）：sage-starmap 之类的
+						// 第三方插件向它注入视图。⚠️ 现状：Section 还没有调用 renderSlot，
+						// 所以这个子槽目前只声明、不渲染（2.7.0 未改；渲染它是独立事项）。
+						// 保留声明是为了不破坏第三方插件的注入面。
+						children: { "settings.memory.starmap": { kind: "list", scope: "root" } },
+					}, function (props) {
+						return react.createElement(Section, { ...props, ctx: ctx });
+					});
+				});
+				return true;
+			} catch (e) {
+				settingsSectionDispose = null;
+				return false;
+			}
+		}
+
+		/** 注销设置页 section（反序不需要：只有一个 inject 句柄）。 */
+		function disposeSettingsSection() {
+			const stop = settingsSectionDispose;
+			settingsSectionDispose = null;
+			if (typeof stop !== "function") return;
+			try { stop(); } catch (e) { /* 注销失败不能把设置卡死在「已注销」状态 */ }
+		}
+
+		/**
+		 * 立即应用一个入口模式（改完槽位就变，不需要刷新）。
+		 *
+		 * 顺序：探测侧栏 → 解析可见性 → 按需注册 / 注销两侧。
+		 * 设置页注册失败而侧栏又被要求隐藏时，强制把侧栏放回来 —— 这是最后一道门。
+		 */
+		function applyEntryMode(mode) {
+			entryMode = normalizeEntryMode(mode) || "both";
+			const sidebarOk = detectSidebarSupport();
+			const visible = resolveEntryVisibility(entryMode, { sidebar: sidebarOk, settings: settingsSupported });
+
+			if (visible.sidebar) {
+				if (!registerSidebarEntry()) {
+					sidebarSupported = false;
+					visible.sidebar = false;
+				}
+			} else {
+				setSidebarEntry(false);
+			}
+
+			if (visible.settings) {
+				settingsSupported = registerSettingsSection();
+				if (!settingsSupported && !visible.sidebar) {
+					if (registerSidebarEntry()) {
+						sidebarSupported = true;
+						visible.sidebar = true;
+					}
+				}
+			} else {
+				disposeSettingsSection();
+			}
+
+			return {
+				mode: entryMode,
+				sidebar: visible.sidebar,
+				settings: visible.settings,
+				sidebarOk: sidebarSupported,
+				settingsOk: settingsSupported,
+			};
+		}
+
+		/**
+		 * 保存一个入口模式：先写设置、成功后再动槽位。
+		 *
+		 * stale host 上没有 ui.entry，退回旧写法 sidebarEntry（true = 两个都显示，
+		 * false = 只显示设置页）；若宿主真的拒绝了 entry，也自动重试一次旧写法。
+		 */
+		function saveEntryMode(remote, mode) {
+			const next = normalizeEntryMode(mode) || "both";
+			const writeModern = function () {
+				return Promise.resolve(remote.setSettings({ ui: { entry: next } }));
+			};
+			const writeLegacy = function () {
+				return Promise.resolve(remote.setSettings({ ui: { sidebarEntry: next !== "settings" } }));
+			};
+			const finish = function (out, retried) {
+				if (out && out.ok === false) {
+					// stale host 的报错形如 "unknown ui setting: entry"：自动退回旧写法再试一次。
+					if (!retried && entryApiModern !== false && /unknown ui setting/i.test(String(out.error || ""))) {
+						entryApiModern = false;
+						return writeLegacy().then(function (legacyOut) { return finish(legacyOut, true); });
+					}
+					return { ok: false, error: out.error || t("ad.err.saveRejected") };
+				}
+				const settings = out && out.settings ? out.settings : null;
+				// 服务端回传的形状就是事实：带 ui.entry 才是新接口。
+				if (settings) entryApiModern = hasModernEntryApi(settings);
+				const applied = settings ? entryModeFromSettings(settings) : next;
+				applyEntryMode(applied);
+				return { ok: true, settings: settings, mode: applied };
+			};
+			return (entryApiModern === false ? writeLegacy() : writeModern()).then(function (out) {
+				return finish(out, entryApiModern === false);
+			});
+		}
+
+		/** 读一次设置并同步全局模式；失败时返回 null（界面按默认渲染，不阻塞）。 */
+		function readEntrySettings(remote) {
+			if (!remote || typeof remote.getSettings !== "function") return Promise.resolve(null);
+			return Promise.resolve(remote.getSettings()).then(function (out) {
+				const settings = unwrap(out) || {};
+				entryApiModern = hasModernEntryApi(settings);
+				const mode = entryModeFromSettings(settings);
+				applyEntryMode(mode);
+				return { settings: settings, mode: mode };
+			}, function () { return null; });
+		}
+
+		/**
+		 * 三选一控件（受控）。
+		 *
+		 * 不自己读设置、不自己保存：两个控制面各自处理 busy / error，
+		 * 这样插件页卡片与面板里的交互文案可以不同，而选项本身只有一份。
+		 */
+		function EntryChooser(props) {
+			const mode = props && normalizeEntryMode(props.mode) ? props.mode : entryDisplayMode();
+			const busy = !!(props && props.busy);
+			const sidebarOk = !(props && props.sidebarOk === false);
+			const modernApi = !(props && props.modernApi === false);
+			const onPick = props && typeof props.onPick === "function" ? props.onPick : function () {};
+			const labels = { both: "entry.opt.both", sidebar: "entry.opt.sidebar", settings: "entry.opt.settings" };
+			return h("div", { className: "smem-entry-opts" }, ENTRY_MODES.map(function (value) {
+				const blocked = value === "sidebar" && (!sidebarOk || !modernApi);
+				const disabled = busy || blocked;
+				const blockedWhy = !modernApi ? t("entry.legacyHost") : t("entry.sidebarUnsupported");
+				return h("label", {
+					className: "smem-check smem-entry-opt", key: value,
+					title: blocked ? blockedWhy : undefined,
+				}, [
+					h("input", {
+						type: "radio", key: "r", name: "smem-entry-mode",
+						value: value, checked: mode === value, disabled: disabled,
+						onChange: function () { if (!disabled) onPick(value); },
+					}),
+					h("span", { key: "l" }, t(labels[value])),
+				]);
+			}));
+		}
 		// ⚠️ 不把 `layout` 写进 inject：它是**可选**依赖（官方 inspect：optional access =
 		// `ctx.get("layout")` + 判空；hardDependency 才是 inject）。写进 inject 会让旧外壳
 		// 缺这个服务时整个 client 插件不 apply —— 连带丢掉设置页。返回会话优先用宿主给的
@@ -8324,38 +8595,26 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				document.head.appendChild(tag);
 			}
 			setupI18n(ctx);
-			ctx.slots.inject("settings.section", () =>
-				ctx.slots.register(
-					{
-						name: "settings.section",
-						id: "sage-mem",
-						order: 20,
-						label: () => t("section.label"),
-						// 声明「记忆星图」子槽：sage-starmap 向它注入星空视图，
-						// 记忆管理页用 renderSlot 渲染。声明 children 后 shell 才会
-						// 向本 section 组件传入 renderSlot。
-						children: { "settings.memory.starmap": { kind: "list", scope: "root" } },
-					},
-					(props) => react.createElement(Section, { ...props, ctx }),
-				),
-			);
-			// ── 1.8.0 侧栏入口：先记住 ctx，再读一次设置决定注不注册 ──────────────
-			// 设置页 section **永远**保留（关闭侧栏入口只是少一个入口，不是少一个设置页）。
-			// 读失败 / 旧宿主没有 ui 字段 / 值坏掉 → 一律按「开」处理，绝不阻塞界面。
+
+			// ── 2.7.0 界面入口三选一 ────────────────────────────────────────────
+			// 先读一次设置，决定注册哪一侧；读失败 / 旧宿主没有 ui.entry / 值坏掉
+			// → 一律按「两个都显示」处理，绝不阻塞界面。
+			// 设置页 section 不再无条件注册：只显示侧栏时它会被注销（78-entry-visibility）。
 			sidebarCtx = ctx;
-			let sidebarEnabled = true;
+			let initialMode = "both";
 			try {
 				const mem = typeof ctx.get === "function" ? ctx.get("remote.memory") : null;
 				if (mem && typeof mem.getSettings === "function") {
 					const loaded = unwrap(await mem.getSettings()) || {};
-					if (loaded.ui && loaded.ui.sidebarEntry === false) sidebarEnabled = false;
+					entryApiModern = hasModernEntryApi(loaded);
+					initialMode = entryModeFromSettings(loaded);
 				}
 			} catch (e) {
-				sidebarEnabled = true;
+				initialMode = "both";
 			}
-			setSidebarEntry(sidebarEnabled);
+			applyEntryMode(initialMode);
 
-			// ── 1.8.2 插件详情页的「侧栏入口」卡片 ──────────────────────────────
+			// ── 1.8.2 / 2.7.0 插件详情页的「界面入口」折叠行 ────────────────────
 			// `plugins.bundle.config` 是 keyed 槽，key = 本 bundle 的 **package name**（sage-mem）。
 			// 宿主在插件页的 description 与「包含的组件」行之间渲染它；ownerProps 形如
 			// `{ view: "summary" | "page" }`，卡片里自己再判一次（summary 返回 null）。

package/lib/index.js

@@ -430,14 +430,16 @@ export class MemoryGateway extends TypertRemoteService {
     const norm = (list) => JSON.stringify([...list].map((s) => String(s).toLowerCase()).sort())
     const restartRequired =
       JSON.stringify(limits) !== JSON.stringify(pending.limits) || norm(activeExtra) !== norm(reservedExtra)
+    // 2.7.0：entry 是 canonical；sidebarEntry 只为 2.6.0 的客户端保留（派生值，不落盘）。
+    const ui = pendingUi(fileRead.data)
     return {
       limits,
       pendingLimits: pending.limits,
       restartRequired,
       // Q04 的诊断出口：面板据此说明「你保存的值没生效，原因是 X」；宿主侧先如实给出，别让问题只能靠猜。
       limitDiagnostics,
-      // 1.8.0：客户端行为（侧栏入口开关）。**不参与** restartRequired —— 改完立刻生效。
-      ui: pendingUi(fileRead.data),
+      // 1.8.0 / 2.7.0：客户端行为（界面入口三选一）。**不参与** restartRequired —— 改完立刻生效。
+      ui: { ...ui, sidebarEntry: ui.entry !== 'settings' },
       // 生效的保护名单（含两个内置名）+ 用户声明的那部分原文（面板编辑的是后者）
       reserved: [...new Set([INDEX_FILE_KEY, SESSION_LOG_KEY, ...reservedExtra.map((s) => s.toLowerCase())])],
       reservedExtra,
@@ -498,7 +500,8 @@ export class MemoryGateway extends TypertRemoteService {
       }
       const current = currentRead.data
       const mergedLimits = { ...(current?.limits ?? {}), ...nextLimits }
-      // ui 只覆盖这次给出的键；没给就沿用文件里的有效值（坏值 / 缺失一律按默认「开」）
+      // ui 只覆盖这次给出的键；没给就沿用文件里的有效值（坏值 / 缺失一律按默认「两个都显示」）。
+      // 2.7.0：落盘只写 canonical 的 entry，旧 sidebarEntry 由 pendingUi 迁移进来、不再写出。
       const mergedUi = { ...pendingUi(current), ...(uiPatch ?? {}) }
       await writeFileAtomic(SETTINGS_FILE, JSON.stringify({ limits: mergedLimits, ui: mergedUi, updatedAt: Date.now() }, null, 2))
     }

package/lib/settings.js

@@ -21,22 +21,34 @@ export const RESERVED_FILE = join(STATE_ROOT, 'reserved.json')
 export const clampInt = (v, spec) => (Number.isFinite(v) ? Math.max(spec.lo, Math.min(spec.hi, Math.round(v))) : spec.dflt)
 
 /**
- * 面板 UI 设置（1.8.0）。
+ * 面板 UI 设置（1.8.0；2.7.0 改成三选一）。
  *
  * ⚠️ 与 `limits` **不是一类**：上限在模块加载时就固化进常量，改完必须重启；
- * `ui.sidebarEntry` 是**客户端行为** —— 界面读到值就决定注不注册侧栏槽位，
+ * `ui.entry` 是**客户端行为** —— 界面读到值就决定注不注册侧栏 / 设置页槽位，
  * 改完立刻生效。所以它不进 `restartRequired` 的计算。
+ *
+ * 2.7.0：`entry` 取代 1.8.0 的布尔 `sidebarEntry`。三个值从类型上就保证
+ * 「至少保留一个入口」，不需要额外的互斥校验；旧字段只读不写。
  */
-export const DEFAULT_UI = Object.freeze({ sidebarEntry: true })
+export const ENTRY_MODES = Object.freeze(['both', 'sidebar', 'settings'])
+export const DEFAULT_UI = Object.freeze({ entry: 'both' })
 
-/** 读出 `ui` 的**有效值**：文件里没有 / 坏对象 / 不是布尔 → 一律回落默认（开）。 */
+/**
+ * 读出 `ui` 的**有效值**：新字段优先，旧 `sidebarEntry` 按
+ * `true → both` / `false → settings` 迁移；缺失或坏值回落默认（两个都显示）。
+ */
 export function pendingUi(fileObj) {
   const saved = fileObj?.ui && typeof fileObj.ui === 'object' && !Array.isArray(fileObj.ui) ? fileObj.ui : {}
-  return { sidebarEntry: typeof saved.sidebarEntry === 'boolean' ? saved.sidebarEntry : DEFAULT_UI.sidebarEntry }
+  if (ENTRY_MODES.includes(saved.entry)) return { entry: saved.entry }
+  if (typeof saved.sidebarEntry === 'boolean') return { entry: saved.sidebarEntry ? 'both' : 'settings' }
+  return { entry: DEFAULT_UI.entry }
 }
 
 /**
- * 校验 `setSettings({ ui })` 的那一段：**只认 `sidebarEntry` 一个键**，值必须是布尔。
+ * 校验 `setSettings({ ui })` 的那一段：认 `entry`（2.7.0）与旧 `sidebarEntry`（1.8.0）。
+ *
+ * 两个键同时给时要求语义一致（`sidebarEntry === (entry !== 'settings')`），否则报冲突 ——
+ * 旧客户端写 true 的语义是「侧栏显示、设置页也保留」，和 `entry:'sidebar'` 不是一回事。
  *
  * 返回 `{ ok:true, patch }`（patch 为 null = 调用方没给 ui，或给的是空对象）；`{ ok:false, error }`。
  * 与 limits 同一套严格语义：绝不静默丢掉不认识的键。
@@ -45,10 +57,30 @@ export function parseUiPatch(ui) {
   if (ui === undefined) return { ok: true, patch: null }
   if (!ui || typeof ui !== 'object' || Array.isArray(ui)) return { ok: false, error: 'sage-mem: ui must be an object' }
   const patch = {}
+  let hasLegacy = false
+  let legacy = null
   for (const [key, value] of Object.entries(ui)) {
-    if (key !== 'sidebarEntry') return { ok: false, error: `sage-mem: unknown ui setting: ${key}` }
-    if (typeof value !== 'boolean') return { ok: false, error: `sage-mem: ui.sidebarEntry must be a boolean, got ${typeof value}` }
-    patch.sidebarEntry = value
+    if (key === 'entry') {
+      if (typeof value !== 'string' || !ENTRY_MODES.includes(value)) {
+        return { ok: false, error: `sage-mem: ui.entry must be one of ${ENTRY_MODES.join(' | ')}, got ${JSON.stringify(value)}` }
+      }
+      patch.entry = value
+      continue
+    }
+    if (key === 'sidebarEntry') {
+      if (typeof value !== 'boolean') return { ok: false, error: `sage-mem: ui.sidebarEntry must be a boolean, got ${typeof value}` }
+      hasLegacy = true
+      legacy = value
+      continue
+    }
+    return { ok: false, error: `sage-mem: unknown ui setting: ${key}` }
+  }
+  if (hasLegacy) {
+    const derived = legacy ? 'both' : 'settings'
+    if (patch.entry !== undefined && patch.entry !== derived) {
+      return { ok: false, error: `sage-mem: ui.entry=${patch.entry} conflicts with ui.sidebarEntry=${legacy}` }
+    }
+    patch.entry = derived
   }
   return { ok: true, patch: Object.keys(patch).length ? patch : null }
 }

package/lib/typert.host.js

@@ -239,10 +239,9 @@ const settingsLimitsSchema = z.object({
 	'maxSessionBytes': z.number().readonly(),
 	'staleDays': z.number().readonly(),
 }).readonly()
-// 1.8.0：面板 UI 设置。`sidebarEntry` 是**客户端行为**（改完立刻生效），不进 restartRequired。
-const settingsUiSchema = z.object({
-	'sidebarEntry': z.boolean().readonly(),
-}).readonly()
+// 1.8.0 / 2.7.0：面板 UI 设置。`entry` 是**客户端行为**（改完立刻生效），不进 restartRequired。
+// `sidebarEntry` 是给 2.6.0 客户端的派生值（= entry !== 'settings'），永远随 `entry` 一起返回。
+const settingsUiSchema = z.object({ 'entry': z.enum(['both', 'sidebar', 'settings']).readonly(), 'sidebarEntry': z.boolean().readonly() }).readonly()
 const settingsSchema = z.object({
 	'limits': settingsLimitsSchema,
 	'pendingLimits': settingsLimitsSchema,
@@ -260,6 +259,7 @@ const settingsPatchSchema = z.object({
 		'staleDays': z.number().optional(),
 	}).readonly().optional(),
 	'ui': z.object({
+		'entry': z.enum(['both', 'sidebar', 'settings']).optional(),
 		'sidebarEntry': z.boolean().optional(),
 	}).readonly().optional(),
 	'reserved': z.array(z.string()).optional(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sage-mem",
   "description": "Cross-session memory for DeepSeek Harness — plain markdown files, no database, no worker.",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "type": "module",
   "main": "lib/index.js",
   "icon": "./icon.png",