@modusensus/dsh-mneme 0.9.1 → 0.9.3

package/lib/client.js

@@ -495,6 +495,11 @@ window.__ModuleLoader__.load({
         "memory.features.tagDefault.hint": "这一项用的是出厂默认值，没有被你改过",
         "memory.features.tagChanged": "已改",
         "memory.features.tagChanged.hint": "你改过这一项，它不再用默认值",
+        // 「待重启」是第三态，不是「已改」的加强版：#481 之前面板只有「已改」，
+        // 用户改完总闸看到徽标亮起就以为生效了，实际运行时还在用启动时的旧值。
+        "memory.features.tagPending": "待重启",
+        "memory.features.tagPending.hint": "这一项已存进配置，但本次启动还没用上——重启 DSH（或在插件管理里关开一次本插件）后才生效",
+        "memory.features.pendingRestartNotice": "有改动还没生效：标着「待重启」的开关要等重启 DSH 后才起作用（在插件管理里把本插件关开一次也行）。",
         "memory.features.autoSummarize": "自动把对话记下来（自动注入之外）",
         "memory.features.autoSummarize.hint": "开：对话结束自动提炼成长期记忆条目（autoSummarize）；关：只有你手动存或 Agent 主动存才有记忆",
         "memory.features.hotMemoryEnabled": "顺带带上最近几轮原话",
@@ -526,12 +531,12 @@ window.__ModuleLoader__.load({
         "memory.features.heatEnabled.hint": "开：像遗忘曲线一样给记忆降温，长期没用过的往后排、不占注入名额；关：一直按相关度排（热度衰减，默认关）",
         "memory.features.documentMemoryEnabled": "长文档只存一张摘要卡",
         "memory.features.documentMemoryEnabled.hint": "开：Agent 写的长文档在记忆里只放「摘要卡」，正文仍由 Agent 保管、按需读取，注入只带摘要；关：整篇都往上下文里带（document 型记忆，默认关）",
-        // --- v0.9.0 M.O.（Modus Operandi · 手法，beta）---
+        // --- v0.9.0 M.O.（Modus Operandi，beta）---
         // M.O. = Modus Operandi，拉丁语「一个人一贯的做事方式」；也是 org 词根
         // modus（modusensus）。界面主显示 M.O.，设置项 hint 第一句给全名。
         "memory.actions.beta": "beta",
         "memory.actions.notice": "提炼结果是候选，可能有错、过时、会被推翻。",
-        "memory.actions.title": "M.O. · 手法",
+        "memory.actions.title": "M.O. · 工作流",
         "memory.actions.open": "打开 M.O.",
         "memory.actions.viewFull": "完整视图",
         "memory.actions.openPane": "在右栏打开完整视图",
@@ -583,13 +588,24 @@ window.__ModuleLoader__.load({
         "memory.actions.broken": "有文件读不出来：",
         "memory.actions.empty.title": "这个项目里还没有工作流",
         "memory.actions.empty.body": "工作流的本体住在项目里的 .mneme/pipelines/ 下——跟着仓库走，能被提交、能被 review、能被 CI 读。做法被复用第二次才算节点类型，第一次只是实例；同一路径被走通两次之后，它才会从会话里被提炼出来、落到那个目录里。",
+        "memory.actions.distill.action": "现在沉淀一次",
+        "memory.actions.distill.busy": "正在读会话…",
+        "memory.actions.distill.hint": "看一遍这个项目自己的会话日志，把反复走通的动作挖成提议。只写提议，不落草稿、不改仓库。",
+        "memory.actions.distill.noProject": "读不到会话的工作目录，所以不知道该看哪个项目的日志",
+        "memory.actions.distill.saved": "已提出 {n} 条提议（本次挖到 {m} 条候选）",
+        "memory.actions.distill.none": "这一遍没挖到新的重复动作",
+        "memory.actions.distill.noSessions": "这个项目还没有自己的会话日志，先攒几轮再来",
+        "memory.actions.distill.unreadable": "会话日志读不出来（这是环境问题，不是「没有重复动作」）",
+        "memory.actions.distill.failed": "这一遍没跑完，详见插件日志",
         "memory.actions.noRuns": "这一条还没有运行记录，所以每个节点都还是候选。",
         "memory.actions.settle.title": "本次运行",
         "memory.actions.settle.line": "「{title}」",
         "memory.actions.settle.used": "本次复用 {n} 条做法（勾选为被用上）",
         "memory.actions.settle.refutedWarn": "本次路径里有已被推翻的节点，结果仅供参考",
         "memory.features.actionPipelineEnabled": "M.O.（beta）",
-        "memory.features.actionPipelineEnabled.hint": "⚠️ 开发中：目前只有「看」这一层能用，自己沉淀和触发都还没做，建议暂时保持关闭。Modus Operandi（手法）：把真实会话里反复走通的「做法」连成一张只读图谱——会话头图标、右栏完整视图、每次运行的结算卡。重启 DSH 后生效",
+        "memory.features.actionPipelineEnabled.hint": "只读视图：把真实会话里反复走通的动作连成一张图谱——会话头图标、右栏完整视图、每次运行的结算卡。看 ≠ 写：沉淀由「M.O. 自动沉淀」单独开，执行记账由 /mo-run 单独开。Modus Operandi（工作流）。重启 DSH 后生效",
+        "memory.features.actionNudgeEnabled": "自动沉淀工作流（beta）",
+        "memory.features.actionNudgeEnabled.hint": "开：每轮结束后看一眼这个项目自己的会话日志，把反复走通的动作挖成记忆库里的一条「提议」，等你确认才可能变成工作流。只产草稿、不自动启用、不往仓库里塞文件。挂热路径且要解压日志，轻量档会强制关掉。重启 DSH 后生效",
         "memory.features.resilientModelDownload": "模型下载断了能续上",
         "memory.features.resilientModelDownload.hint": "开：下载中断后从断点续传并自动重试；关：中断就整份重来（断点续传，默认开）",
         "memory.features.searchSemanticDedup": "搜到意思相同的只留一条",
@@ -676,6 +692,12 @@ window.__ModuleLoader__.load({
         "memory.features.sleepProvider": "睡眠 Provider",
         "memory.features.sleepModel": "睡眠模型",
         "memory.features.sleepModelHint": "留空 = 用巩固模型或当前模型；建议选非思考模型",
+        // Issue #478：max_tokens 预算键。hint 写清两件事：这是「单轮输出预算」，
+        // 以及服务商硬上限更小时后端会按报错自动降级重试（对齐 #478 的后端行为）。
+        "memory.features.dreamMaxTokens": "巩固单轮输出上限 (max_tokens)",
+        "memory.features.dreamMaxTokens.hint": "单轮巩固最多生成多少 token，256–131072。默认 131072 超过部分服务商硬上限时，后端会按报错里的上限自动降级重试",
+        "memory.features.sleepMaxTokens": "睡眠单轮输出上限 (max_tokens)",
+        "memory.features.sleepMaxTokens.hint": "睡眠阶段冲突/模式判断的单轮输出预算，256–131072；超上限同样自动降级",
         "memory.features.routeFollowDefault": "跟随默认路由",
         "memory.features.modelTest": "测试连通性",
         "memory.features.modelTesting": "测试中…",
@@ -1156,6 +1178,9 @@ window.__ModuleLoader__.load({
         "memory.features.tagDefault.hint": "This one is at its factory default — you have not changed it",
         "memory.features.tagChanged": "changed",
         "memory.features.tagChanged.hint": "You changed this one; it no longer uses the default",
+        "memory.features.tagPending": "restart pending",
+        "memory.features.tagPending.hint": "Saved, but not yet in effect for this session — restart DSH (or toggle this plugin off and on in the plugin manager) to apply it",
+        "memory.features.pendingRestartNotice": "Some changes are not in effect yet: switches marked \"restart pending\" apply only after you restart DSH (toggling this plugin off and on in the plugin manager works too).",
         "memory.features.autoSummarize": "Turn conversations into memory automatically",
         "memory.features.autoSummarize.hint": "On: memory entries are distilled when a conversation ends (autoSummarize). Off: memory only exists if you save it, or the agent decides to",
         "memory.features.hotMemoryEnabled": "Carry the last few turns verbatim",
@@ -1240,13 +1265,24 @@ window.__ModuleLoader__.load({
         "memory.actions.broken": "Some files could not be read:",
         "memory.actions.empty.title": "No workflows in this project yet",
         "memory.actions.empty.body": "A workflow lives in the project, under .mneme/pipelines/ — it travels with the repository: committable, reviewable, readable by CI. A practice becomes a node type on its second reuse; the first run is just an instance. Once the same path has been walked twice it gets distilled out of the session and lands in that directory.",
+        "memory.actions.distill.action": "Distill now",
+        "memory.actions.distill.busy": "Reading sessions…",
+        "memory.actions.distill.hint": "Scan this project's own session logs and mine repeated actions into proposals. Writes proposals only — no drafts, no repository changes.",
+        "memory.actions.distill.noProject": "The session's working directory is unknown, so there is no project to scan",
+        "memory.actions.distill.saved": "{n} proposal(s) written ({m} candidate(s) mined this pass)",
+        "memory.actions.distill.none": "No new repeated action this pass",
+        "memory.actions.distill.noSessions": "This project has no session logs of its own yet — come back after a few turns",
+        "memory.actions.distill.unreadable": "The session logs could not be read (an environment problem, not an empty result)",
+        "memory.actions.distill.failed": "This pass did not finish; see the plugin log",
         "memory.actions.noRuns": "No runs recorded for this workflow yet, so every step is still a candidate.",
         "memory.actions.settle.title": "This run",
         "memory.actions.settle.line": "\"{title}\"",
         "memory.actions.settle.used": "Reused {n} steps this run (checked = actually used)",
         "memory.actions.settle.refutedWarn": "This path contains refuted steps; take the result with caution",
         "memory.features.actionPipelineEnabled": "M.O. (beta)",
-        "memory.features.actionPipelineEnabled.hint": "⚠️ Under development: only the viewing layer works today — self-distillation and triggering are not built yet, so leave this off for now. Modus Operandi: the ways of working that actually got walked through in real sessions, drawn as a read-only graph — session-header icon, full sidebar view, and a per-run settlement card. Takes effect after restarting DSH",
+        "memory.features.actionPipelineEnabled.hint": "Read-only view: the ways of working that actually got walked through in real sessions, drawn as a graph — session-header icon, full sidebar view, and a per-run settlement card. Viewing is not writing: distillation has its own switch below, and run accounting has its own (/mo-run). Modus Operandi. Takes effect after restarting DSH",
+        "memory.features.actionNudgeEnabled": "Auto-distill workflows (beta)",
+        "memory.features.actionNudgeEnabled.hint": "On: after each turn, look at this project's own session logs and mine the actions it keeps repeating into a proposal in the memory store — it still needs your sign-off before becoming a workflow. Drafts only; never auto-activates; never writes files into the repo. Hooks a hot path and decompresses logs, so light mode forces it off. Takes effect after restarting DSH",
         "memory.features.resilientModelDownload": "Model downloads resume after interruption",
         "memory.features.resilientModelDownload.hint": "On: downloads continue from where they stopped and retry automatically. Off: an interrupted download starts over (resumable downloads, on by default)",
         "memory.features.searchSemanticDedup": "Keep one entry when search hits near-duplicates",
@@ -1329,6 +1365,12 @@ window.__ModuleLoader__.load({
         "memory.features.sleepProvider": "Sleep provider",
         "memory.features.sleepModel": "Sleep model",
         "memory.features.sleepModelHint": "Leave empty to reuse the consolidation model; a non-reasoning model is recommended",
+        // Issue #478: max_tokens budget keys. Hint states both the scope (single-run
+        // output budget) and the backend auto-downgrade on provider cap rejection.
+        "memory.features.dreamMaxTokens": "Consolidation output cap (max_tokens)",
+        "memory.features.dreamMaxTokens.hint": "Max tokens generated per consolidation run, 256–131072. When the default 131072 exceeds a provider's hard limit, the backend retries with the cap from the error",
+        "memory.features.sleepMaxTokens": "Sleep output cap (max_tokens)",
+        "memory.features.sleepMaxTokens.hint": "Single-run output budget for sleep conflict/mode calls, 256–131072; over-cap values are downgraded automatically",
         "memory.features.routeFollowDefault": "Follow default route",
         "memory.features.modelTest": "Test connectivity",
         "memory.features.modelTesting": "Testing…",
@@ -1830,6 +1872,13 @@ window.__ModuleLoader__.load({
       ".mneme-set-del{flex:none;opacity:0;transition:opacity .12s;border:none;background:none;color:var(--mneme-fg-dim);cursor:pointer;font-size:14px;line-height:20px;padding:0 4px;border-radius:6px}",
       ".mneme-set-row:hover .mneme-set-del,.mneme-set-row:focus-within .mneme-set-del{opacity:1}",
       ".mneme-set-del:hover{color:var(--mneme-danger);background:var(--dsw-alias-interactive-bg-hover)}",
+      // 人格卡删除 × 独立类：不复用 mneme-set-del——其 opacity:0 仅在
+      // .mneme-set-row:hover 解除，卡标签不在该容器里 → × 永远透明（v1.2
+      // 实测踩中）。#457 曾用内联 opacity:1 覆写，但悬停变红仍走
+      // .mneme-set-del:hover，连带常点亮了规则区的真删除按钮，被 #459 回滚。
+      // 独立类常显，只沿用配色，规则区行为分毫不动。
+      ".mneme-persona-del{flex:none;opacity:1;border:none;background:none;color:var(--mneme-fg-dim);cursor:pointer;font-size:16px;line-height:18px;padding:0 3px;border-radius:6px}",
+      ".mneme-persona-del:hover{color:var(--mneme-danger);background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-set-cmd{flex:1;min-width:0}",
       ".mneme-set-cmdname{font-size:13px;font-weight:600;color:var(--mneme-accent)}",
       ".mneme-set-cmddesc{font-size:12px;line-height:17px;color:var(--mneme-fg-dim);margin-top:1px;word-break:break-word}",
@@ -1967,6 +2016,13 @@ window.__ModuleLoader__.load({
       ".mneme-conflict-primary:disabled{opacity:.55;cursor:default}",
       ".mneme-conflict-primary:hover:not(:disabled){background:color-mix(in srgb,var(--mneme-accent) 85%,var(--dsw-alias-label-primary))}",
       ".mneme-badge--frozen{color:var(--mneme-warn);background:color-mix(in srgb,var(--mneme-warn) 12%,transparent)}",
+      // 「待重启」徽标：沿用 frozen 的 warn 语义（都是「现状不是你刚设的样子」），
+      // 但加边框把它和只读冻结态区分开——它需要用户动手，不是终态。
+      ".mneme-badge--pending{color:var(--mneme-warn);background:color-mix(in srgb,var(--mneme-warn) 12%,transparent);border:1px solid color-mix(in srgb,var(--mneme-warn) 30%,transparent)}",
+      ".mneme-pending{display:flex;align-items:flex-start;gap:8px;margin:8px 0 0;padding:8px 10px;border-radius:8px;font-size:12.5px;line-height:18px;color:var(--mneme-warn);background:color-mix(in srgb,var(--mneme-warn) 10%,transparent);border:1px solid color-mix(in srgb,var(--mneme-warn) 28%,transparent)}",
+      // 圆点用当前色（currentColor）而不是再引一次 --mneme-warn：色值只有一个真源，
+      // 改主题时提示行与圆点不会走散。
+      ".mneme-pending-dot{flex:none;width:6px;height:6px;margin-top:6px;border-radius:50%;background:currentColor}",
       ".mneme-conflict-empty{border:1px dashed var(--dsw-alias-border-l2);border-radius:10px;padding:12px 14px;display:flex;flex-direction:column;gap:4px}",
       ".mneme-conflict-empty-title{font-size:12.5px;font-weight:600;color:var(--dsw-alias-label-secondary)}",
       ".mneme-conflict-empty-body{font-size:12px;line-height:18px;color:var(--mneme-fg-dim)}",
@@ -2317,6 +2373,17 @@ window.__ModuleLoader__.load({
       ".mneme-pipe-wfMeta{display:block;margin-top:3px;font-size:12px;color:var(--mneme-fg-dim)}",
       ".mneme-pipe-wfId{display:block;margin-top:2px;font-size:11px;color:var(--mneme-fg-dim)}",
       ".mneme-pipe-broken{flex:none;font-size:12px;line-height:17px;color:var(--mneme-warn);padding:6px 14px 0}",
+      // 手动沉淀：按钮与回执占一行。回执用 --mneme-fg-dim 而不是 --mneme-warn——
+      // 「这一遍没挖到」是正常结果，不是警告；只有「读不出来」才是故障，那也由文案说清，
+      // 不靠颜色区分（红黄两色在深浅主题里最容易一起掉对比度）。
+      ".mneme-pipe-distill{flex:none;display:flex;align-items:center;gap:8px;flex-wrap:wrap;font-size:12px}",
+      ".mneme-pipe-distillBtn{border:1px solid var(--dsw-alias-border-l2);background:0 0;border-radius:8px;cursor:pointer;color:var(--mneme-fg-dim);font-family:inherit;font-size:12px;line-height:16px;padding:2px 9px}",
+      ".mneme-pipe-distillBtn:hover:enabled{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-pipe-distillBtn:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}",
+      // 禁用态用虚线边而不是降透明度：整块降 opacity 会把文字一起压到 AA 以下，
+      // 而「为什么禁用」本来就由 title 说明（读不到会话工作目录）。
+      ".mneme-pipe-distillBtn:disabled{cursor:not-allowed;border-style:dashed;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-distillNote{color:var(--mneme-fg-dim);line-height:17px;min-width:0}",
     ].join("\n");
     if (typeof document !== "undefined" && document.querySelector(`style[data-plugin-css="${CSS_TAG}"]`) === null) {
       const tag = document.createElement("style");
@@ -2889,7 +2956,10 @@ window.__ModuleLoader__.load({
       // （关=一个座位都不注册，见 apply 内的 M.O. 块）。独立成组只解决「混在
       // enhance 末位」；可见层由 FEATURE_FIRST_SCREEN 决定（见其注释），
       // 本轮已把组名提进首屏——组成员资格不决定可见性。
-      { key: "group.mo", items: ["actionPipelineEnabled"] },
+      // 同一组的三个键是**三件独立能力**，不是一条链的三段：看图（座位闸门）、
+      // 自动沉淀（写提议到记忆库）、执行记账（/mo-run 开窗）。各自默认关，
+      // 开了任何一个都不会顺带打开另一个——写能力必须由人一项一项点。
+      { key: "group.mo", items: ["actionPipelineEnabled", "actionNudgeEnabled"] },
       { key: "group.enhance", items: ["entityExtractionEnabled", "codingRetrospect", "rerankEnabled", "resilientModelDownload", "searchSemanticDedup", "bm25SearchEnabled", "heatEnabled", "documentMemoryEnabled",
         // 人格定义页（beta）：注入总闸。分组随 enhance（行为开关，非座位闸门）；
         // 人格内容在设置页「个性化」区的人格卡。
@@ -2910,7 +2980,7 @@ window.__ModuleLoader__.load({
     // 后端白名单、面板够不着——而 CONFIGURATION.md 明写「面板可启停」。
     // 其余整数键（429 调速器参数、distillMaxChars、codingBoostFactor）是有意
     // 不上 UI 的调优噪音，见上方注释，别顺手搬进来。
-    const FEATURE_NUMBERS = ["distillRecords.retentionDays"];
+    const FEATURE_NUMBERS = ["distillRecords.retentionDays", "dreamMaxTokens", "sleepMaxTokens"];
     const EMBED_PROVIDERS = ["openai", "local", "ollama"];
     // 实体抽取思考强度（issue #109）：与后端 FEATURE_FLAG_ENUMS 枚举对齐。
     const ENTITY_REASONING = ["none", "low", "medium", "high"];
@@ -3063,11 +3133,25 @@ window.__ModuleLoader__.load({
       // = 值仍来自 config schema 的默认值。面板自己判断，不加后端字段、
       // 不动 config.js（#427 的验收红线之一）。
       const ovr = (state && state.overrides) || {};
-      const flagTag = (k) => ({
-        kind: Object.prototype.hasOwnProperty.call(ovr, k) ? "mneme-badge--changed" : "mneme-badge--default",
-        text: t(Object.prototype.hasOwnProperty.call(ovr, k) ? "memory.features.tagChanged" : "memory.features.tagDefault"),
-        title: t(Object.prototype.hasOwnProperty.call(ovr, k) ? "memory.features.tagChanged.hint" : "memory.features.tagDefault.hint")
-      });
+      // 「待重启」是第三态，必须由后端算：#481 的坑正是「面板显示已改 ≠ 运行时
+      // 已改」——开关在宿主启动时合并进 cfg 并冻结，此后改 kv 只是持久化。这个
+      // 落差前端看不见（overrides 里只有「改了」这一个事实），所以后端另比一次
+      // 冻结值并给出 pendingRestart 名单；本面板只负责把它显示出来。
+      const pending = new Set((state && state.pendingRestart) || []);
+      const flagTag = (k) => {
+        if (pending.has(k)) {
+          return {
+            kind: "mneme-badge--pending",
+            text: t("memory.features.tagPending"),
+            title: t("memory.features.tagPending.hint")
+          };
+        }
+        return {
+          kind: Object.prototype.hasOwnProperty.call(ovr, k) ? "mneme-badge--changed" : "mneme-badge--default",
+          text: t(Object.prototype.hasOwnProperty.call(ovr, k) ? "memory.features.tagChanged" : "memory.features.tagDefault"),
+          title: t(Object.prototype.hasOwnProperty.call(ovr, k) ? "memory.features.tagChanged.hint" : "memory.features.tagDefault.hint")
+        };
+      };
       const boolRow = (k, opts = {}) => h(FeatureRow, {
         key: k,
         name: t(`memory.features.${k}`),
@@ -3256,14 +3340,19 @@ window.__ModuleLoader__.load({
         // Issue #239 第 4 项镜像到巩固：高峰时段串（空 = 关闭）。放在 autoDream
         // 子块内——它是巩固的排程，开关关掉时不该还在界面上留着可编辑的输入框。
         strRow("dreamPeakHours"),
-        h("div", { className: "mneme-featsubhint" }, t("memory.features.dreamPeakHours.hint"))
+        h("div", { className: "mneme-featsubhint" }, t("memory.features.dreamPeakHours.hint")),
+        // Issue #478：单轮巩固的 max_tokens 预算。后端白名单（256–131072）早就有，
+        // 修复前 UI 够不着；默认 131072 超过很多 OpenAI 兼容网关的硬上限又看不见调不了。
+        numRow("dreamMaxTokens")
       );
 
       // 睡眠模型：sleepModeEnabled 开着才展开（sleepProvider/sleepModel 随本版
       // 进白名单；下拉与测试复用同一 /llm-providers 数据源）。
       const sleepSub = eff.sleepModeEnabled && Array.isArray(routes) && h("div", { className: "mneme-featsub" },
         routeSelects("sleepProvider", "sleepModel", sleepTest, setSleepTest, "sleepReasoningEffort"),
-        h("div", { className: "mneme-featsubhint" }, t("memory.features.sleepModelHint"))
+        h("div", { className: "mneme-featsubhint" }, t("memory.features.sleepModelHint")),
+        // Issue #478：睡眠侧同款预算键（#257 引入后端白名单，UI 一直缺席）。
+        numRow("sleepMaxTokens")
       );
 
       // 实体抽取路由与思考强度（issue #109）：entityExtractionEnabled 开着才
@@ -3325,6 +3414,14 @@ window.__ModuleLoader__.load({
           savedTick && h("span", { className: "mneme-saved", style: { marginLeft: 8, fontWeight: 400 } }, t("memory.features.restartHint"))
         ),
         h("div", { className: "mneme-set-desc" }, t("memory.features.desc")),
+        // #481：改了但没生效的开关，在这张卡里明说。放在 desc 之后、错误行之前
+        // ——它是常态提示而非错误，但比错误更该先被看见（用户刚改完就会看这里）。
+        // 行级 badge（flagTag 的第三态）标出具体是哪几行，这条只负责说清「有事
+        // 没生效」和「怎么办」。
+        pending.size > 0 && h("div", { className: "mneme-pending" },
+          h("span", { className: "mneme-pending-dot" }),
+          h("span", null, t("memory.features.pendingRestartNotice"))
+        ),
         // 见 saveError 的声明处：这条分支不能跟着加载失败那条走。
         saveError && h("div", { className: "mneme-mainterr" }, saveError),
         h(RuntimeProvisionBlock, { t }),
@@ -3857,9 +3954,11 @@ window.__ModuleLoader__.load({
                   className: "mneme-btn" + (personaEditing === id ? " mneme-btn--active" : ""),
                   onClick: () => setPersonaEditing(id)
                 }, id),
+                // 卡删除 × 常显：用独立类 mneme-persona-del（见上方样式定义处的
+                // 注释——为何不复用 mneme-set-del，以及 #457→#459 一修一回滚的教训）。
                 h("button", {
                   type: "button",
-                  className: "mneme-set-del",
+                  className: "mneme-persona-del",
                   title: t("memory.settings.personaDeleteCard"),
                   "aria-label": t("memory.settings.personaDeleteCard") + " " + id,
                   onClick: () => removePersonaCard(id)
@@ -7540,8 +7639,62 @@ window.__ModuleLoader__.load({
     // 条目清单（名字 + 规模 + 作用域）：图上方的**选择器**。
     // 它解决的是「这是哪条工作流」——一进来就是一张图时这个问题没有落点，多条之间也没得选。
     // 但它不占整屏：图和它同屏，见下面的 PipelineBrowser。
+    // 「现在就跑一次」。自动沉淀只在 turn/end 之后跑、还有 10 分钟冷却，所以人想立刻
+    // 看到结果时没有入口。这里的 POST 与自动跑走**同一条** nudgeForProject，区别只有
+    // materialize：按钮永远不落草稿，只把提议写进记忆库——升格仍然要人批。
+    // project 为空（会话里读不到 cwd）时按钮是禁用的：服务端只会回 400，
+    // 而一个点了必然失败的按钮比没有按钮更糟。
+    function PipelineDistillButton(props) {
+      const { t, project } = props;
+      const [busy, setBusy] = useState(false);
+      const [note, setNote] = useState("");
+      const disabled = busy || !project;
+      const run = () => {
+        if (disabled) return;
+        setBusy(true);
+        setNote("");
+        apiFetch("/api/dsh-mneme/nudge?project=" + encodeURIComponent(project), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({})
+        })
+          .then((res) => res.json().then((j) => ({ ok: res.ok, status: res.status, body: j || {} })))
+          .then(({ ok, status, body }) => {
+            if (!ok) {
+              // 503 = 会话日志读不到（环境问题），其余是这一跑本身失败。两句不能合并：
+              // 「读不到」和「没有重复动作」在界面上长得一样时，人就只能瞎猜。
+              setNote(t(status === 503
+                ? "memory.actions.distill.unreadable"
+                : "memory.actions.distill.failed"));
+              return;
+            }
+            if (body.skipped) {
+              setNote(t("memory.actions.distill.noSessions"));
+              return;
+            }
+            const saved = (body.counts && body.counts.savedProposals) || 0;
+            const found = (body.counts && body.counts.candidates) || 0;
+            setNote(found === 0
+              ? t("memory.actions.distill.none")
+              : t("memory.actions.distill.saved").replace("{n}", String(saved)).replace("{m}", String(found)));
+          })
+          .catch(() => setNote(t("memory.actions.distill.failed")))
+          .then(() => setBusy(false));
+      };
+      return h("span", { className: "mneme-pipe-distill" },
+        h("button", {
+          type: "button",
+          className: "mneme-pipe-distillBtn",
+          disabled,
+          title: !project ? t("memory.actions.distill.noProject") : t("memory.actions.distill.hint"),
+          onClick: run
+        }, busy ? t("memory.actions.distill.busy") : t("memory.actions.distill.action")),
+        note ? h("span", { className: "mneme-pipe-distillNote", role: "status" }, note) : null
+      );
+    }
+
     function PipelineWorkflowList(props) {
-      const { t, data, activeId, onOpen } = props;
+      const { t, data, activeId, onOpen, project } = props;
       const list = (data && data.available) || [];
       const scopeOf = (row) => (row.scope === "global"
         ? t("memory.actions.scope.global")
@@ -7551,6 +7704,7 @@ window.__ModuleLoader__.load({
           h("span", null, t("memory.actions.list.heading")),
           h("span", null, t("memory.actions.list.count").replace("{n}", String(list.length)))
         ),
+        h(PipelineDistillButton, { t, project }),
         list.length
           ? list.map((row) => h("button", {
               key: row.id,
@@ -7601,7 +7755,7 @@ window.__ModuleLoader__.load({
         className: "mneme-pipe",
         style: { height: "100%", display: "flex", flexDirection: "column", minHeight: "0" }
       },
-        h(PipelineWorkflowList, { t, data: listDoc, activeId, onOpen: setPicked }),
+        h(PipelineWorkflowList, { t, data: listDoc, activeId, onOpen: setPicked, project }),
         h(PipelineView, { t, data: detailDoc })
       );
     }

package/lib/config.js

@@ -863,7 +863,24 @@ export const Config = z.object({
   // 数据、观察 A2 加权质量后再切硬过滤。
   strictScope: z.boolean().default(false),
 
-  // --- v0.9.0 M.O.（Modus Operandi · 手法，beta）--------------------------
+  // scopeState（issue #471）：政策轴——作用域级可逆闸门。与上面两个键是**两条不同
+  // 的轴**：scopeEnabled/strictScope 管「这条记忆属于谁」（事实轴：持久、跟着记忆
+  // 行走、改的是归属数据），本键管「这个作用域现在通不通」（政策轴：暂时、由人单
+  // 方面按下、松开即恢复、不改任何记忆行）。
+  // 两级语义同 writeAdmission/preInjectGate——enabled 打开时被按下的作用域其候选
+  // 照常注入，但留一条审计行说清「本应被拦下几条」（观察档，先在真实流量看会少掉
+  // 多少再决定真按）；enforce 打开才真的不注入（拦截档）。两个都默认关，打开前
+  // 行为与今天逐字段一致。
+  // 不进 LIGHT_MODE_OFF：它只是查一张小表的判定，不引入重型后台路径、不加常驻
+  // 文本（同 actionPipelineEnabled 的定性）——轻量档预设该关的是重型能力，不该替
+  // 用户关掉一个纯判定入口，用户显式勾选仍然赢。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  scopeState: z.object({
+    enabled: z.boolean().default(false),
+    enforce: z.boolean().default(false)
+  }).default({}),
+
+  // --- v0.9.0 M.O.（Modus Operandi，beta）--------------------------
   // 命名：M.O. = Modus Operandi，拉丁语「一个人一贯的做事方式」，缩写 M.O.；
   // 也正是 org 词根 modus（modusensus）。界面主显示 M.O.，设置项 hint 第一句
   // 给全名——缩写不靠注释解释，靠用户第一眼能看见全名。
@@ -885,6 +902,20 @@ export const Config = z.object({
   // 所以轻量档要关掉：`LIGHT_MODE_OFF` 里有它。
   actionRunEnabled: z.boolean().default(false),
 
+  // M.O. 自动沉淀（v0.9.0 第三批）：会话跑完一轮后，把这个项目自己的会话日志挖一遍，
+  // 把「反复出现的同一段能力序列」落成提议（memoryDir 下），可选再落一份 draft 草稿。
+  //
+  // 与上面两个键三件事分开：actionPipelineEnabled 管「看图的座位」，actionRunEnabled
+  // 管「往账本里写」，这个管「从日志里长出候选」。三个都是独立能力，混成一个键会让
+  // 「只想看图」的人顺手获得写盘能力。
+  //
+  // 默认关（beta 必须 opt-in），并且进 LIGHT_MODE_OFF：它挂在 session/event 热路径上，
+  // 且解压会话日志是**同步**的（本机 118 份实测 16.2s），轻量档最不该背这条路径。
+  // 触发侧另有 10 分钟/项目的冷却与 budgetMs 上限（见 src/pipeline-nudge.js 的
+  // NUDGE_AUTO_MIN_INTERVAL_MS 与 src/index.js 的装配注释）——旗标只是总闸。
+  // （冷却值以常量为准：早前这里写「30 分钟」，与实际 10 分钟不符。）
+  actionNudgeEnabled: z.boolean().default(false),
+
   // --- 人格定义页（beta）---------------------------------------------------
   // 注入器渲染人格段的顶层总闸（双闸门的 config 半边；user_settings "persona"
   // 键内的 persona.enabled 是 per-agent 半边，两闸同真才渲染）。API 的 effective
@@ -945,7 +976,11 @@ const LIGHT_MODE_OFF = [
   // M.O. 执行记账：它挂在**热路径**上（每个会话事件都过一次监听）。轻量档的取向
   // 是「小模型 / 小上下文 / 少常驻路径」，这与一个每事件都过一遍的监听器相冲突。
   // 默认关，这里只是轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同上面两条）。
-  "actionRunEnabled"
+  "actionRunEnabled",
+  // M.O. 自动沉淀：同样挂在 session/event 热路径上，而且解压会话日志是同步 I/O。
+  // 轻量档的取向（小模型 / 小上下文 / 少常驻路径）与它直接冲突，预设里关掉；
+  // 用户显式勾选仍然赢（合并顺序同上面几条）。
+  "actionNudgeEnabled"
 ];
 
 /**

package/lib/dream/sleep.js

@@ -21,7 +21,7 @@ import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions, ACTIONS } from "./decisions.js";
 import { findPotentialConflicts, cosineSimilarity } from "./clustering.js";
 import { scopeKeyOf } from "../scope.js";
-import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, maintainIndexAfterDream } from "../dream.js";
+import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, withMaxTokensFallback, maintainIndexAfterDream } from "../dream.js";
 import { computeHeat } from "../heat.js";
 
 // Issue #126 review（Copilot）：默认档（sleepActionSet="conflict"）允许的动作 = 全局
@@ -172,6 +172,22 @@ function makeSummary(m) {
   return text.length <= SUMMARY_MAX ? text : `${text.slice(0, SUMMARY_MAX)}…`;
 }
 
+// issue #471 政策轴：被按下的作用域也不参与睡眠整理。与 dream.js 的 withoutPaused
+// 同源（那里记着「判定只许有一份实现」的理由），但这里是**单独一处**而不是复用：
+// 两个模块各被独立装配（runSleep / runDream 各自接 service），任何一个被换进只
+// 实现了一半 service 的夹具时都该各自降级，而不是因为对方模块没装而双双失效。
+//
+// 睡眠侧比日间加固侧更要紧：这几个相位不只读——phaseDemotion 会 setArchived 与
+// demoteToSummary（真改归档面），phasePatterns 会 mint 出 type=pattern 的新行
+// （凭空给被按下的作用域生出衍生记忆）。只挡日间那几处读入口的话，闸门开着而每
+// 6 小时一次的睡眠照样动手，那等于「按下」只是让它在白天看不见。
+//
+// service 上取不到 filterPaused 时（老装配、测试夹具）原样返回，与改动前一致。
+function withoutPaused(service, rows) {
+  if (typeof service?.filterPaused !== "function") return rows;
+  return service.filterPaused(rows);
+}
+
 // ---------------------------------------------------------------- phases
 
 /**
@@ -189,7 +205,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   }
   const strictness = config.sleepConflictStrictness ?? "normal";
   const threshold = CONFLICT_THRESHOLDS[strictness] ?? CONFLICT_THRESHOLDS.normal;
-  const memories = service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document");
+  const memories = withoutPaused(service, service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document"));
   if (memories.length < 2) return { status: "skipped", reason: "too few memories" };
   if (signal?.aborted) return { status: "aborted", reason: "user activity" };
 
@@ -313,7 +329,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   // actionSet 已在候选构造前解析（跨类型候选需要它），这里只按档位选 prompt：
   // 默认档保持只有 conflict/keep 的窄 prompt，"full" 才开放六分支。
   const conflictPrompt = actionSet === "full" ? STR.prompts.conflictFull[language] : STR.prompts.conflict[language];
-  const runConflict = (withEffort) => {
+  const runConflict = (withEffort, tokens) => {
     conflictStreamFailure = "";
     return auditedSleepLlm(ctx, service, config, logger, {
       triggerSource: "sleep",
@@ -331,7 +347,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     provider: route.provider,
     model: route.model,
     purpose: "sleep-conflict",
-    maxTokens: config.sleepMaxTokens ?? 2048,
+    maxTokens: tokens,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: conflictPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
@@ -339,7 +355,9 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     ]
   }, reportUsage, (reason) => { conflictStreamFailure = describeStreamFailure(reason); }));
   };
-  const text = await withEffortFallback(ctx, sleepEffort, () => runConflict(true), () => runConflict(false), () => conflictStreamFailure);
+  // Issue #478：睡眠侧同样接 max_tokens 降级——面板 hint 已承诺「超上限同样自动降级」，
+  // 只挂 dream 三个点会让 sleepMaxTokens 的 131072 上限继续原样发。
+  const text = await withMaxTokensFallback(ctx, config.sleepMaxTokens ?? 2048, (tokens) => withEffortFallback(ctx, sleepEffort, () => runConflict(true, tokens), () => runConflict(false, tokens), () => conflictStreamFailure), () => conflictStreamFailure);
   if (text === undefined) {
     if (conflictStreamFailure) ctx.logger?.warn?.(`dsh-mneme sleep: conflict stream aborted or errored (${conflictStreamFailure})`);
     return { status: "failed", error: "llm failed" };
@@ -423,7 +441,10 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
   const compressCut = Date.now() - compressDays * 86400000;
   const demoted = [];
   const archived = [];
-  for (const m of service.all()) {
+  // 政策轴在这里尤其要紧：下面两行会真改归档面（setArchived / demoteToSummary）。
+  // 把过滤放在循环之外、而不是在循环体里 continue：一旦将来有人在循环体里加
+  // 副作用（现已有），漏掉那条 continue 就是静默改到被按下的行。
+  for (const m of withoutPaused(service, service.all())) {
     if (signal?.aborted) break;
     if (m.archived || m.forgotten) continue;
     const ref = m.last_accessed_at ?? m.created_at;
@@ -472,9 +493,11 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
   const limit = config.sleepPatternMinMemories ?? 100;
   // #230：document 在查询层排除（excludeTypes）而不是截断后过滤——LIMIT 200
   // 先生效的话，指针行一多就会把普通记忆挤出扫描窗，池子饿到门槛以下。
-  const memories = service
+  // 政策轴同理必须排在 `.slice(0, limit)` **之前**，否则被按下的行照样占掉
+  // sleepPatternMinMemories 的名额，而它们既不会被扫、也不该挤掉别人（#471）。
+  const memories = withoutPaused(service, service
     .list({ limit: 200, includeForgotten: false, excludeTypes: ["document"] })
-    .filter((m) => !m.archived && m.type !== "summary" && m.type !== "pattern")
+    .filter((m) => !m.archived && m.type !== "summary" && m.type !== "pattern"))
     .sort((a, b) => (a.updated_at < b.updated_at ? 1 : -1))
     .slice(0, limit);
   if (memories.length === 0) return { status: "skipped", reason: "no memories to scan" };
@@ -485,7 +508,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
   const maxPatterns = config.sleepMaxPatternPerRun ?? 3;
   const sleepEffort = await resolveDreamEffort(ctx, route, config.sleepReasoningEffort, logger);
   let patternStreamFailure = "";
-  const runPattern = (withEffort) => {
+  const runPattern = (withEffort, tokens) => {
     patternStreamFailure = "";
     return auditedSleepLlm(ctx, service, config, logger, {
       triggerSource: "sleep",
@@ -500,7 +523,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     provider: route.provider,
     model: route.model,
     purpose: "sleep-pattern",
-    maxTokens: config.sleepMaxTokens ?? 2048,
+    maxTokens: tokens,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
@@ -508,7 +531,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     ]
   }, reportUsage, (reason) => { patternStreamFailure = describeStreamFailure(reason); }));
   };
-  const text = await withEffortFallback(ctx, sleepEffort, () => runPattern(true), () => runPattern(false), () => patternStreamFailure);
+  const text = await withMaxTokensFallback(ctx, config.sleepMaxTokens ?? 2048, (tokens) => withEffortFallback(ctx, sleepEffort, () => runPattern(true, tokens), () => runPattern(false, tokens), () => patternStreamFailure), () => patternStreamFailure);
   if (text === undefined) {
     if (patternStreamFailure) ctx.logger?.warn?.(`dsh-mneme sleep: pattern stream aborted or errored (${patternStreamFailure})`);
     return { status: "failed", error: "llm failed" };
@@ -563,7 +586,7 @@ function phaseRelations(service, config, logger, runId, signal = null) {
   if (entities.length < 2) return { status: "skipped", reason: "too few entities" };
   const orphans = entities.filter((e) => (service.getRelations(e.id) ?? []).length === 0);
   if (orphans.length === 0) return { status: "skipped", reason: "no orphan entities" };
-  const memories = service.all().filter((m) => !m.archived && !m.forgotten);
+  const memories = withoutPaused(service, service.all().filter((m) => !m.archived && !m.forgotten));
   const seen = new Set();
   const related = [];
   const MAX_RELATIONS_PER_ORPHAN = 3;