@modusensus/dsh-mneme 0.8.9 → 0.8.10

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-1431%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/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

@@ -415,6 +415,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 +468,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 +848,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 +901,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",
@@ -2072,7 +2089,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）：作用域隔离组——标注总开关 + 严格硬过滤。

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 });
 

package/lib/inject.js

@@ -16,6 +16,23 @@ export function getInjectionSnapshot() {
   return injectionSnapshot;
 }
 
+// Issue #334：UTF-16 截断切开 emoji 代理对会留下孤立代理项（如 🔴 = D83D DD34
+// 在 800 处切，D83D 留下、DD34 被切走）。DSH 把它序列化成非法 UTF-8，DeepSeek
+// API 对每个请求回 400 INVALID_REQUEST——而且畸形文本随注入消息被永久写进会话
+// 历史，此后**每一轮**都带着它，表现为会话从某一轮起连续 400、换话题/重启都不
+// 恢复（会话级不可逆损坏）。防法是「少一个字符都行，绝不留半个」：尾字符是
+// 高位代理（0xD800–0xDBFF）说明它的低位搭档被切走了，把这个高位代理整个丢掉。
+// （反过来尾字符是低位代理不可能孤立——它的搭档必然紧邻在前、同在切点之内。）
+// ASCII-only 的文本零开销（length 相等直接短路）。
+function safeSlice(text, limit) {
+  const s = String(text);
+  if (s.length <= limit) return s;
+  let cut = s.slice(0, limit);
+  const tail = cut.charCodeAt(cut.length - 1);
+  if (tail >= 0xd800 && tail <= 0xdbff) cut = cut.slice(0, -1);
+  return cut;
+}
+
 // Best-effort extraction of the current user's latest message text from the
 // live session, for semantic-first injection (Bug4). The system-prompt
 // interpolator renders synchronously, so this walks the already-materialized
@@ -36,11 +53,13 @@ function lastUserQuery(ctx) {
       if (kind !== undefined && kind !== "user") continue;
       const parts = event.data?.content;
       if (!Array.isArray(parts) || parts.length === 0) continue;
-      return parts
-        .map((p) => (typeof p === "string" ? p : p?.text ?? ""))
-        .filter(Boolean)
-        .join("\n")
-        .slice(0, 500);
+      return safeSlice(
+        parts
+          .map((p) => (typeof p === "string" ? p : p?.text ?? ""))
+          .filter(Boolean)
+          .join("\n"),
+        500
+      );
     }
   } catch { /* session internals unavailable: degrade to no query */ }
   return "";
@@ -85,7 +104,7 @@ function extractRounds(ctx, maxRounds) {
       const isUser = event?.type === "user/message" && (kind === undefined || kind === "user");
       if (isUser) {
         if (pendingQuery) rounds.push({ query: pendingQuery, response: "" });
-        pendingQuery = textOf(event).slice(0, 500);
+        pendingQuery = safeSlice(textOf(event), 500);
         continue;
       }
       // Only assistant-originated events close a round; tool/system events
@@ -94,7 +113,7 @@ function extractRounds(ctx, maxRounds) {
         || kind === "assistant";
       const body = isAssistant ? textOf(event) : "";
       if (!body || !pendingQuery) continue;
-      rounds.push({ query: pendingQuery, response: body.slice(0, 800) });
+      rounds.push({ query: pendingQuery, response: safeSlice(body, 800) });
       pendingQuery = null;
     }
     if (pendingQuery) rounds.push({ query: pendingQuery, response: "" });
@@ -171,7 +190,7 @@ export function createInjector(ctx, service, settings, config) {
   function injectMemory(m, maxLength = maxContent) {
     const text = String(m?.content ?? "");
     if (text.length <= maxLength) return text;
-    return `${text.slice(0, maxLength)}…${STR.truncatedHint[language](maxLength, text.length, m.id)}`;
+    return `${safeSlice(text, maxLength)}…${STR.truncatedHint[language](maxLength, text.length, m.id)}`;
   }
 
   // Prompt-variable brace escaping (issue #162, restored from v0.7.4 #40):
@@ -192,6 +211,41 @@ export function createInjector(ctx, service, settings, config) {
     return String(text).replace(/[{}]{2,}/g, (run) => run.split("").join("\\"));
   }
 
+  // Time-prefix injection (issue #34，恢复于 #333): opt-in, off by default.
+  // When enabled the current date/time is injected once per conversation — at
+  // the first prompt assembly of a new session — so the model can sense what
+  // time/day it is. A per-session latch means later assemblies in the same
+  // session never re-inject; a bare render ctx (no session id) falls back to
+  // once per injector lifetime.
+  // v0.7.11 面板大改版（ce4658e）时这段随一次批量删除被静默移除，CHANGELOG 无
+  // 登记（#162 的 escapePromptVars 同刀误删、后来恢复，本函数漏了）——用户按
+  // CHANGELOG 开着开关，实际什么都不会发生。本次按 v0.7.2 语义原样恢复：键名、
+  // 默认值（false）、格式 `[当前时间: YYYY-MM-DD 周X HH:MM]` 全部不变，存量
+  // feature_flags 里的配置恢复即生效。
+  // 已注入过时间前缀的会话集合（#335 review：单值闩锁在 A→B→A 交替渲染下会
+  // 重复注入）。上限 500 防长驻进程无界增长，超限逐出最早记录。
+  const timePrefixDone = new Set();
+  let timePrefixBare = false;
+
+  function renderTimePrefix(ctx) {
+    if (config.injectTimePrefix !== true) return "";
+    const sessionId = ctx?.agent?.session?.id;
+    if (sessionId === undefined) {
+      if (timePrefixBare) return "";
+      timePrefixBare = true;
+    } else {
+      if (timePrefixDone.has(sessionId)) return "";
+      if (timePrefixDone.size >= 500) timePrefixDone.delete(timePrefixDone.keys().next().value);
+      timePrefixDone.add(sessionId);
+    }
+    const WEEKDAYS = ["周日", "周一", "周二", "周三", "周四", "周五", "周六"];
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+    const time = `${pad(now.getHours())}:${pad(now.getMinutes())}`;
+    return escapePromptVars(`[当前时间: ${date} ${WEEKDAYS[now.getDay()]} ${time}]`);
+  }
+
   // Hot memory (v0.5.0 1.3): the latest rounds of THIS session, rebuilt from
   // the materialized event log on every render — stateless, so it survives
   // session switches and never persists anywhere.
@@ -335,7 +389,12 @@ export function createInjector(ctx, service, settings, config) {
         // separate context) keeps the prompt assembly stable at two blocks.
         const hotText = renderHotContext(ctx);
         const body = render(candidates, pinnedStats);
-        const finalBody = !hotText ? body : body ? `${hotText}\n\n${body}` : hotText;
+        // #333（issue #34 恢复）：时间前缀只在会话首轮出现（per-session 闩锁），
+        // 排在整个记忆块的最前——模型先知道「今天几号」，再看热上下文与长期记忆。
+        const timePrefix = renderTimePrefix(ctx);
+        // 拼接次序：时间 → 热上下文 → 长期记忆（三者都可能为空，逐级判空拼接）。
+        const withHot = !hotText ? body : body ? `${hotText}\n\n${body}` : hotText;
+        const finalBody = !timePrefix ? withHot : withHot ? `${timePrefix}\n\n${withHot}` : timePrefix;
         // Issue #179：旁路缓存一帧——面板「注入预览」卡据此展示构成与体积。
         // chars 为条目内容的截断后近似值（与 render 同一函数计长），totalChars
         // 是本次实际返回块的精确长度。maxItems 反映自适应收缩后的生效值。

package/lib/service.js

@@ -1250,9 +1250,12 @@ export function createService({ store, mirror, config, onWrite, logger, document
       scheduleEmbed(result);
       return { action: "merged", memory: result };
     }
-    // #254 写入准入（第一阶段只计量）：决策恒 allow、不拦写入，只把两个闸门的
-    // 测量点算出来。放在 store.save 之前——第二阶段要在这里拦下写入，接缝先摆好。
-    // 计量是旁路：任何一环失败只 warn，绝不反噬写入（与质量打分同款容错）。
+    // #254 写入准入：决策形状由 write-admission.js 一次定死（阶段一定死、之后只加
+    // 分支），这里只做两件事——先问决策，再在 enforce 命中时**在 store.save 之前**
+    // 返回。放在 store.save 之前是这条闸门的意义所在：写进去再删等于没拦，而且中间
+    // 那一瞬的注入/检索面已经暴露了。
+    // 计量是旁路，拒绝不是：evaluate 抛异常按「不判定」处理（宁可漏拦也不能让判据
+    // 故障把写入变成不可用），record 抛异常同样只 warn（审计失败不能反噬写入）。
     let admission = null;
     if (writeAdmission) {
       try {
@@ -1261,6 +1264,23 @@ export function createService({ store, mirror, config, onWrite, logger, document
         try { logger?.warn?.(`[dsh-mneme] write admission evaluate failed: ${String(e)}`); } catch { /* 不反噬 */ }
       }
     }
+    // 第 1 级硬拒（enforce 打开且判据命中）：这次写入不落库、不通知、不排嵌入、
+    // 不抽实体。审计行仍然要落——拒绝面是这条闸门唯一可解释性的来源（验收第 2 条
+    // 「被拒写入有审计与明确原因、可解释不静默丢弃」）。memoryId 传 null：这次写入
+    // 没有产生任何行，related_memory_ids 必须空着，挂一个不存在的 id 就是造虚账。
+    // reason 随返回值透出，工具层据此给模型一句可行动的拒绝理由。
+    if (admission?.decision === "deny") {
+      try {
+        writeAdmission.record({
+          sessionKey: memory._sessionKey,
+          verdict: admission,
+          memoryId: null
+        });
+      } catch (e) {
+        try { logger?.warn?.(`[dsh-mneme] write admission record failed: ${String(e)}`); } catch { /* 不反噬 */ }
+      }
+      return { action: "denied", reason: admission.deny?.reason ?? "denied", deny: admission.deny ?? null, memory: null };
+    }
     const created = store.save({
       type: memory.type,
       title: memory.title,
@@ -1268,6 +1288,11 @@ export function createService({ store, mirror, config, onWrite, logger, document
       tags: memory.tags ?? [],
       importance: memory.importance ?? 3,
       source: memory.source ?? "manual",
+      // epistemic_status 必须显式透传：省略时 store 会回退到内容标记推断
+      // （中文正则），英文/无标记内容一律落 subjective——E2 四臂实验当场抓到
+      // （trustEpistemicWeighting 的重排对 saveWithDedupe 写入的记忆整体空转，
+      // R+ 臂与 A 臂注入序逐条相同）。undefined 保持推断行为，显式值优先。
+      epistemic_status: memory.epistemic_status,
       ...(memory.evidence !== undefined ? { evidence: memory.evidence } : {}),
       // v0.8.0 A1：scope 标注透传（store 端归一化，未标注落 NULL）。
       // v0.8.1 底座：来源（auto/explicit）与决策时间随行透传。

package/lib/settings.js

@@ -43,6 +43,9 @@ const FEATURE_FLAG_BOOLEANS = [
   "autoInject",
   "autoSummarize",
   "hotMemoryEnabled",
+  // Issue #34（v0.7.2 引入；v0.7.11 误删后随 #333 恢复）：对话开始注入当前时间。
+  // 顶层扁平键，随白名单回面板（FEATURE_GROUPS 的 group.core）。
+  "injectTimePrefix",
   // Issue #239 第 5 项：注入条数的查询自适应（确定性强则收缩注入条数，默认关）。
   "injectUncertaintyAdaptive",
   // Issue #249：能力说明（工具描述判断指引 + order 150 总则段）。第二批起它是
@@ -100,7 +103,12 @@ const FEATURE_FLAG_BOOLEANS = [
   // 子字段。kv 按点号键平铺存（"memoryQualityFilter.enabled": false），index.js
   // 合并时展开回嵌套对象，api.js 的 effective 从对象子字段取值。
   "memoryQualityFilter.enabled",
-  "llmAudit.enabled"
+  "llmAudit.enabled",
+  // Issue #254：写入准入（第 1 级确定性拒绝）。两个键分层——enabled 跑判据、
+  // enforce 真拦；都默认关。同上，点号键平铺存、合并时展开回
+  // writeAdmission 对象。
+  "writeAdmission.enabled",
+  "writeAdmission.enforce"
 ];
 // 整数开关的闭区间，与 config.js 里 z.natural().min().max() 对齐。
 const FEATURE_FLAG_INT_RANGES = {

package/lib/tools.js

@@ -149,11 +149,17 @@ export function createTools(ctx, service, config, embedder) {
           type: "object",
           additionalProperties: false,
           properties: {
-            action: { type: "string", required: true, enum: ["created", "merged"] },
-            id: { type: "string", required: true }
+            action: { type: "string", required: true, enum: ["created", "merged", "denied"] },
+            // denied 时压根没有行可指，所以 id 缺省而不是空串：空串会让「写成功但
+            // id 为空」与「根本没写」在读回执时长得一样，与 #254 验收第 2 条
+            // （被拒写入可解释、不静默丢弃）相悖。
+            id: { type: "string", description: "Row id; absent when action=denied." },
+            reason: { type: "string", description: "Rejection reason when action=denied: blank | noise | sensitive." }
           }
         },
-        render: (_args, value) => TEXT_OUTPUT(`memory ${value.action}: ${value.id}`)
+        render: (_args, value) => TEXT_OUTPUT(value.action === "denied"
+          ? `memory save rejected (${value.reason ?? "denied"}): nothing was written`
+          : `memory ${value.action}: ${value.id}`)
       },
       async execute(args, exec) {
         // scope 标注（v0.8.1 底座，issue #170）：默认由会话身份解析（载体自动
@@ -172,10 +178,10 @@ export function createTools(ctx, service, config, embedder) {
         const workspaceLabel = args.workspace_scope !== undefined
           ? { value: normalizeExplicitScope(args.workspace_scope), source: "explicit" }
           : autoStamping && scope ? { value: scope.workspace_scope, source: "auto" } : null;
-        const { action, memory } = service.saveWithDedupe({
-          // #254 写入准入（第一阶段只计量）的计数单位：会话键作为瞬时字段随写入
-          // 传递（与 _mergeInto / _overwrite 同款约定，不落库）。缺会话身份的宿主
-          // 返回 null = 这次写入不进预算。
+        const result = service.saveWithDedupe({
+          // #254 写入准入的计数单位：会话键作为瞬时字段随写入传递（与 _mergeInto /
+          // _overwrite 同款约定，不落库）。缺会话身份的宿主返回 null = 这次写入不进
+          // 预算；系统写入（dream / summarize / organize）从不带这个字段。
           _sessionKey: sessionKeyOf(exec),
           type: args.type,
           title: args.title,
@@ -188,7 +194,10 @@ export function createTools(ctx, service, config, embedder) {
           ...(args.sensitivity !== undefined ? { sensitivity: args.sensitivity } : {}),
           ...(args.occurred_at !== undefined ? { occurred_at: args.occurred_at } : {})
         });
-        return { action, id: memory.id };
+        // #254 第 1 级硬拒：工具层是模型唯一能看到这次失败的地方，必须显式回一句
+        // 可行动的拒绝理由。静默返回成功会让模型以为记住了，然后永远不再重写。
+        if (result.action === "denied") return { action: "denied", reason: result.reason };
+        return { action: result.action, id: result.memory.id };
       }
     }),