@modusensus/dsh-mneme 0.8.9 → 0.8.11

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

package/lib/write-admission.js

@@ -1,10 +1,17 @@
-// #254 写入准入（第一阶段：只计量，不拦截）。
-//
-// 为什么先只计量：会话写入预算的 N 与同话题冷却的 X 在没有真实分布时拍任何数字
-// 都是误杀面（维护者 2026-09-23 拍板「先记录不拦，由遥测定」）。所以这一阶段只把
-// 两个闸门的原始测量点写进 llm_audit_logs（status='skipped'、metadata.gate='g1'
-// 且同话题重复时附 metadata.g2），不做判定、不改任何写入行为；第二阶段把拦截打开
-// 时才引入阈值与二次确认（memory_save({confirm:true})）。
+// #254 写入准入。两个阶段：
+//   阶段一（已合入）：只计量、不拦截。会话写入预算的 N 与同话题冷却的 X 在没有真实
+//   分布时拍任何数字都是误杀面（维护者 2026-09-23 拍板「先记录不拦，由遥测定」）。
+//   所以那两个闸门只把原始测量点写进 llm_audit_logs（status='skipped'、
+//   metadata.gate='g1' 且同话题重复时附 metadata.g2），不做判定、不改任何写入行为；
+//   阈值与二次确认（memory_save({confirm:true})）等遥测有分布再单独提。
+//   阶段一之后（本批）：第 1 级确定性拒绝。按 2026-09-21/09-22 两轮收窄的口径，
+//   第 1 级只剩**密钥/PII 与空白噪声**两类判据走硬拒；去重键命中判 write-update 放行
+//   （不把同步去重升级成拒绝门——2606.24535 记的那个失效模式：同步近重复门抢在异步
+//   矛盾检测之前，本该被裁决的矛盾写入被门直接拒掉）。两类判据都零 LLM、纯确定性。
+//   两个开关都默认关：enabled 打开判定，enforce 打开拦截（关 = 仅告警 + 留审计）。
+//   默认关时 evaluate 的返回与阶段一逐字段一致（验收第 1 条「默认路径零行为变化」）。
+//   密钥/PII 那一类的判据实现不在本模块：按验收第 4 条它是 #164 A2 的判据来源，由
+//   createWriteAdmission 的 sensitiveScan 注入，本模块只定义它怎么被消费。
 //
 // 为什么复用 llm_audit_logs：它是仓库既有的「后台动作回执」表（bookkeeping，不
 // 触发写钩子，见 store.js 的表注释）。第二阶段落地时「第一次 skipped/gate →
@@ -36,7 +43,7 @@
 // deleteOldLlmAudits），所以关掉时本模块一行都不写，否则就是在无保留期的表里做
 // 按写入频次增长。
 import { PINNED_MEMORY_TYPES } from "./service.js";
-import { contentHashOf } from "./content-hash.js";
+import { contentHashOf, normalizeForHash } from "./content-hash.js";
 
 // 审计口径（llm_audit_logs 的既有列）：trigger_source = 组件名，operation_type =
 // 动作名，status='skipped' = 本行没有产生任何 LLM 花费（与 summarize 的间隔门、
@@ -45,6 +52,16 @@ export const ADMISSION_TRIGGER_SOURCE = "writeAdmission";
 export const ADMISSION_OPERATION_TYPE = "write_admission";
 export const ADMISSION_GATE_SESSION_BUDGET = "g1";
 
+// 决策两值。阶段一恒 allow；第 1 级判定命中且 enforce 打开时才 deny。
+export const ADMISSION_DECISION_ALLOW = "allow";
+export const ADMISSION_DECISION_DENY = "deny";
+
+// 第 1 级的拒绝原因（#254 拍板：硬拒绝只留密钥/PII 与空白噪声；去重键命中归
+// write-update 放行，G1/G2 走二次确认）。reason 是审计行里的稳定键，别当展示文案用。
+export const ADMISSION_DENY_BLANK = "blank";
+export const ADMISSION_DENY_NOISE = "noise";
+export const ADMISSION_DENY_SENSITIVE = "sensitive";
+
 // 首次见到某会话时的回填深度：话题表由审计行重建，只回填最近这么多行。更早的
 // 话题会漏（测量口径可接受），换来的是一次查询与有界的常驻内存。
 export const TOPIC_LOOKBACK_ROWS = 200;
@@ -76,19 +93,58 @@ export function extractTopicKeys(memory) {
   return [...keys].sort();
 }
 
+/**
+ * 第 1 级「空白 / 纯噪声」判据（#254，零 LLM、纯函数、无状态）。
+ *
+ * 为什么这两类够格进硬拒：它们的命中面**没有解释空间**——一条归一化后什么都不剩的
+ * 写入，进库之后既检索不到也注入不了，写它只有成本没有收益，不存在「误杀有价值内容」
+ * 的可能。这正是硬拒与二次确认的分界：有解释空间的（去重命中、预算/冷却）走二次确认，
+ * 没有解释空间的才硬拒。
+ *
+ * 为什么复用 content-hash 的归一化而不另写一套：判据要的是「有没有信息」，而
+ * normalizeForHash 的口径（NFKC → 小写 → 去标点 → 空白折叠）恰好就是「把格式折掉之后
+ * 还剩什么」。另写一套只会多出一个会漂移的口径（同 content-hash.js 文件头的存量重算
+ * 理由）。两个 reason 分开报是为了可解释：`blank` 是真的什么都没写（提交一个空表单），
+ * `noise` 是写了但只有标点/空白（`...`、`---`）——两者的修法不同。
+ *
+ * 为什么不用 quality-filter 的 `repetitive`（dedupRatio < 0.3）一起判：那是**写入后**
+ * 的评分扣分项，扣分可以错（只影响排序与归档），硬拒不能错。一条字符多样性低的正常
+ * 记忆（同一种分隔符排出的长清单）会被它判成 repetitive，本判据不背这个误杀面。
+ *
+ * @param {{title?: string, content?: string}|null|undefined} memory
+ * @returns {"blank"|"noise"|null} 命中即返回 reason，否则 null
+ */
+export function informationlessReason(memory) {
+  const title = String(memory?.title ?? "").trim();
+  const content = String(memory?.content ?? "").trim();
+  if (!title && !content) return ADMISSION_DENY_BLANK;
+  if (!normalizeForHash(title) && !normalizeForHash(content)) return ADMISSION_DENY_NOISE;
+  return null;
+}
+
 /**
  * 写入准入（#254）。返回的两个方法就是三个消费方共用的那份接口：
- *   evaluate 给出决策形状（阶段一恒 allow），record 把测量点写成审计行。
- * 阶段二在 evaluate 里引入阈值与 confirm 分支；#249 的注入提示与 #275 的水位计数
- * 都读同一份 decision/审计行，而不是各写一套判定。
+ *   evaluate 给出决策形状，record 把测量点/拒绝面写成审计行。
+ * #249 的注入提示与 #275 的水位计数都读同一份 decision/审计行，而不是各写一套判定。
+ *
+ * 两个开关（config.writeAdmission，都默认关——验收第 1 条「默认路径零行为变化」）：
+ *   enabled — 打开第 1 级判定（空白/噪声 + 注入进来的密钥/PII 判据）。
+ *             关时 evaluate 的返回与阶段一逐字段一致，只算三个测量点。
+ *   enforce — 命中时真的拒绝。关时判定照跑、照留审计，但决策回落 allow（仅告警）。
+ * 密钥/PII 那一类判据不在这里实现：按 #254 验收第 4 条，它是 #164 A2 的判据来源，
+ * 由 `sensitiveScan` 注入（见下），本模块只定义它怎么被消费。
  *
  * @param {object} deps
  * @param {object} deps.store 存储层（listLlmAudits / saveLlmAudit）
- * @param {object} [deps.config] 已解析配置（读 llmAudit.enabled）
+ * @param {object} [deps.config] 已解析配置（读 llmAudit.enabled、writeAdmission.*）
  * @param {object} [deps.logger]
  * @param {() => number} [deps.now] 时钟注入（测试用）
+ * @param {(memory: object) => ({reason: string, kind?: string, label?: string}|null)} [deps.sensitiveScan]
+ *   第 1 级的密钥/PII 判据（#164 A2 的落点）。约定：命中返回 `{kind, label}`，未命中
+ *   返回 null，**不抛**（抛出按未命中处理并 warn，判据故障不能让写入变成不可用）。
+ *   缺省时这一类判据整个不参与——本模块在 A2 落地前只跑空白/噪声。
  */
-export function createWriteAdmission({ store, config, logger, now = Date.now } = {}) {
+export function createWriteAdmission({ store, config, logger, now = Date.now, sensitiveScan = null } = {}) {
   // sessionKey → Map<话题锚, 最近一次新建行时刻(ms)>。真相源是审计行，这里只是它的
   // 增量视图：进程重启后按需回填。FIFO 上限防长驻进程内存无界（同 store.js 的
   // embedding 解析缓存口径）。
@@ -115,6 +171,11 @@ export function createWriteAdmission({ store, config, logger, now = Date.now } =
         // 穿透行（pinned）整个不在闸门里，也就不该进基准表——只挡内存路径不挡回填，
         // 重启后口径就变了（同一个话题会因为一条穿透行而被判成重复）。
         if (metadata.exempt) continue;
+        // 被第 1 级拦下的行同理：它根本没进库。内存路径已经跳过了（见 record 的
+        // enforced 判断），回填路径必须同口径——否则同一条时间线会随进程重启而变：
+        // 重启前不重复、重启后变重复。仅告警档（deny 非空但 decision=allow）要留，
+        // 那条行确实落库了。
+        if (metadata.deny?.enforced === true) continue;
         const at = Date.parse(row.timestamp);
         // 坏时间戳跳过：落到 0 会让 gap 变成几十年，一个离群值就能带偏按分位定的 X。
         if (!Number.isFinite(at)) continue;
@@ -165,25 +226,82 @@ export function createWriteAdmission({ store, config, logger, now = Date.now } =
   }
 
   /**
-   * 阶段一决策：恒 allow（本模块里没有阈值），只算出三个闸门的测量点。返回形状一次
-   * 定死，阶段二只往里加分支、不改字段：
-   *   decision — "allow" | "confirm"（阶段一只可能 allow）
+   * 第 1 级判据的汇总口（#254）：空白 / 噪声 + 注入进来的密钥 / PII。
+   * 顺序按成本排：字符串判据在前，注入的扫描器在后；扫描器抛异常按「未命中」处理
+   * （warn）——判据故障不能让所有写入变成不可用，这是与计量同一条不反噬原则。
+   * @returns {{reason: string, kind?: string, label?: string}|null}
+   */
+  function firstLevelHit(memory) {
+    const info = informationlessReason(memory);
+    if (info) return { reason: info };
+    if (typeof sensitiveScan !== "function") return null;
+    try {
+      const hit = sensitiveScan(memory);
+      if (!hit) return null;
+      const deny = { reason: ADMISSION_DENY_SENSITIVE };
+      // kind / label 只在判据真给了才落盘：给 undefined 会让审计行里出现一个
+      // 存在但无值的键，读的人分不清「没报」和「报了空串」。
+      if (hit.kind !== undefined) deny.kind = hit.kind;
+      if (hit.label !== undefined) deny.label = hit.label;
+      return deny;
+    } catch (e) {
+      warn(`[dsh-mneme] write admission sensitive scan failed: ${String(e)}`);
+      return null;
+    }
+  }
+
+  /**
+   * 决策形状一次定死，后续只加分支、不改字段：
+   *   decision — "allow" | "deny"
    *   gate     — "g1" | null（null = 这次写入不进预算，不记行）
    *   topics   — 本次写入的确定性话题锚
    *   repeat   — {topic, gapMs} | null（g2 的命中面）
    *   dup      — {memory_id, archived, forgotten} | null（内容哈希的命中面）
    *   exempt   — null | "pinned"
+   *   deny     — null | {reason, kind?, label?}（第 1 级命中面）
+   *
+   * deny 非空但 decision 仍是 allow = 仅告警档（config.writeAdmission.enforce 关）：
+   * 判定照跑、审计照留，写入不拦。读审计时「deny 非空且 decision=allow」就是这一档的
+   * 指纹，不需要再读配置才能解释一行。
+   *
+   * 第 1 级判定放在 pinned 豁免之前：pinned 豁免的是**预算与冷却**（constraint /
+   * preference 是 #249 第一批立的逐字保真池，不该被会话预算拦），不是「这条能不能落库」。
+   * 一条写着私钥的 constraint 仍然是私钥。
    * @param {{memory: object, sessionKey?: string|null}} input
    */
   function evaluate({ memory, sessionKey } = {}) {
-    const verdict = { decision: "allow", gate: null, topics: [], repeat: null, dup: null, exempt: null };
+    const verdict = {
+      decision: ADMISSION_DECISION_ALLOW,
+      gate: null,
+      topics: [],
+      repeat: null,
+      dup: null,
+      exempt: null,
+      deny: null
+    };
     // 无会话身份 = 系统写入（dream / summarize / import / organize），不进预算。
+    // 第 1 级判定同样在这里之外：#164 A2 定的判据面含 autoSummarize / dream 输出，
+    // 那三处的接线是 A2 的落地范围（本模块跑的是会话内的 memory_save 路径）。
     if (!sessionKey) return verdict;
     // 审计关掉时不记行、也不推进话题表（见文件头：那个开关连启动期清理一起关掉）。
     if (config?.llmAudit?.enabled === false) return verdict;
+
+    const hit = config?.writeAdmission?.enabled === true ? firstLevelHit(memory) : null;
+    const judged = hit ? { ...verdict, deny: hit } : verdict;
+
+    // 命中且 enforce：决策已定，不再发候选集查询、不再比较话题（纯白花成本）。
+    if (hit && config?.writeAdmission?.enforce === true) {
+      return {
+        ...judged,
+        decision: ADMISSION_DECISION_DENY,
+        gate: ADMISSION_GATE_SESSION_BUDGET,
+        topics: extractTopicKeys(memory)
+      };
+    }
+
     const topics = extractTopicKeys(memory);
     const pinned = PINNED_MEMORY_TYPES.has(String(memory?.type ?? ""));
-    if (pinned) return { ...verdict, gate: ADMISSION_GATE_SESSION_BUDGET, topics, exempt: "pinned" };
+    if (pinned) return { ...judged, gate: ADMISSION_GATE_SESSION_BUDGET, topics, exempt: "pinned" };
     const dup = lookupContentDup(memory);
     const table = topicTable(sessionKey);
     const at = now();
@@ -194,11 +312,11 @@ export function createWriteAdmission({ store, config, logger, now = Date.now } =
       // 同一行可能命中多个锚：取最近的那次（间隔最短＝最有价值的那次重复）。
       if (!repeat || gapMs < repeat.gapMs) repeat = { topic, gapMs };
     }
-    return { ...verdict, gate: ADMISSION_GATE_SESSION_BUDGET, topics, repeat, dup };
+    return { ...judged, gate: ADMISSION_GATE_SESSION_BUDGET, topics, repeat, dup };
   }
 
   /**
-   * 把测量点落成审计行（一行一个新建行）。三个信号的读法：
+   * 把测量点与拒绝面落成审计行（一行一个新建行 / 一次被拒的写入）。四个信号的读法：
    *   g1 会话写入预算：`GROUP BY session_key` 计数即得「会话内新建条数」分布；要剔
    *      掉穿透行（pinned 不进预算）就加 `json_extract(metadata,'$.exempt') IS NULL`。
    *   g2 同话题冷却：`json_extract(metadata,'$.g2.gap_ms')` 即得「同话题新建行间隔」
@@ -207,6 +325,10 @@ export function createWriteAdmission({ store, config, logger, now = Date.now } =
    *   dup 内容哈希：`json_extract(metadata,'$.dup.memory_id')` 非空即「这条新行的内容
    *      与某条既有行归一化后逐字节相同」；`$.dup.archived` 区分命中那条在活区还是
    *      归档区——归档区命中就是去重候选集漏掉的那一类穿透。
+   *   deny 第 1 级命中：#254 验收第 2 条要的「被拒的写入可解释、不静默丢弃」就落在
+   *      这一项。三个键分工——`$.deny.reason` 是稳定判据键（blank / noise / sensitive），
+   *      `$.deny.kind` 是密钥/PII 的子类，`$.deny.enforced` 区分「真拦下了」与「仅告警」。
+   *      enforced=false 时这一行同时也是一个正常的 g1 行（写入确实发生了）。
    * 计量绝不影响写入：任何异常只 warn。
    * @returns {object[]} 落下的审计行（无测量点或失败时为空数组）
    */
@@ -214,6 +336,7 @@ export function createWriteAdmission({ store, config, logger, now = Date.now } =
     if (!sessionKey || !verdict || verdict.gate == null) return [];
     const at = now();
     const topics = Array.isArray(verdict.topics) ? verdict.topics : [];
+    const enforced = verdict.decision === ADMISSION_DECISION_DENY;
     const rows = [];
     try {
       rows.push(store.saveLlmAudit({
@@ -239,6 +362,24 @@ export function createWriteAdmission({ store, config, logger, now = Date.now } =
               archived: verdict.dup.archived === true,
               forgotten: verdict.dup.forgotten === true
             } }
+            : {}),
+          // enforced 由 decision 推出而不是另存一个入参：两者若各存一份，将来就会出现
+          // 「decision=deny 但 enforced=false」这种自相矛盾的行。
+          //
+          // decision 只在真有拒绝面时落盘：两个开关都关时，这条 metadata 必须与只计量
+          // 那一阶段逐字节一致（#254 验收第 1 条）。没有 deny 的行本来就默认是放行，
+          // 写一个恒为 "allow" 的键只是把「默认路径零行为变化」变成需要解释的事。
+          // 读法：有 deny 才有 decision，deny 非空且 decision=allow 就是仅告警档。
+          ...(verdict.deny
+            ? {
+              decision: verdict.decision,
+              deny: {
+                reason: verdict.deny.reason,
+                ...(verdict.deny.kind !== undefined ? { kind: verdict.deny.kind } : {}),
+                ...(verdict.deny.label !== undefined ? { label: verdict.deny.label } : {}),
+                enforced
+              }
+            }
             : {})
         }
       }));
@@ -247,8 +388,10 @@ export function createWriteAdmission({ store, config, logger, now = Date.now } =
       warn(`[dsh-mneme] write admission audit failed: ${String(e)}`);
     }
     // 只有真正落库、且不是穿透口的行才推进话题表：审计写失败时内存视图不能跑在审计
-    // 前面（重启回填会得到另一条时间线），pinned 写入整个不在闸门里。
-    if (rows.length > 0 && !verdict.exempt) {
+    // 前面（重启回填会得到另一条时间线），pinned 写入整个不在闸门里。被拦下的写入
+    // 同样不推进——它没进库，成为下一次 g2 的基准就会造出一条不存在的时间线。
+    // 仅告警档（deny 非空但 decision=allow）**要**推进：那条行确实落库了。
+    if (rows.length > 0 && !verdict.exempt && !enforced) {
       const table = topicTable(sessionKey);
       for (const topic of topics) table.set(topic, at);
     }

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "mneme",
+    "description": "Cross-session memory: auto-distill each session into a local SQLite store, inject on demand, consolidate while idle (autoDream)."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "mneme 记忆库",
+    "description": "跨会话记忆：自动把会话沉淀进本机 SQLite，需要时按需注入，空闲时巩固（做梦）。"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 9 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.8.9",
+  "version": "0.8.11",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -13,6 +13,7 @@
   },
   "type": "module",
   "main": "lib/index.js",
+  "icon": "assets/icon.svg",
   "bin": {
     "dsh-mneme": "bin/cli.mjs",
     "dsh-mneme-mcp": "bin/dsh-mneme-mcp.mjs"
@@ -24,11 +25,14 @@
     "./client": {
       "default": "./lib/client.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locale/*": "./locale/*"
   },
   "files": [
+    "assets",
     "bin",
     "lib",
+    "locale",
     "src",
     "scripts",
     "test",