@modusensus/dsh-mneme 0.8.9 → 0.8.11

package/README.md

@@ -5,7 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Awesome](https://awesome-dsh-plugin.com/badge.svg)](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)
-[![tests](https://img.shields.io/badge/tests-1405%20passed-success)](https://github.com/slow-stack/mneme)
+[![tests](https://img.shields.io/badge/tests-1437%20passed-success)](https://github.com/slow-stack/mneme)
 [![CI](https://img.shields.io/github/actions/workflow/status/slow-stack/mneme/ci.yml)](https://github.com/slow-stack/mneme/actions)
 [![node](https://img.shields.io/badge/node-22%2B-blue)](https://nodejs.org)
 [![npm downloads](https://img.shields.io/npm/d18m/@modusensus/dsh-mneme.svg?color=blue&label=downloads)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
@@ -432,6 +432,7 @@ dsh web
 | `llmAudit` | `{enabled:true, retentionDays:90}` | LLM 消耗审计（v0.4.6，默认开）：每次后台 LLM 调用（`autoDream` / `autoSummarize` / `sleep` / `entityExtract`，对应 `operation_type` 为 `dream_consolidate` / `dream_summarize` / `dream_narrative`、`summarize_compress`、`sleep_conflict` / `sleep_pattern`、`entity_extract`）写 `llm_audit_logs`（tokens/duration/status/source）；失败记 error 不阻塞；只读 API `/api/dsh-mneme/semantic/llm-audit` + `/llm-audit/stats` |
 | `scopeEnabled` | `false` | 作用域隔离总开关（v0.8.0，issue #17）：memory_save 按会话身份写入 agent / workspace 标注（agentPreset / 工作区路径，registry 反查取不到回退 header.cwd，再取不到 NULL）；去重键扩展含作用域三元——跨作用域同标题不再物理合并；检索按当前会话作用域加权（命中 ×1.25、他 scope ×0.5 保留可见）。也走 feature_flags 白名单（面板可启停） |
 | `strictScope` | `false` | 作用域硬过滤（v0.8.0 引入，v0.8.1 起只认显式声明；依赖 `scopeEnabled`）：检索 / 注入 / 列表 / 单取四路过滤，**显式声明**收窄到他者作用域的记忆完全不可见；载体自动标注只降权保留可见——真正的物理隔离请用 sensitivity。会话身份解析不到时 fail-closed 只挡显式行。关闭时全部为软隔离（降权保留可见）。也走 feature_flags 白名单 |
+| `writeAdmission` | `{enabled:false, enforce:false}` | 写入准入（issue #254，默认关）：把「这条该不该进库」前移到 LLM 之前。第 1 级是零 LLM 的确定性判据——空白 / 纯噪声 + 密钥 / PII（判据来源是 #164 A2，经 `sensitiveScan` 注入，本批只定义接口）。`enabled` 跑判据并落审计行（`llm_audit_logs` 的 `metadata.deny`），`enforce` 才真的拒（`store.save` 之前返回，`memory_save` 返回 `action:"denied"` + `reason`）；只开 `enabled` = 仅告警、写入不拦。去重键命中不进第 1 级（归 write-update 放行），G1/G2 阈值只计量。也走 feature_flags 白名单 |
 | `conflictFreezeEnabled` | `false` | 冲突冻结（v0.4.4）：dream 发现矛盾对不自动裁决，冻结进冲突队列；状态页「冲突队列」支持并排对比与人工确认（保留 A / 保留 B / 仅标记已处理，v0.8.0） |
 | `conflictFreezeMaxPending` | `100` | 冲突冻结队列最大挂起数（1-1000）：超出后不再入队（防队列无限膨胀） |
 | `escapePromptVariables` | `true` | 注入文本花括号转义（v0.8.0 恢复，issue #162）：注入边界把 `{{...}}` 转义，防止 hot memory / 记忆原文里的 Go template / Vue 语法触发宿主 interpolate 抛错卡死会话（v0.7.4 曾修复、v0.7.11 误删） |
@@ -583,7 +584,7 @@ src/
 ├── api.js            # HTTP 路由（Web 面板数据通道，含 /conflicts 冲突队列）
 └── index.js          # 插件接线
 lib/                  # src 的同步分发产物（npm run sync；发布前由 root prepack 的 check-sync.js 校验一致性；唯一手写例外 lib/client.js——Web 面板 bundle，sync 不覆盖）
-test/                 # 1405 个 node:test 测试（审计与三轴线压测不变量；src↔lib 一致性由 scripts/check-sync.js 发布闸门校验）
+test/                 # 1431 个 node:test 测试（审计与三轴线压测不变量；src↔lib 一致性由 scripts/check-sync.js 发布闸门校验）
 scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压测 · sync-lib.js 同步 · check-sync.js 发布闸门 · benchmark-recall.js / benchmark-embed.js / benchmark-rerank.js 基准 · sync-test-badge.mjs 测试徽章 · build-runtime-manifest.mjs 运行时清单
 ```
 
@@ -592,7 +593,7 @@ scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压
 ```bash
 cd dsh-mneme
 npm install        # 安装 peer 依赖（以 devDependencies 形式，用于本地测试）
-npm test           # 运行 1405 个测试
+npm test           # 运行 1431 个测试
 npm run stress     # 三轴线压测：长会话检索 / 冲突仲裁 / 多 Agent 并发（离线 mock LLM）
 npm run sync       # 把 src/ 同步到 lib/（发布时由 prepack 钩子自动执行）
 ```

package/assets/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 16 16" fill="none" stroke="#4176e6" stroke-width="1" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M4.43 12.31C2.19 10.17 2.27 6.81 4.18 4.84C6.10 2.88 9.06 2.99 10.74 4.68C12.43 6.37 12.28 8.92 10.82 10.33C9.35 11.74 7.22 11.55 6.08 10.32C4.95 9.08 5.18 7.35 6.18 6.50C6.57 6.17 7.03 5.99 7.48 5.97"/>
+</svg>

package/lib/api-standalone.js

@@ -386,7 +386,7 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
             }
           }
           try {
-            const { action, memory } = service.saveWithDedupe({
+            const result = service.saveWithDedupe({
               type: body.type,
               title: body.title,
               content: body.content,
@@ -398,6 +398,16 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
               ...(body.agent_scope !== undefined ? { agent_scope: body.agent_scope, agent_scope_source: "explicit" } : {}),
               ...(body.workspace_scope !== undefined ? { workspace_scope: body.workspace_scope, workspace_scope_source: "explicit" } : {})
             });
+            const { action } = result;
+            // #254 写入准入：这条 HTTP 路径今天不带会话身份，evaluate 在无 sessionKey
+            // 时直接早退，所以拦不到；仍然显式分支——将来真接上会话身份时，落到
+            // `toApiList([null])` 上会变成 500，把「被拒」伪装成「服务器出错」，而
+            // 这两件事对调用方的处置完全不同（改内容 vs 重试）。
+            if (action === "denied") {
+              sendJson(res, 422, { error: "write-rejected", reason: result.reason });
+              return;
+            }
+            const { memory } = result;
             // action 随行透出（created/merged）：memory_save 工具语义对齐所需，
             // 附加键对既有消费方（CLI add 等）向后兼容。
             sendJson(res, action === "created" ? 201 : 200, { ...service.toApiList([memory])[0], action });

package/lib/api.js

@@ -135,9 +135,14 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
   ];
   // 嵌套键在 kv 里按点号平铺（"memoryQualityFilter.enabled"），运行时 cfg 里
   // 是嵌套对象，effective 从对象子字段取值；其余键照旧从 cfg 顶层取。
+  // 这张表必须与 settings.js 白名单里的点号键一一对应：#254 加键时漏了这里，
+  // effective 会静默少两个键（configFlagValue 取不到 undefined 就不写进去），
+  // 面板上看不出来、PUT 也存不进去——test/api.test.js 的计数锁就是钉这件事的。
   const NESTED_FLAG_PATHS = {
     "memoryQualityFilter.enabled": ["memoryQualityFilter", "enabled"],
-    "llmAudit.enabled": ["llmAudit", "enabled"]
+    "llmAudit.enabled": ["llmAudit", "enabled"],
+    "writeAdmission.enabled": ["writeAdmission", "enabled"],
+    "writeAdmission.enforce": ["writeAdmission", "enforce"]
   };
   function configFlagValue(key) {
     const path = NESTED_FLAG_PATHS[key];

package/lib/client.js

@@ -68,19 +68,37 @@ window.__ModuleLoader__.load({
       if (ops.filter((o) => o.kind !== "same").length > 200) return null;
       return ops;
     }
-    // #287 归档图标跨代兼容：primitives 在 0.1.7 把图标命名从「像素后缀」改成
-    // 「字重后缀」（IconArchiveOutline20 → …OutlineRegular / …OutlineMedium），
-    // 旧名不留别名，而 peerDependencies 同时覆盖 0.1.6 与 0.1.7 两代宿主——
-    // 只认某一代的名字，另一代就会取到 undefined，h(undefined) 即 React #130
-    // （整个 slot entry 崩掉）。故按「旧名 → 新名」顺序取第一个存在的；
-    // 两代都缺时降级为不渲染图标，宁可无图标也不把 slot 打崩。
-    const IconArchive = primitives.IconArchiveOutline20
-      ?? primitives.IconArchiveOutlineRegular
-      ?? primitives.IconArchiveOutlineMedium
-      ?? null;
-
-    /** 渲染归档图标；宿主未提供任一候选名时返回 null（无图标，不影响其余内容）。 */
-    const renderArchiveIcon = (props) => (IconArchive ? h(IconArchive, props) : null);
+    // --- mneme mark：插件自己的标识图标 -------------------------------------
+    // 不再借宿主的 IconArchiveOutline*，两个原因：
+    //  · 语义撞车——「归档盒」和记忆库里的归档动作是同一个符号，用户反馈看不出
+    //    这是记忆插件（issue 走维护者自开通道）；
+    //  · 宿主耦合——宿主图标名会换代（#287：Outline20 → OutlineRegular/Medium），
+    //    只认某一代就取到 undefined，h(undefined) 即 React #130 把整个 slot entry
+    //    崩掉。自绘后这一整类问题消失，也不再需要「探测多代名字 + 缺名降级」。
+    // 形状：单线螺旋（记忆痕迹 / 召回回路）。规格逐条对齐宿主图标，才不像外来户：
+    // 16 栅格、fill:none、stroke:currentColor、描边 1（宿主 Regular 档）、圆头圆角。
+    // 路径是 6 段三次贝塞尔拟合同一螺旋（拟合版与逐点采样版逐像素一致，已核验），
+    // 所以源码里只有 200 字符，不是一百多个采样点。
+    // 改形状只需换 MNEME_MARK_D，并同步 assets/icon.svg（插件列表那份，同一个 d）。
+    const MNEME_MARK_D = "M4.43 12.31C2.19 10.17 2.27 6.81 4.18 4.84C6.10 2.88 9.06 2.99 10.74 4.68C12.43 6.37 12.28 8.92 10.82 10.33C9.35 11.74 7.22 11.55 6.08 10.32C4.95 9.08 5.18 7.35 6.18 6.50C6.57 6.17 7.03 5.99 7.48 5.97";
+
+    /** mneme mark 的内联 SVG；currentColor + 描边 1，随主题与字号走。 */
+    const MnemeMark = ({ size = 16, className }) => h("svg", {
+      width: size,
+      height: size,
+      className,
+      viewBox: "0 0 16 16",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      "aria-hidden": "true",
+      stroke: "currentColor",
+      strokeWidth: 1,
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }, h("path", { d: MNEME_MARK_D }));
+
+    /** 渲染 mneme mark：四个入口（浮层标题栏 / footer 回退 / 侧边栏 portal / better-sidebar tab）共用同一颗。 */
+    const renderMnemeMark = (props) => h(MnemeMark, props);
 
     // Portal target for the hero fallback surface. The host whitelists
     // react-dom for its own bundles (dsh-client-ui-trajectory requires it);
@@ -415,6 +433,8 @@ window.__ModuleLoader__.load({
         "memory.features.autoSummarize.hint": "对话结束自动提炼记忆条目",
         "memory.features.hotMemoryEnabled": "热记忆",
         "memory.features.hotMemoryEnabled.hint": "最近几轮对话原文随注入携带，不写入长期记忆",
+        "memory.features.injectTimePrefix": "对话开始注入当前时间",
+        "memory.features.injectTimePrefix.hint": "每次新会话的首轮注入一次日期与星期（默认关）",
         "memory.features.entityExtractionEnabled": "实体抽取",
         "memory.features.entityExtractionEnabled.hint": "从记忆中提取人物/项目/概念，图谱随之生长",
         "memory.features.entityExtractionProvider": "实体抽取 Provider",
@@ -466,6 +486,13 @@ window.__ModuleLoader__.load({
         "memory.features.memoryQualityFilter.enabled.hint": "低价值记忆自动归档，注入按质量降权",
         "memory.features.llmAudit.enabled": "后台调用审计",
         "memory.features.llmAudit.enabled.hint": "记录巩固/总结的后台模型调用与 token 消耗",
+        // #254：写入准入两层。检测关时整条路径不碰；检测开、拦截关 = 仅告警 +
+        // 留审计；两个都开才真拦。文案要写清「只留审计」与「真拦下」的区别，
+        // 否则操作者会以为打开检测就已经在拦。
+        "memory.features.writeAdmission.enabled": "写入准入判定",
+        "memory.features.writeAdmission.enabled.hint": "写入前判空白/噪声，命中留审计（不拦）",
+        "memory.features.writeAdmission.enforce": "写入准入拦截",
+        "memory.features.writeAdmission.enforce.hint": "真拦下命中的写入；关闭时只留审计不拦",
         "memory.features.bm25SearchEnabled": "BM25 关键词检索",
         "memory.features.bm25SearchEnabled.hint": "传统关键词打分检索，与向量召回互补",
         "memory.features.conflictFreezeEnabled": "冲突冻结",
@@ -839,6 +866,8 @@ window.__ModuleLoader__.load({
         "memory.features.autoSummarize.hint": "Distill memory entries when a conversation ends",
         "memory.features.hotMemoryEnabled": "Hot memory",
         "memory.features.hotMemoryEnabled.hint": "Carry the last few turns verbatim; never written to long-term memory",
+        "memory.features.injectTimePrefix": "Inject current time at conversation start",
+        "memory.features.injectTimePrefix.hint": "Adds the date and weekday once at each new session's first turn (off by default)",
         "memory.features.entityExtractionEnabled": "Entity extraction",
         "memory.features.entityExtractionEnabled.hint": "Extract people / projects / concepts so the graph grows by itself",
         "memory.features.entityExtractionProvider": "Entity extraction provider",
@@ -890,6 +919,12 @@ window.__ModuleLoader__.load({
         "memory.features.memoryQualityFilter.enabled.hint": "Archive low-value memories automatically; injection downranks by quality",
         "memory.features.llmAudit.enabled": "Background call audit",
         "memory.features.llmAudit.enabled.hint": "Log background model calls and token usage from consolidation / summaries",
+        // #254 — two layers: enabled runs the check (audit only), enforce actually
+        // blocks. The hints must keep that difference explicit.
+        "memory.features.writeAdmission.enabled": "Write admission checks",
+        "memory.features.writeAdmission.enabled.hint": "Flag blank / noise writes before storing, with an audit row (never blocks)",
+        "memory.features.writeAdmission.enforce": "Write admission enforcement",
+        "memory.features.writeAdmission.enforce.hint": "Actually reject flagged writes; off keeps the audit row only",
         "memory.features.bm25SearchEnabled": "BM25 keyword search",
         "memory.features.bm25SearchEnabled.hint": "Classic keyword scoring, complementary to vector recall",
         "memory.features.conflictFreezeEnabled": "Conflict freezing",
@@ -1311,11 +1346,26 @@ window.__ModuleLoader__.load({
       ".mneme-heat--warm{color:var(--dsw-alias-label-secondary)}",
       ".mneme-heat--cold{color:var(--dsw-alias-label-tertiary)}",
       ".mneme-heat--cold .mneme-heatpct{display:none}",
-      // 纵向 flex 容器按原生按钮的宽度与外边距分配空间，保留展开和收起态的对齐。
+      // 侧边栏入口两种形态的样式（挂载与搬移逻辑见 SidebarTopEntry 的头注释）。
+      // 展开态兜底：逐条镜像宿主 panelRow（36px 行高 / 透明底 / 2px 外边距 /
+      // 7px 8px 内边距）——宿主面板行类名在或不在，观感都是「插件 / 自动化任务」
+      // 那一档，不会再退回 v0.8.10 那种高亮大按钮。
+      // 收起态：按钮带宿主 newSession 类名，标题栏固定几何（position:fixed、
+      // 顶部居中、28px 圆钮、次级文字色、hover 填充）整套继承宿主规则，我们只用
+      // 一条更具体的规则把 left 从宿主的 48px 推到 84px——即「新会话」右侧，
+      // 不再像 v0.8.10 那样压在它身上（用户实测确认的遮挡 bug）。
+      // 84 = 48（宿主给「新会话」的 left）+ 28（钮宽）+ 8（间距）；120 = 84 + 28 + 8，
+      // 让「应用 / 编辑」菜单顺延到我们右侧。宿主侧出处：SidebarRoot.module.css 的
+      // `.collapsed .newSession{left:48px}` 与
+      // `html[data-windows-titlebar]:has([data-sidebar-collapsed=true]){--dsh-windows-menu-start:84px}`。
       ".mneme-topentry{display:flex;flex-direction:column;position:relative}",
-      ".mneme-topentry-native{background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-primary)}",
+      ".mneme-topentry-native{box-sizing:border-box;min-height:36px;border:none;border-radius:var(--dsw-radius-md);background:0 0;color:var(--dsw-alias-label-primary);font:inherit;text-align:left;cursor:pointer;align-items:center;gap:8px;margin:0 2px;padding:7px 8px;line-height:22px;display:flex}",
       ".mneme-topentry-native:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
+      ".mneme-topentry-native:focus-visible{outline:var(--dsw-focus-ring-width) solid var(--dsw-focus-ring-color,var(--dsw-alias-state-business-primary));outline-offset:-2px}",
       ".mneme-topentry-native .mneme-topentry-label{white-space:nowrap}",
+      "html[data-windows-titlebar] .mneme-topentry .mneme-topentry-rail{left:84px}",
+      // 菜单让位只在「收起 + 入口确实挂在标题栏里」时生效；展开态完全不碰宿主变量。
+      "html[data-windows-titlebar]:has([data-sidebar-collapsed=true]):has([data-plugin-entry=\"@modusensus/dsh-mneme\"]){--dsh-windows-menu-start:120px}",
       // --- 功能开关：一行一开关，Claude 式安静排版 ---
       ".mneme-featgroup{flex:none;font-size:12px;font-weight:600;letter-spacing:.02em;color:var(--dsw-alias-label-tertiary);margin:16px 0 2px}",
       ".mneme-featrow{display:flex;align-items:center;gap:14px;padding:11px 2px;border-bottom:1px solid var(--dsw-alias-border-l1)}",
@@ -2072,7 +2122,7 @@ window.__ModuleLoader__.load({
     // test/inject-parent-gate.test.js 钉住。
     const FEATURE_CHILDREN = { autoInject: ["injectGuidanceEnabled", "continuityRescueEnabled"] };
     const FEATURE_GROUPS = [
-      { key: "group.core", items: ["autoInject", "autoSummarize", "hotMemoryEnabled", "memoryQualityFilter.enabled", "llmAudit.enabled"] },
+      { key: "group.core", items: ["autoInject", "autoSummarize", "hotMemoryEnabled", "injectTimePrefix", "memoryQualityFilter.enabled", "llmAudit.enabled", "writeAdmission.enabled", "writeAdmission.enforce"] },
       { key: "group.enhance", items: ["entityExtractionEnabled", "codingRetrospect", "rerankEnabled", "resilientModelDownload", "searchSemanticDedup", "bm25SearchEnabled", "heatEnabled", "documentMemoryEnabled"] },
       { key: "group.dream", items: ["autoDream", "sleepModeEnabled"] },
       // v0.8.0 A4（issue #17）：作用域隔离组——标注总开关 + 严格硬过滤。
@@ -3014,6 +3064,10 @@ window.__ModuleLoader__.load({
     // MemoryExplorer 内部状态（选中行、过滤）由各自的跳转回调处理。
     function openLibrary() {
       setOverlayOpen(true);
+      // 打开面板 = 用户正准备处理冻结冲突：顺手把入口红点重取一次，别让他
+      // 对着一个已经过期的计数（裁决走别的路径、或后台 autoDream 刚写过库时，
+      // 计数不该等 60s 兜底轮询才对齐）。
+      conflictBadgeCount.refresh();
     }
 
     // --- Hero fallback overlay state (module-level pub/sub) ---
@@ -3081,7 +3135,7 @@ window.__ModuleLoader__.load({
         h("div", { className: "mneme-overlay", role: "region", "aria-label": t("memory.view.label"), ref: panelRef },
           h("div", { className: "mneme-overlaybar" },
             h("span", { className: "mneme-overlaytitle" },
-              renderArchiveIcon({ size: 15 }),
+              renderMnemeMark({ size: 15 }),
               t("memory.view.label")
             ),
             h("button", {
@@ -4907,32 +4961,80 @@ window.__ModuleLoader__.load({
       );
     }
 
-    // --- Sidebar entry: 工作区上方的记忆按钮 ---
+    // --- Sidebar entry: 侧边栏里的记忆入口 ---
     // 注册仍在 sidebar.footer.action（list 插槽）——它既是 React 树的挂载
-    // 锚点，也是 portal 失效时的原位回退。真实按钮 portal 插到「新会话」行
-    // 之后、插件入口组的最前：任务看板/技能中心等生态插件也把入口插在新会话
-    // 行后（它们的后插入者在上），若我们固定在 regionArea 之前就会被打成
-    // 入口组末尾的孤立位（issue #130），所以观察器发现错位就搬回锚点位。
-    // 几何对齐方案：读取宿主「新会话」按钮的实时 className 原样套用，再用
-    // 我们的修饰类覆盖配色（次级观感）。这样展开态与收起态（rail）都直接
-    // 继承宿主自己的盒模型与间距——宿主改版/缩进动画零位移，无需硬编码。
+    // 锚点，也是 portal 失效时的原位回退；常驻 sheet 也从这个插槽挂载。
+    // 入口形状跟着宿主 v0.2 的侧边栏走，分两态：
+    //  · 展开态：宿主把「插件 / 自动化任务」这类全局面板渲染成 nav.panelList
+    //    里的 panelRow（36px 行高、透明底、图标 + 标题）。我们把按钮 portal 进
+    //    同一组并原样套用宿主 panelRow 的实时类名，于是它是该组的第三行——低调，
+    //    而不是 v0.8.10 那样长得像第二个高亮「新会话」按钮。
+    //  · 收起态（Windows 标题栏）：panelList / regionArea / footArea 被宿主
+    //    display:none，只有开关与「新会话」被改成固定在标题栏上。我们把按钮搬回
+    //    标题栏、并排在「新会话」右侧（84px / 120px 的算法见上面 CSS 注释），
+    //    三颗图标各就各位——v0.8.10 把入口留在宿主的 48px 上把它盖住了。
+    // 承载类名一律从活元素读取（宿主/皮肤会异步改写哈希类名），不硬编码；
+    // 面板列表不存在（没装任何面板插件）时退回「新会话」行之后。
     // 宿主结构异常时约 2 秒后放弃 portal，footer 回退按钮保持可用。
-    // #177：未处理冲突数 badge——数据走 dream-status 的 pendingConflicts（状态卡
-    // 同一端点），60s 轮询 + 打开面板即刷新。挂侧边栏入口按钮右上角（portal 与
-    // 回退两处都挂），让用户不进面板也知道有冻结要裁决。
-    function useConflictBadgeCount(t) {
-      const [pending, setPending] = useState(0);
+    // #177：未处理冲突数 badge——数据走 dream-status 的 pendingConflicts（与状态卡
+    // 同一端点）。挂侧边栏入口按钮右上角（portal 与回退两处都挂），让用户不进面板
+    // 也知道有冻结要裁决。
+    // 刷新时机（用户反馈「裁决完红点消失得很慢」后重做）：
+    //  · 裁决成功时冲突队列广播 mneme:conflicts-changed → 立刻重取，不必等下一轮；
+    //    此前这条广播只有状态卡订阅，红点漏订，才慢到要等 60s 兜底轮询；
+    //  · openLibrary 打开面板时重取（见上）；
+    //  · 60s 兜底轮询——后台 autoDream 自己产生/消解冲突时没人广播，靠它浮现。
+    // 计数是模块级单例：入口按钮的 portal 与 footer 回退是两个组件，原先各起一个
+    // 60s 轮询（两份请求、两个互不同步的计数）。现在共享一个 store：一次取回广播给
+    // 全部订阅者，in-flight 请求也去重，最后一个订阅者离开才停表。
+    const conflictBadgeCount = (() => {
+      const listeners = new Set();
+      let value = 0;
+      let timer = null;
+      let inflight = null;
+      const publish = (next) => {
+        if (next === value) return;
+        value = next;
+        listeners.forEach((fn) => {
+          try { fn(value); } catch { /* 单个订阅者出错不拖垮其余 */ }
+        });
+      };
+      const refresh = () => {
+        if (inflight) return inflight;
+        inflight = apiFetch("/api/dsh-mneme/dream-status")
+          .then((res) => (res.ok ? res.json() : { pendingConflicts: 0 }))
+          .then((d) => { publish(Number((d && d.pendingConflicts) ?? 0) || 0); })
+          .catch(() => { publish(0); })
+          .finally(() => { inflight = null; });
+        return inflight;
+      };
+      return {
+        get: () => value,
+        refresh,
+        subscribe: (fn) => {
+          listeners.add(fn);
+          fn(value);
+          if (listeners.size === 1) {
+            refresh();
+            timer = setInterval(refresh, 60_000);
+          }
+          return () => {
+            listeners.delete(fn);
+            if (listeners.size === 0 && timer !== null) { clearInterval(timer); timer = null; }
+          };
+        }
+      };
+    })();
+    function useConflictBadgeCount() {
+      const [pending, setPending] = useState(() => conflictBadgeCount.get());
       useEffect(() => {
-        let cancelled = false;
-        const tick = () => {
-          apiFetch("/api/dsh-mneme/dream-status")
-            .then((res) => (res.ok ? res.json() : { pendingConflicts: 0 }))
-            .then((d) => { if (!cancelled) setPending(Number((d && d.pendingConflicts) ?? 0) || 0); })
-            .catch(() => { if (!cancelled) setPending(0); });
+        const unsubscribe = conflictBadgeCount.subscribe(setPending);
+        const onChanged = () => { conflictBadgeCount.refresh(); };
+        window.addEventListener("mneme:conflicts-changed", onChanged);
+        return () => {
+          unsubscribe();
+          window.removeEventListener("mneme:conflicts-changed", onChanged);
         };
-        tick();
-        const timer = setInterval(tick, 60_000);
-        return () => { cancelled = true; clearInterval(timer); };
       }, []);
       return pending;
     }
@@ -4942,7 +5044,7 @@ window.__ModuleLoader__.load({
         pending > 99 ? "99+" : String(pending));
     }
     function SidebarFallbackTrigger({ wide, t }) {
-      const pending = useConflictBadgeCount(t);
+      const pending = useConflictBadgeCount();
       // #295 评审：.mneme-trigger 自身 overflow:hidden 且无定位上下文，badge
       // 直接放里面会被裁剪——包一层定位容器，badge 挂在容器上。
       return h("div", { className: "mneme-triggerwrap" },
@@ -4956,7 +5058,7 @@ window.__ModuleLoader__.load({
           onClick: openLibrary,
           "data-mneme-overlay-opener": "true"
         },
-          renderArchiveIcon({ size: wide ? 16 : 18 }),
+          renderMnemeMark({ size: wide ? 16 : 18 }),
           wide && h("span", { className: "mneme-trigger-label" }, t("memory.panel.open"))
         ),
         h(ConflictBadge, { pending })
@@ -4965,14 +5067,25 @@ window.__ModuleLoader__.load({
 
     function SidebarTopEntry({ wide, t, fallback }) {
       const [host, setHost] = useState(null);
-      const [nativeCls, setNativeCls] = useState("");
-      const pending = useConflictBadgeCount(t);
+      const [cls, setCls] = useState({ row: "", glyph: "", title: "" });
+      const pending = useConflictBadgeCount();
       useEffect(() => {
         if (!reactDom || typeof document === "undefined") return undefined;
         let tries = 0, timer = null, created = null, mo = null;
+        const findRegion = () => {
+          const region = document.querySelector('[class*="regionArea"]');
+          return region && region.parentElement ? region : null;
+        };
         const findNative = (region) =>
           region.parentElement.querySelector('[class*="newSession"]')
           || region.previousElementSibling;
+        const findPanelList = (region) =>
+          region.parentElement.querySelector('[class*="panelList"]');
+        // 宿主自己的面板行：排除我们自己 portal 进去的那颗按钮（它也带 panelRow）。
+        const findPanelRow = (region) => {
+          const list = findPanelList(region);
+          return list ? list.querySelector('[class*="panelRow"]:not(.mneme-topentry-native)') : null;
+        };
         // 占位锚点：新会话行（现役外壳里 newSession 按钮嵌在 logoRow 内，
         // 旧外壳是根的直接子按钮）。判定与生态插件的 sidebar-entry-core
         // 一致；锚点不可靠时回退到 regionArea 之前的旧位置。
@@ -4991,32 +5104,61 @@ window.__ModuleLoader__.load({
         // insertBefore(x, x) 在 Chromium 里不是 no-op，会触发 mutation 造成
         // 观察器自激风暴、冻死整个 SPA。
         const place = (region) => {
+          if (!created) return;
           const parent = region.parentElement;
           if (!parent) return;
+          // 展开态落进宿主的面板列表（紧跟「插件 / 自动化任务」）；宿主没有面板
+          // 列表时退回「新会话」行之后，由 .mneme-topentry-native 兜住低调行样式。
+          const list = wide ? findPanelList(region) : null;
+          if (list) {
+            if (created.parentElement === list && created === list.lastElementChild) return;
+            list.appendChild(created);
+            return;
+          }
           const anchor = findAnchor(region);
           const target = anchor ? anchor.nextSibling : region;
           if (target === created) return;
           if (created.parentElement === parent && created.nextSibling === target) return;
           parent.insertBefore(created, target);
         };
+        // 类名一律从活元素读。展开态借宿主面板行的盒模型，并剔掉激活态修饰类
+        // （否则我们的行会跟着宿主当前选中的面板一起常亮）；收起态借「新会话」
+        // 按钮的类名拿整套标题栏固定几何。两处都取不到时留空，由我们的类兜底。
+        const readCls = (region) => {
+          if (!wide) return { row: findNative(region)?.className || "", glyph: "", title: "" };
+          const row = findPanelRow(region);
+          const btn = row || findNative(region);
+          const glyph = row && row.querySelector('[class*="panelGlyph"]');
+          const title = row && row.querySelector('[class*="panelTitle"]');
+          return {
+            row: (btn?.className || "")
+              .split(/\s+/)
+              .filter((name) => name && !name.includes("panelActive"))
+              .join(" "),
+            glyph: (glyph && glyph.className) || "",
+            title: (title && title.className) || ""
+          };
+        };
+        const sync = (region) => {
+          const next = readCls(region);
+          setCls((prev) => (prev.row === next.row && prev.glyph === next.glyph && prev.title === next.title ? prev : next));
+        };
         const attempt = () => {
-          const region = document.querySelector('[class*="regionArea"]');
-          if (region && region.parentElement) {
-            // 「新会话」按钮与 regionArea 同级且紧邻其前，借它的类名获得
-            // 与原生侧边栏项完全一致的盒模型（含收起态 rail 几何）。
-            // 宿主/皮肤会异步改写按钮类名，用 MutationObserver 持续同步，
-            // 否则 portal 按钮会停留在捕获时刻的旧类上（宽度/对齐失配）。
+          const region = findRegion();
+          if (region) {
+            // 宿主切换展开/收起时会重排 DOM（面板列表 → 标题栏固定位），所以每次
+            // 变动都重新落位并重读类名；宿主/皮肤异步改写类名也靠这条同步，否则
+            // portal 按钮会停留在捕获时刻的旧类上（宽度/对齐失配）。
             created = document.createElement("div");
             created.dataset.pluginEntry = "@modusensus/dsh-mneme";
             place(region);
             setHost(created);
-            setNativeCls(findNative(region)?.className || "");
+            sync(region);
             mo = new MutationObserver(() => {
-              const cur = document.querySelector('[class*="regionArea"]');
-              if (!cur || !cur.parentElement) return;
+              const cur = findRegion();
+              if (!cur) return;
               place(cur);
-              const cls = findNative(cur)?.className || "";
-              setNativeCls((prev) => (prev === cls ? prev : cls));
+              sync(cur);
             });
             mo.observe(region.parentElement, {
               attributes: true,
@@ -5035,13 +5177,19 @@ window.__ModuleLoader__.load({
           if (mo) mo.disconnect();
           if (created && created.parentElement) created.parentElement.removeChild(created);
         };
-      }, []);
+      }, [wide]);
       if (!host) return fallback;
+      // 图标与「插件 / 自动化任务」同档（16px）；收起态沿用标题栏里原来的 18px。
+      const icon = renderMnemeMark({ size: wide ? 16 : 18 });
       return reactDom.createPortal(
         h("div", { className: "mneme-topentry" },
           h("button", {
             type: "button",
-            className: `${nativeCls} mneme-topentry-native`.trim(),
+            // 展开态：宿主面板行类名 + 我们的同款兜底；收起态：宿主「新会话」类名
+            // + 只覆盖 left 的 rail 规则（整套标题栏几何继承宿主）。
+            className: wide
+              ? `${cls.row} mneme-topentry-native`.trim()
+              : `${cls.row} mneme-topentry-rail`.trim(),
             "aria-label": pending > 0
               ? `${t("memory.sidebar.aria")} · ${t("memory.status.conflicts")} ${pending}`
               : t("memory.sidebar.aria"),
@@ -5049,8 +5197,9 @@ window.__ModuleLoader__.load({
             onClick: openLibrary,
             "data-mneme-overlay-opener": "true"
           },
-            renderArchiveIcon({ size: wide ? 15 : 18 }),
-            wide && h("span", { className: "mneme-topentry-label" }, t("memory.panel.open")),
+            // 图标套上宿主面板行的槽位类名，视觉与同组入口完全一致；取不到时裸渲染。
+            cls.glyph ? h("span", { className: cls.glyph, "aria-hidden": "true" }, icon) : icon,
+            wide && h("span", { className: `${cls.title} mneme-topentry-label`.trim() }, t("memory.panel.open")),
             h(ConflictBadge, { pending })
           )
         ), host);
@@ -5111,7 +5260,7 @@ window.__ModuleLoader__.load({
                   reg.registerTab({
                     id: TAB_ID,
                     title: () => t("memory.view.label"),
-                    icon: (size) => renderArchiveIcon({ size }),
+                    icon: (size) => renderMnemeMark({ size }),
                     order: 60,
                     component: () => h(MemoryExplorer, { t })
                   });

package/lib/config.js

@@ -71,6 +71,9 @@ export const Config = z.object({
   // 提示：上限/原长/全文 memory_get 指引（BUDGET_EXCEEDED 原则——绝不静默）。
   // 默认 300 = 与既有行为一致。
   injectContentMaxChars: z.natural().min(60).max(4000).default(300),
+  // Issue #34（v0.7.2 引入；v0.7.11 误删后随 #333 恢复）：对话开始注入一次当前
+  // 时间。默认关 = 与既有行为一致；格式与键名不变，存量 feature_flags 恢复即生效。
+  injectTimePrefix: z.boolean().default(false),
   importanceThreshold: z.natural().min(1).max(5).default(3),
   // Issue #239（第 5 项）：注入条数的查询自适应（默认关）。确定性强的话题收缩注入
   // 条数（减半、下限 1），模糊话题（回指/时间线索，或极短查询）维持
@@ -588,6 +591,29 @@ export const Config = z.object({
     retentionDays: z.natural().min(1).max(3650).default(90)
   }).default({}),
 
+  // --- write admission (#254) ------------------------------------------------
+  // 写入准入：把「这条该不该进库」前移到 LLM 之前。与 memoryQualityFilter 的分工
+  // 是时点不是判据——那个是**写入后**打分归档（扣分可以错，只影响排序与归档），
+  // 这个是**写入前**判定（硬拒不能错）。
+  //
+  // 两个开关都默认关（验收第 1 条「默认关零行为变化」）：
+  //   enabled — 跑第 1 级确定性判据。关时 evaluate 的返回与只计量那一阶段逐字段
+  //     一致，写入路径完全不碰。
+  //   enforce — 命中时真的拒绝。关时判据照跑、审计照留，决策回落 allow（仅告警）。
+  //     读审计时「metadata.deny 非空且 metadata.decision=allow」就是这一档的指纹。
+  // 分层是为了能把「先观察」和「开始拦」分成两次上线：enforce 打开前先在真实流量
+  // 里看误杀面，而不是靠回滚开关当保险。
+  //
+  // 第 1 级的判据面刻意收窄到两类：密钥/PII（#164 A2 是判据来源，经
+  // createWriteAdmission 的 sensitiveScan 注入；本批只定义它怎么被消费）与空白/
+  // 纯噪声文本。去重键命中**不**进第 1 级——按维护者 09-22 的判定归 write-update
+  // 放行（2606.24535 的失效模式：同步近重复门跑在异步矛盾检测之前，把本该被裁决
+  // 的矛盾直接拒掉）；G1/G2 的阈值继续只计量，等遥测有分布再单独提。
+  writeAdmission: z.object({
+    enabled: z.boolean().default(false),
+    enforce: z.boolean().default(false)
+  }).default({}),
+
   // --- recall evaluation: test-result storage (v0.4.6, 方案 B) --------------
   // Separate retrieval evaluation snapshots from the production recall audit.
   // When false (default) evaluateRetrieval still computes precision/recall/mrr

package/lib/index.js

@@ -272,10 +272,16 @@ export const apply = (ctx, config) => {
     documentIndex.remove();
   }
 
-  // 写入准入实例：本批次只做计量（决策恒放行、写审计行），所以不需要新开关——它
-  // 不改变任何写入行为，也不新增拦截分支；既有的 llmAudit.enabled 关掉时它同样
-  // 不写（那个开关连审计行的启动期清理一起关掉）。第二阶段把拦截打开时才按仓库
-  // 惯例引入 opt-in 默认关的配置键，届时只改这一个实例的构造与 service 的调用点。
+  // 写入准入实例（#254）。两个开关 writeAdmission.enabled / .enforce 都默认关；
+  // 关时它的返回与只计量那一阶段逐字段一致，写入路径完全不碰。既有的
+  // llmAudit.enabled 关掉时它同样既不判也不写（那个开关连审计行的启动期清理一起
+  // 关掉，在无保留期的表里按写入频次增长是不能接受的）。
+  //
+  // sensitiveScan 是密钥 / PII 那一类判据的注入点。按 #254 验收第 4 条它是 #164 A2
+  // 的判据来源（A2 记在维护者排期里），所以本批不实现它，只把接口形状定在这里——
+  // 接上时只改这一行：
+  //   createWriteAdmission({ ..., sensitiveScan: createSensitiveScan({ config: cfg }) })
+  // 缺省 null 时第 1 级只跑空白 / 噪声两类判据，其余一切照旧。
   const writeAdmission = createWriteAdmission({ store, config: cfg, logger: ctx.logger });
   const service = createService({ store, mirror, config: cfg, logger: ctx.logger, documentIndex, writeAdmission });