@modusensus/dsh-mneme 0.8.8 → 0.8.10

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/continuity.js

@@ -205,7 +205,7 @@ export function createContinuityRescue(ctx, store) {
       ...decision,
       messages: [
         ...messages,
-        createUserMessage({ content: [{ type: "text", text }], source: { kind: "plugin", plugin: "dsh-mneme" } })
+        createUserMessage({ content: [{ type: "text", text }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } })
       ]
     };
   });

package/lib/dream/sleep.js

@@ -334,8 +334,8 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     maxTokens: config.sleepMaxTokens ?? 2048,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
-      { role: "system", content: [{ type: "text", text: conflictPrompt }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+      { role: "system", content: [{ type: "text", text: conflictPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
     ]
   }, reportUsage, (reason) => { conflictStreamFailure = describeStreamFailure(reason); }));
   };
@@ -496,8 +496,8 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     maxTokens: config.sleepMaxTokens ?? 2048,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
-      { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+      { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
     ]
   }, reportUsage, (reason) => { patternStreamFailure = describeStreamFailure(reason); }));
   };

package/lib/dream.js

@@ -422,8 +422,8 @@ async function generateNarratives({ ctx, service, config, route, language, effor
       maxTokens: config.dreamMaxTokens ?? 2048,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: STR.prompts.narrative[language] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: listing }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+        { role: "system", content: [{ type: "text", text: STR.prompts.narrative[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+        { role: "user", content: [{ type: "text", text: listing }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
   };
@@ -1100,8 +1100,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       maxTokens: config.dreamMaxTokens ?? 4096,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+        { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+        { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
     };
@@ -1335,8 +1335,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       maxTokens: config.dreamMaxTokens ?? 2048,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: summaryInputs.map((m) => `- ${m.title}: ${m.content}`).join("\n") }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+        { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+        { role: "user", content: [{ type: "text", text: summaryInputs.map((m) => `- ${m.title}: ${m.content}`).join("\n") }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { summaryStreamFailure = describeStreamFailure(reason); }));
     };

package/lib/entities/extractor.js

@@ -150,8 +150,8 @@ export async function extractEntities(memory, { store, config, callLLM, logger }
     const userText = buildUserMessage(memory.content);
 
     const messages = [
-      { role: "system", content: [{ type: "text", text: systemPrompt }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-      { role: "user", content: [{ type: "text", text: userText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+      { role: "system", content: [{ type: "text", text: systemPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+      { role: "user", content: [{ type: "text", text: userText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
     ];
 
     // Issue #109: optional provider/model override + reasoning effort are

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/peak-hours.js

@@ -1,117 +1,117 @@
-// 高峰时段（peak hours）解析与判定——纯函数模块，零依赖。
-//
-// 从 summarize.js 抽出（PR #320 review）：#316 之后 summarize.js 反向依赖
-// dream.js（withEffortFallback 复用），dream 镜像错峰时再 import summarize
-// 会成真循环。时段调度本来就不是蒸馏的私有语义，独立成模块后两侧都从这里
-// import，循环消失。re-export 兼容留在 summarize.js，调用方零改动。
-//
-// Issue #239（第 4 项，错峰队列）：高峰时段解析与判定。纯函数、可单测——排程
-// 判断不绑死真实时钟，测试才能确定性地覆盖跨零点、多段、星期过滤与非法写法。
-// spec 语法：`[<星期> ]<时段>[,<时段>...]`，星期前缀可省（省 = 每天）：
-//   "09:00-18:00"                        每天 09:00-18:00
-//   "mon-fri 08:00-12:00,14:00-18:00"    工作日两段（ISO 1=周一…7=周日，也认 mon..sun）
-//   "sat,sun 23:00-06:00"                周末跨零点段
-// 时间取宿主本地时区。任一写法非法 → 整串视为未配置（返回 null）：排程是省钱手段，
-// 绝不该因为写错格式把蒸馏/巩固停掉。
-const DAY_NAMES = { mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6, sun: 7 };
-
-function parseDayToken(token) {
-  const days = new Set();
-  const normalize = (value) => (/^\d$/.test(value) ? Number(value) : DAY_NAMES[value] ?? null);
-  for (const piece of token.split(",")) {
-    const matched = /^([a-z]{3}|\d)(?:-([a-z]{3}|\d))?$/.exec(piece.trim().toLowerCase());
-    if (!matched) return null;
-    const from = normalize(matched[1]);
-    const to = matched[2] === undefined ? from : normalize(matched[2]);
-    if (from === null || to === null || from < 1 || from > 7 || to < 1 || to > 7) return null;
-    // 支持跨周环绕（fri-mon）：从 from 起逐天推进到 to，最多绕一圈。
-    for (let day = from; ; day = (day % 7) + 1) {
-      days.add(day);
-      if (day === to) break;
-    }
-  }
-  return days.size > 0 ? [...days].sort((a, b) => a - b) : null;
-}
-
-/** JS 的 getDay() 是 0=周日…6=周六；这里统一成 ISO（1=周一…7=周日）。 */
-function isoDay(date) {
-  const day = date.getDay();
-  return day === 0 ? 7 : day;
-}
-
-export function parsePeakSpec(spec) {
-  if (typeof spec !== "string" || spec.trim() === "") return null;
-  let rest = spec.trim();
-  let days = null;
-  // 星期前缀 = 第一个空白之前的部分，但**头段含冒号就不是前缀**（那是时段本身，
-  // 例如 "09:00-12:00, 14:00-18:00" 里的逗号空格）。前缀解析失败一律按未配置处理，
-  // 不做猜测——宁可不省，也不能误停。
-  const sep = rest.search(/\s/);
-  if (sep > 0) {
-    const head = rest.slice(0, sep);
-    if (!head.includes(":")) {
-      days = parseDayToken(head);
-      if (days === null) return null;
-      rest = rest.slice(sep).trim();
-    }
-  }
-  const windows = [];
-  for (const part of rest.split(",")) {
-    const matched = /^\s*(\d{1,2}):(\d{2})\s*-\s*(\d{1,2}):(\d{2})\s*$/.exec(part);
-    if (!matched) return null;
-    const [sh, sm, eh, em] = [Number(matched[1]), Number(matched[2]), Number(matched[3]), Number(matched[4])];
-    if (sh > 23 || eh > 23 || sm > 59 || em > 59) return null;
-    const start = sh * 60 + sm;
-    const end = eh * 60 + em;
-    if (start === end) return null;
-    windows.push({ start, end });
-  }
-  return windows.length > 0 ? { days, windows } : null;
-}
-
-/**
- * 该时刻是否落在高峰内。跨零点段（start > end）按「窗口所属的那一天」认星期：
- * `mon-fri 23:00-06:00` 的周六 02:00 属于周五开的那个窗口，仍算高峰。
- */
-export function isInPeakWindow(date, spec) {
-  const parsed = parsePeakSpec(spec);
-  if (!parsed) return false;
-  const minutes = date.getHours() * 60 + date.getMinutes();
-  const today = isoDay(date);
-  const yesterday = today === 1 ? 7 : today - 1;
-  const allowed = (day) => !parsed.days || parsed.days.includes(day);
-  return parsed.windows.some(({ start, end }) => {
-    if (start < end) return minutes >= start && minutes < end && allowed(today);
-    return (minutes >= start && allowed(today)) || (minutes < end && allowed(yesterday));
-  });
-}
-
-/**
- * 高峰内则返回「距当前最近的一个高峰结束时刻」（择时补跑用），否则 null。
- * 落在多个时段重叠处时取最早结束的那个——早跑不亏，晚跑才亏。
- */
-export function nextOffPeakAt(date, spec) {
-  const parsed = parsePeakSpec(spec);
-  if (!parsed) return null;
-  const minutes = date.getHours() * 60 + date.getMinutes();
-  const today = isoDay(date);
-  const yesterday = today === 1 ? 7 : today - 1;
-  const allowed = (day) => !parsed.days || parsed.days.includes(day);
-  let bestDelta = null;
-  const consider = (delta) => {
-    if (bestDelta === null || delta < bestDelta) bestDelta = delta;
-  };
-  for (const { start, end } of parsed.windows) {
-    if (start < end) {
-      if (minutes >= start && minutes < end && allowed(today)) consider(end - minutes);
-      continue;
-    }
-    if (minutes >= start && allowed(today)) consider((1440 - minutes) + end);
-    else if (minutes < end && allowed(yesterday)) consider(end - minutes);
-  }
-  if (bestDelta === null) return null;
-  const at = new Date(date.getTime());
-  at.setSeconds(0, 0);
-  at.setMinutes(at.getMinutes() + bestDelta);
-  return at;
-}
+// 高峰时段（peak hours）解析与判定——纯函数模块，零依赖。
+//
+// 从 summarize.js 抽出（PR #320 review）：#316 之后 summarize.js 反向依赖
+// dream.js（withEffortFallback 复用），dream 镜像错峰时再 import summarize
+// 会成真循环。时段调度本来就不是蒸馏的私有语义，独立成模块后两侧都从这里
+// import，循环消失。re-export 兼容留在 summarize.js，调用方零改动。
+//
+// Issue #239（第 4 项，错峰队列）：高峰时段解析与判定。纯函数、可单测——排程
+// 判断不绑死真实时钟，测试才能确定性地覆盖跨零点、多段、星期过滤与非法写法。
+// spec 语法：`[<星期> ]<时段>[,<时段>...]`，星期前缀可省（省 = 每天）：
+//   "09:00-18:00"                        每天 09:00-18:00
+//   "mon-fri 08:00-12:00,14:00-18:00"    工作日两段（ISO 1=周一…7=周日，也认 mon..sun）
+//   "sat,sun 23:00-06:00"                周末跨零点段
+// 时间取宿主本地时区。任一写法非法 → 整串视为未配置（返回 null）：排程是省钱手段，
+// 绝不该因为写错格式把蒸馏/巩固停掉。
+const DAY_NAMES = { mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6, sun: 7 };
+
+function parseDayToken(token) {
+  const days = new Set();
+  const normalize = (value) => (/^\d$/.test(value) ? Number(value) : DAY_NAMES[value] ?? null);
+  for (const piece of token.split(",")) {
+    const matched = /^([a-z]{3}|\d)(?:-([a-z]{3}|\d))?$/.exec(piece.trim().toLowerCase());
+    if (!matched) return null;
+    const from = normalize(matched[1]);
+    const to = matched[2] === undefined ? from : normalize(matched[2]);
+    if (from === null || to === null || from < 1 || from > 7 || to < 1 || to > 7) return null;
+    // 支持跨周环绕（fri-mon）：从 from 起逐天推进到 to，最多绕一圈。
+    for (let day = from; ; day = (day % 7) + 1) {
+      days.add(day);
+      if (day === to) break;
+    }
+  }
+  return days.size > 0 ? [...days].sort((a, b) => a - b) : null;
+}
+
+/** JS 的 getDay() 是 0=周日…6=周六；这里统一成 ISO（1=周一…7=周日）。 */
+function isoDay(date) {
+  const day = date.getDay();
+  return day === 0 ? 7 : day;
+}
+
+export function parsePeakSpec(spec) {
+  if (typeof spec !== "string" || spec.trim() === "") return null;
+  let rest = spec.trim();
+  let days = null;
+  // 星期前缀 = 第一个空白之前的部分，但**头段含冒号就不是前缀**（那是时段本身，
+  // 例如 "09:00-12:00, 14:00-18:00" 里的逗号空格）。前缀解析失败一律按未配置处理，
+  // 不做猜测——宁可不省，也不能误停。
+  const sep = rest.search(/\s/);
+  if (sep > 0) {
+    const head = rest.slice(0, sep);
+    if (!head.includes(":")) {
+      days = parseDayToken(head);
+      if (days === null) return null;
+      rest = rest.slice(sep).trim();
+    }
+  }
+  const windows = [];
+  for (const part of rest.split(",")) {
+    const matched = /^\s*(\d{1,2}):(\d{2})\s*-\s*(\d{1,2}):(\d{2})\s*$/.exec(part);
+    if (!matched) return null;
+    const [sh, sm, eh, em] = [Number(matched[1]), Number(matched[2]), Number(matched[3]), Number(matched[4])];
+    if (sh > 23 || eh > 23 || sm > 59 || em > 59) return null;
+    const start = sh * 60 + sm;
+    const end = eh * 60 + em;
+    if (start === end) return null;
+    windows.push({ start, end });
+  }
+  return windows.length > 0 ? { days, windows } : null;
+}
+
+/**
+ * 该时刻是否落在高峰内。跨零点段（start > end）按「窗口所属的那一天」认星期：
+ * `mon-fri 23:00-06:00` 的周六 02:00 属于周五开的那个窗口，仍算高峰。
+ */
+export function isInPeakWindow(date, spec) {
+  const parsed = parsePeakSpec(spec);
+  if (!parsed) return false;
+  const minutes = date.getHours() * 60 + date.getMinutes();
+  const today = isoDay(date);
+  const yesterday = today === 1 ? 7 : today - 1;
+  const allowed = (day) => !parsed.days || parsed.days.includes(day);
+  return parsed.windows.some(({ start, end }) => {
+    if (start < end) return minutes >= start && minutes < end && allowed(today);
+    return (minutes >= start && allowed(today)) || (minutes < end && allowed(yesterday));
+  });
+}
+
+/**
+ * 高峰内则返回「距当前最近的一个高峰结束时刻」（择时补跑用），否则 null。
+ * 落在多个时段重叠处时取最早结束的那个——早跑不亏，晚跑才亏。
+ */
+export function nextOffPeakAt(date, spec) {
+  const parsed = parsePeakSpec(spec);
+  if (!parsed) return null;
+  const minutes = date.getHours() * 60 + date.getMinutes();
+  const today = isoDay(date);
+  const yesterday = today === 1 ? 7 : today - 1;
+  const allowed = (day) => !parsed.days || parsed.days.includes(day);
+  let bestDelta = null;
+  const consider = (delta) => {
+    if (bestDelta === null || delta < bestDelta) bestDelta = delta;
+  };
+  for (const { start, end } of parsed.windows) {
+    if (start < end) {
+      if (minutes >= start && minutes < end && allowed(today)) consider(end - minutes);
+      continue;
+    }
+    if (minutes >= start && allowed(today)) consider((1440 - minutes) + end);
+    else if (minutes < end && allowed(yesterday)) consider(end - minutes);
+  }
+  if (bestDelta === null) return null;
+  const at = new Date(date.getTime());
+  at.setSeconds(0, 0);
+  at.setMinutes(at.getMinutes() + bestDelta);
+  return at;
+}

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/summarize.js

@@ -220,7 +220,7 @@ function collectMessages(session, maxChars = 8000, language = "zh", afterSeq, th
   }, undefined);
   return {
     messages: lines.length
-      ? [createUserMessage({ content: [{ type: "text", text: trimTranscript(lines.join("\n"), maxChars) }], source: { kind: "plugin", plugin: "dsh-mneme" } })]
+      ? [createUserMessage({ content: [{ type: "text", text: trimTranscript(lines.join("\n"), maxChars) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } })]
       : [],
     hasEvents: events.length > 0,
     lastSeq
@@ -495,7 +495,7 @@ export function createSummarizer(ctx, service, config, deps = {}) {
         model: route.model,
         purpose: "summarization",
         messages: [
-          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
+          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
           ...messages
         ],
         signal: controller.signal