@modusensus/dsh-mneme 0.8.12 → 0.8.14

package/lib/sensitive-scan.js

@@ -0,0 +1,209 @@
+// #164 A2：写入边界的密钥 / PII 判据。判据来源是 #164 A2（维护者 09-28 把认领转给
+// 本侧），消费方是 #254 的写入准入——`write-admission.js` 从 #332 起就留了
+// `sensitiveScan` 注入点，本模块是那个占位的实现。
+//
+// 为什么判据独立成文件、不写进 write-admission.js：判据的归属是 #164 A2，闸门的归属
+// 是 #254。闸门只消费 `{kind, label}`（deny 面已在 #332 定死），判据自己既不认识
+// 「会话预算」也不认识 `llm_audit_logs`——换一个判据（比如将来接更重的 PII 分类器）
+// 只换注入的那一行。写入边界的另外两个出口（autoSummarize / dream 输出）要复用同一份
+// 判据时也直接 import 本模块的 `scanSensitive`，不必各写一套形状。
+//
+// 三条判据口径（前两条是 #254 已定的硬约束，第三条是本模块自己的）：
+//
+// 1. 零 LLM、纯确定性。写入路径在最上游，这里多花的时间会乘上每一次写入；EdgeMem
+//    （2609.05553）那句「能不用模型判定就不用」说的就是这一层。
+//
+// 2. 假阳率由负样本定。`test/helpers/write-admission-samples.js` 的 12 条负样本是
+//    #332 就配好的验收面，维护者把话说死了：「同一套负样本原样跑，抓错任何一条就不
+//    算落地」。所以本模块的形状是**先认形状再认关键词**——纯关键词匹配在那组负样本
+//    上全军覆没（「把 API key 放进环境变量」这类讨论句里一个凭据值都没有）。
+//
+// 3. 报最严重的那一类（`kind` 落审计）。同一个字符串可能同时像两类（`sk_live_` 前缀
+//    既是 Stripe 的形状、也能被通用的 `sk-` 规则吃下），所以规则表按「越具体越靠前」
+//    排，命中即返回。密钥在前、PII 在后：两者误杀面差一个量级（密钥串出现在正常项目
+//    记忆里就是事故，邮箱 / 手机号完全可能是正当内容），同时命中时报更严重的那一类。
+//    `kind` 是稳定判据键（不是展示文案），enforce 打开前先按它看分布，将来要按类放行
+//    也只改策略、不动判据。
+//
+// 已知边界（都是「宁漏不误杀」的取舍，不是遗漏）：
+//   - 只扫文本（title / content / tags）。不扫路径、id、时间戳这类元数据字段——它们
+//     由系统生成，不是用户写进来的内容，扫它们只会引入假阳。
+//   - 中文关键词（密码 / 令牌）不认。补进去会让「密码必须脱敏后再入库」这类讨论句
+//     命中，而那正是负样本 group 的形状。要覆盖中文赋值得先设计「关键词语种 × 值形状」
+//     的两维判据，不在本批。
+//   - 手机号只认大陆移动号段（1[3-9] + 9 位），固定电话与带国家码的写法不认。宽一位
+//     就会把长度相近的订单号 / 内部编号吃进来，而 PII 这一档的误杀面已经比密钥大一档。
+//   - 银行卡号加 Luhn 校验：`0000000000000000`、`4111111111111112` 这类形状对但校验
+//     不过的串不报。少了这道校验，任何 16 位数字串（订单号、时间戳拼接）都会命中。
+//   - 身份证同样加校验位（GB 11643 / ISO 7064 MOD 11-2）：位数对但校验不过的 18 位
+//     数字串不报。原先只有银行卡有校验、身份证没有，结果是 18 位纯数字先被身份证规则
+//     命中，反倒绕过银行卡那条的 Luhn。
+//
+// 归一化：这里**不**用 content-hash.js 的 normalizeForHash。那套口径（NFKC → 小写 →
+// 去标点）是为「只差格式的两条写入是否同一件事」定的，判据要的是原串的形状——大小写
+// 是密钥 alphabet 的一部分（`AKIA` 与 `akia` 不是同一个值），去掉 `-` / `_` 会把 JWT
+// 与 Slack token 的分段结构一起折没。两个口径别互换。
+
+/** 判据命中的返回形状（与 `createWriteAdmission` 的 sensitiveScan 契约一致）。 */
+// kind 是稳定键、label 是给人看的一行说明；两者都落 llm_audit_logs 的
+// metadata.deny，所以别在其中塞运行时的值（命中的凭据本身绝不落盘 / 不回显）。
+const SECRET_RULES = [
+  { kind: "aws_access_key", label: "AWS access key id", re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/ },
+  // AWS 的 secret access key 没有前缀，只能靠赋值键认：`AWS_SECRET_ACCESS_KEY` /
+  // `aws_secret_access_key` 这个键名是它的形状。最早的一批 `secret` 关键词规则被
+  // 「必须在赋值号前」的位置要求挡在外面（多词键里 `secret` 后面跟的是 `_`，不是
+  // `:`/`=`），所以它得单独一条。40 位下限取 AWS 官方密钥的固定长度。
+  {
+    kind: "aws_secret_key",
+    label: "AWS secret access key",
+    // 键名不分大小写，所以挂 `/i` 而不是行内修饰符组 `(?i:...)`：后者是 ES2025 语法，
+    // CI 矩阵里的 Node 22 直接抛 SyntaxError（本文件其余规则也没有用它的）。
+    // 值那一半本来就是 `[A-Za-z0-9/+=]`，带上 `/i` 不改变大小写敏感度。
+    re: /(?:aws[_-]?secret[_-]?access[_-]?key)\s*[:=]\s*["']?([A-Za-z0-9/+=]{40})(?![A-Za-z0-9/+=])/i
+  },
+  { kind: "github_token", label: "GitHub token", re: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36}\b/ },
+  { kind: "slack_token", label: "Slack token", re: /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/ },
+  // PEM 头是明文私钥的确定标志，带不带正文都一样判——`BEGIN` 与 `PRIVATE KEY` 之间
+  // 可能有 `RSA` / `EC` / `OPENSSH`，所以中间那段是 [A-Z ]*。
+  { kind: "private_key", label: "PEM private key", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+  { kind: "jwt", label: "JSON Web Token", re: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/ },
+  // scheme 与 userinfo 两段都加上界。scheme 那段的 `*` 作用在含 `.` 的字符类上，
+  // 一条长点分串（包名 / 路径 / 版本链）里每个起点都要一路回溯到结尾才发现没有
+  // `://` → 与 email 同源的 O(n²)（实测 120KB 对抗串里这条占 4.1 秒）。
+  // URL scheme 名本就短、`user:password` 也不会长到 64，上界只钉住回溯面，
+  // 真实连接串一条不少。
+  { kind: "connection_string", label: "credentials in URL", re: /\b[a-z][a-z0-9+.-]{0,31}:\/\/[^\s/:@]{1,64}:[^\s/:@]{6,}@/ },
+  // Stripe 排在通用 `sk-` 之前：`sk_live_…` 两条规则都吃，先到的那条决定 kind。
+  // 只认 sk_live_（生产密钥）：sk_test_ 是公开测试密钥，报它是纯误杀。
+  { kind: "stripe_key", label: "Stripe secret key", re: /\bsk_live_[A-Za-z0-9]{16,}\b/ },
+  { kind: "npm_token", label: "npm auth token", re: /_authToken\s*=\s*[A-Za-z0-9_-]{20,}/ },
+  // 下限 24 而不是 20：这是一条纯收紧、不动语料读数的加固——OpenAI 的 key 没有校验
+  // 位，前缀 + 长度是唯一形状，20 位会把更长的假阳性面留在表里。`sk-` 后面跟短串的
+  // 赋值句仍会被赋值型那条认下（那是**对的**：值长了 8 位以上就该报）。
+  { kind: "openai_key", label: "OpenAI API key", re: /\bsk-(?:proj-)?[A-Za-z0-9_-]{24,}\b/ },
+  {
+    // 赋值型：最常见的一类，也是负样本组（占位符 / 环境变量 / 模板变量 / 只提关键词）
+    // 的主要靶子。判据是「关键词 + 赋值号 + 右边真的是个值的形状」，值本身不校验
+    // alphabet——凭据值没有通用形状，能通用的只有「它不像占位符」。
+    kind: "assigned_secret",
+    label: "assigned credential literal",
+    // 左边界不能把 `_` 排除在外：环境变量名正是拿 `_` 当分隔符，排除它会让
+    // `DB_PASSWORD=` / `MY_API_KEY=` / `MYSQL_PASSWORD=` 整类漏放（只有恰好落在
+    // 行首的 `API_KEY=` 能中）。放宽后 #332 那套 26 条语料（含 12 条负样本）全绿，
+    // 说明原写法不是语料换来的取舍。挡误杀的是下面那道占位符守卫，不是这个边界。
+    re: /(?:^|[^A-Za-z0-9])(?:password|passwd|pwd|secret|api[_-]?key|token)\b\s*[:=]\s*["']?([^\s"']{8,})/i,
+    // 占位符守卫：右边是尖括号占位、shell / 模板变量、环境变量读取、或一串 x / * / …
+    // 时不算命中。少这道守卫，`password: <redacted>` 与 `token: ${TOKEN}` 都会被报，
+    // 而它们正是「配置里该怎么写」的示例文本。
+    guard: (value) => !/^(?:<[^>]*>|\$\{|\$[A-Z_]+$|process\.env|redacted|xx+|\*+|\u2026)/i.test(value)
+  }
+];
+
+const PII_RULES = [
+  {
+    kind: "email",
+    label: "email address",
+    // 先看 TLD 再看 `@`：反过来的 `(?:[A-Za-z]{2,}\.)+[A-Za-z]{2,}` 对
+    // `a@b.c.d.e` 这类可以回溯出指数条路径。
+    // local part 的 `+` 必须加上界。该字符类含 `.`，所以一条长点分串（包名 / 路径 /
+    // 版本链）后跟一个 `@` 时，每个起点都要重扫到那个 `@` 才失败 → 整体 O(n²)。
+    // 实测 120KB 对抗串 23.5 秒里这条占 18.6 秒，34KB 点分链要 0.6 秒；本判据在写入
+    // 路径上同步跑，等于把写入阻塞住。64 是 RFC 5321 给 local part 的上限，加上界
+    // 不缩检测面——放弃的只是长于 64 的非法形状。
+    re: /\b[A-Za-z0-9._%+-]{1,64}@(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}\b/
+  },
+  { kind: "cn_mobile", label: "mainland mobile number", re: /(?<!\d)1[3-9]\d{9}(?!\d)/ },
+  { kind: "cn_id_card", label: "mainland ID number", re: /(?<![0-9A-Za-z])\d{17}[\dXx](?![0-9A-Za-z])/, cnId: true },
+  { kind: "bank_card", label: "payment card number", re: /(?<!\d)(?:\d{13,19})(?!\d)/, luhn: true }
+];
+
+/**
+ * Luhn（模 10）校验。银行卡号这一档只靠位数与首字符形状会把所有 13–19 位数字串
+ * 都吃进来，而项目记忆里长度差不多的数字串（订单号、拼接的时间戳）很常见；校验位
+ * 是卡号自带的、零成本的第二道形状。负样本里没有卡号形状的串，这道校验是防未列举
+ * 的那一类（同时它也不影响正样本：4111111111111111 是 Luhn 通过的公开测试卡号）。
+ * @param {string} value 归一后的数字串（可能含分隔符）
+ */
+function passesLuhn(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length < 13 || digits.length > 19) return false;
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (double) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+
+// 大陆身份证校验位（GB 11643 / ISO 7064 MOD 11-2）。与银行卡的 Luhn 同理：18 位
+// 数字串在项目记忆里很常见（订单号、内部编号、拼接时间戳），位数这个形状拦不住它们，
+// 而校验位是身份证自带的、零成本的第二道形状。权重序列与余数映射都是标准值，别改。
+const CN_ID_WEIGHTS = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+const CN_ID_CODES = "10X98765432";
+/** @param {string} value 命中串（17 位数字 + 校验位，校验位可为 X） */
+function passesCnId(value) {
+  if (!/^\d{17}[\dXx]$/.test(value)) return false;
+  let sum = 0;
+  for (let i = 0; i < 17; i++) sum += Number(value[i]) * CN_ID_WEIGHTS[i];
+  return CN_ID_CODES[sum % 11] === value[17].toUpperCase();
+}
+
+/**
+ * 扫一段文本里的密钥 / PII。命中返回 `{kind, label}`、未命中返回 null，不抛。
+ *
+ * 只认第一处命中（按规则表顺序 = 严重度顺序）。一次写入里出现第二条凭据时不再报——
+ * deny 面只记判据类别，报多条只是把同一件事写几遍。
+ * @param {unknown} value
+ * @returns {{kind: string, label: string}|null}
+ */
+export function scanSensitive(value) {
+  const text = typeof value === "string" ? value : String(value ?? "");
+  if (!text) return null;
+  for (const rule of [...SECRET_RULES, ...PII_RULES]) {
+    const match = text.match(rule.re);
+    if (!match) continue;
+    // 守卫只看捕获组：没有捕获组的规则天然没有守卫。
+    if (rule.guard && !rule.guard(match[1] ?? "")) continue;
+    if (rule.luhn && !passesLuhn(match[0])) continue;
+    if (rule.cnId && !passesCnId(match[0])) continue;
+    return { kind: rule.kind, label: rule.label };
+  }
+  return null;
+}
+
+/**
+ * 判据的两种调用面，共用同一份规则表：
+ *   `scanSensitive(text)`           — 任意文本，给写入边界之外的消费方（autoSummarize /
+ *                                     dream 输出）直接调；它们手里是文本，不是记忆行。
+ *   `createSensitiveScan({config})` — `write-admission.js` 的 `sensitiveScan` 契约，
+ *                                     入参是记忆对象、返回 `{kind, label}` 或 null。
+ *
+ * 开关在工厂里判一次：`sensitiveScanEnabled` 关时返回 null，闸门侧连函数都拿不到，
+ * 于是「第 1 级只跑空白 / 噪声」这条路与 #332 合并时**逐字段一致**（那一版根本没有
+ * 这个函数）。反过来，本键开着也不会自己去扫：唯一的调用点是闸门的 firstLevelHit，
+ * 而闸门要 `writeAdmission.enabled` 打开才走第 1 级判据。所以两个键是「闸门」与
+ * 「闸门内这一批判据」的关系，不是互为子开关——任一个关着，A2 都不产生任何判定。
+ * 分成两个键是为了能单独观察 A2 的命中分布（空白 / 噪声与密钥 / PII 的误杀面差一个
+ * 量级），不是为了让它能脱离闸门独立生效。
+ *
+ * @param {{config?: object}} [deps]
+ * @returns {((memory: object) => ({kind: string, label: string}|null))|null}
+ */
+export function createSensitiveScan({ config } = {}) {
+  if (config?.sensitiveScanEnabled !== true) return null;
+  const scan = (memory) => {
+    const text = [memory?.title, memory?.content, ...(Array.isArray(memory?.tags) ? memory.tags : [])]
+      .filter((s) => typeof s === "string")
+      .join("\n");
+    return scanSensitive(text);
+  };
+  // 工厂只认「开 / 关」；enforce 由 write-admission 决定（命中即 deny 还是仅告警），
+  // 判据自己不碰决策——那一步在闸门里。两层分开就能先开检测看分布、再开拦截。
+  return scan;
+}

package/lib/serve.js

@@ -0,0 +1,215 @@
+// src/serve.js —— 独立服务(daemon)运行时:mneme 在 DSH 宿主之外常驻的最小装配面
+// (#363 承诺的「官方推荐第三方挂载姿势」)。bin/dsh-mneme-serve.mjs 是它的 CLI 壳,
+// Mneme Bridge 这类第三方也可直接 import 本模块自行托管生命周期。
+//
+// 与宿主装配(src/index.js apply)的关系:只搬数据面 + 语义管线两块,每步注释锚定
+// index.js 来源行号。刻意不抽公共装配函数——apply 的其余环节(注入/工具/dream)与
+// 宿主 ctx 纠缠,防御段纪律是「最后动或不动」;本文件的漂移风险由 serve-bin 测试的
+// 多进程共存用例兜底(两侧真开同一个库互写互读)。
+//
+// 无 LLM:巩固(autoDream)与蒸馏(autoSummarize)结构上不在这里——巩固只属于 DSH
+// 宿主进程,这就是 daemon 与宿主「单写者」的机械保证(AGENTS.md 的 externalApi/
+// autoDream 单侧纪律),不依赖用户自觉。语义检索(PR2 起)与宿主共用 src/semantic.js
+// 的同一份装配;daemon 不参与做梦,但向量检索/语义去重与宿主同质。
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createStore } from "./store.js";
+import { createSettings } from "./settings.js";
+import { createMirror, TYPE_FILE } from "./mirror.js";
+import { langOf } from "./lang.js";
+import { createService } from "./service.js";
+import { createMaintenance } from "./maintenance.js";
+import { createStandaloneApi } from "./api-standalone.js";
+import { createSemantic } from "./semantic.js";
+import { createVectorIndex } from "./vector-index.js";
+import { provisionRuntime } from "./runtime/provision.js";
+import { defaultRuntimeDir, listPayloadDirs } from "./runtime/layout.js";
+
+const EMBED_PROVIDERS = new Set(["off", "local", "ollama", "openai"]);
+
+/**
+ * 组装并启动一个独立数据面(含语义管线)。
+ * @param {object} opts
+ *   memoryDir  — 数据目录;缺省与宿主同默认 ~/.dsh/memory(config.js:9),支持前导 ~。
+ *   port/host  — 透传 createStandaloneApi;缺省走 kv external_api 持久值 > 8790/127.0.0.1。
+ *   logger     — console 形状(info/warn/error,收单字符串);缺省 null(全链路容缺)。
+ *   strictPort — 默认 true:配置端口被占即失败(第三方把 URL 写死,顺延=静默打到
+ *                错误端口)。显式 port=0(测试/OS 分配)不受影响。
+ *   embed      — "local"(默认,自管 runtime 取件 + ONNX 嵌入)|"ollama"|"openai"
+ *                (读宿主面板配的 vector-config)|"off"(纯关键词 + BM25)。
+ *   embedder/reranker — 注入式覆盖(测试/宿主方自管):给了就跳过 createSemantic,
+ *                直接 setEmbedder/setReranker;仅 embed="off" 之外有意为之。
+ * @returns {api, store, service, settings, maintenance, semantic, tokenExisted, dispose}
+ *   tokenExisted — 启动前 kv 里是否已有 token;false 时本次为首次生成,入口层可提示。
+ */
+export async function createServeRuntime({
+  memoryDir, port, host, logger = null, strictPort = true, embed = "local", embedder = null, reranker = null
+} = {}) {
+  if (!EMBED_PROVIDERS.has(embed)) {
+    throw new Error(`invalid embed provider: ${String(embed)}(允许 off/local/ollama/openai)`);
+  }
+  // index.js:192-195:~ 展开只认前导;目录不存在时 node:sqlite 直接抛,先 mkdir。
+  const dir = String(memoryDir || join(homedir(), ".dsh", "memory")).replace(/^~(?=$|[\\/])/, homedir());
+  mkdirSync(dir, { recursive: true });
+
+  // 装配顺序照 index.js:197-292:store → settings → mirror → service → recoverMirror。
+  const store = createStore(join(dir, "memory.db"));
+  const settings = createSettings(store.db);
+  // 第一期不吃宿主 config schema(schemastery 是宿主 peer 依赖,独立进程装不装随缘),
+  // 配最小集,与第三方 embedded 挂载实测同形:language 参与镜像渲染与去重标题;
+  // documentMemoryEnabled 关掉 document 子系统(daemon 不建 documentIndex,service
+  // 内部 if-guard 安全,index.js:261 的 documentIndex 仅宿主装配)。
+  const cfg = { language: "zh", documentMemoryEnabled: false };
+  const mirror = createMirror(dir, langOf(cfg));
+  const service = createService({ store, mirror, config: cfg, logger });
+
+  // index.js:292:上次镜像同步失败留下的 dirty 状态,启动时安全重渲一次(内部自吞)。
+  service.recoverMirror();
+
+  // index.js:319-332:人改镜像先合并——镜像文件里的手工编辑每次启动都赢。
+  // readHumanEdits 全类型一次读齐:mergeHumanEdits 成功会重渲全部镜像,逐类型读改
+  // 循环会拿没读到的类型覆盖掉未合并的编辑(index.js:324-327 注释同款坑)。
+  // 何时 apply 由 semantic 的分支时序契约决定(见 semantic.js 文件头),本文件只造闭包。
+  const humanEdits = new Map();
+  for (const type of Object.keys(TYPE_FILE)) humanEdits.set(type, mirror.readHumanEdits(type));
+  const applyHumanEdits = () => {
+    for (const [type, edits] of humanEdits) {
+      if (edits.length) service.mergeHumanEdits(type, edits);
+    }
+  };
+
+  // index.js:316-317:向量索引包住 store 的 embedding 列并跟踪活跃模型指纹。
+  const vectorIndex = createVectorIndex({ store, logger });
+  service.setVectorIndex(vectorIndex);
+
+  // ---- 语义管线(PR2):三路二选一 ------------------------------------------
+  let semantic = null;
+  if (embedder !== null) {
+    // 注入式覆盖(测试 / 宿主方自管 embedder):绕过装配,人改合并立刻做
+    //(对齐宿主 openai 分支的同步语义)。
+    service.setEmbedder(embedder);
+    if (reranker !== null) service.setReranker(reranker);
+    applyHumanEdits();
+  } else if (embed === "off") {
+    // 纯关键词 + BM25:对齐宿主 lightMode 分支——不建 embedder,人改合并立即。
+    applyHumanEdits();
+  } else {
+    let semanticReady = true;
+    if (embed === "local") {
+      // 自管 runtime 缺失时取件:只走 download 档(宿主 adopt 推导对独立进程无意义
+      // ——没有宿主 node_modules 可推)。失败不阻断 daemon:降级关键词 + 可操作提示。
+      semanticReady = await ensureRuntimePayload(logger);
+    }
+    if (semanticReady) {
+      semantic = createSemantic({
+        store, service, settings,
+        cfg: daemonSemanticCfg(embed),
+        logger, vectorIndex, applyHumanEdits, lightMode: false
+      });
+    } else {
+      applyHumanEdits();
+    }
+  }
+
+  // index.js:294-309:检索回执落 recall_runs(searchMemories 的 recordRecall 默认开,
+  // 第三方检索统计因此不缺数)。best-effort:回执写失败绝不影响检索本身。
+  service.setRecallRecorder((recall) => {
+    try {
+      store.saveRecallRun({
+        query: recall.query,
+        mode: recall.mode,
+        topK: recall.topK,
+        threshold: recall.threshold ?? null,
+        candidates: recall.candidates ?? [],
+        created_at: recall.createdAt
+      });
+    } catch { /* non-fatal: recall recording is bookkeeping */ }
+  });
+
+  // index.js:636:#275 无损回收。daemon 带上它,POST /maintenance/reclaim 才有后端
+  // (api-standalone 缺 maintenance 时该路由 503);同样不挂启动路径、不接定时器。
+  const maintenance = createMaintenance({ store, config: cfg, logger });
+
+  // index.js:643-649 同一工厂;差别只有 strictPort 默认开(daemon 语义,见上)。
+  // token 与宿主共用同一 kv 键 external_api:首次启动自动生成并持久化
+  // (api-standalone.js:203-212),DSH 面板 / CLI / daemon 三方零配置共享凭证。
+  const tokenExisted = Boolean(settings.getExternalApi?.()?.token);
+  // embedder 注入 /context 的查询嵌入（issue #370）：三路取当前生效的同一句柄——
+  // 注入覆盖用注入值，semantic 路用它的产物，off/lightMode 为 null（路由侧降级
+  // 规则档）。与 service.setEmbedder 的是同一个实例，不存在第二真相源。
+  const api = createStandaloneApi({ service, store, config: cfg, logger, settings, port, host, maintenance, strictPort, embedder: embedder ?? semantic?.embedder ?? null });
+
+  return {
+    api,
+    store,
+    service,
+    settings,
+    maintenance,
+    semantic,
+    tokenExisted,
+    /**
+     * 收尾：先停收新请求、等在途请求跑完，再关库——直接同步关库会让在途的
+     * PUT/POST 撞上已关的 store（500 或丢写）。closeIdleConnections 排干
+     * keep-alive 空闲连接（node ≥18.2，旧版无此 API 则跳过），否则 server.close
+     * 的回调要等 keep-alive 超时才触发。node:sqlite 对未 finalize 语句可能抛，
+     * 吞掉——WAL 会在下次打开时回放，已提交事务不丢。
+     */
+    async dispose() {
+      await new Promise((resolve) => {
+        try {
+          api.server.close(() => resolve());
+          api.server.closeIdleConnections?.();
+        } catch { resolve(); }
+      });
+      try { semantic?.dispose(); } catch { /* 同上 */ }
+      try { store.close(); } catch { /* 同上 */ }
+    }
+  };
+}
+
+/**
+ * daemon 侧语义配置:默认值逐键锚定 src/config.js(309-420),daemon 不装 schemastery
+ * (宿主 peer 依赖),同值硬编码;config.js 改默认值时此处与 docs/DAEMON.md 同步。
+ * 只放开 embedProvider(CLI --embed);rerank 暂不提供 CLI(默认关,与宿主同默认)。
+ */
+function daemonSemanticCfg(embed) {
+  return {
+    embedProvider: embed,                          // config.js:309(宿主默认 openai;daemon 默认 local——独立部署唯一自洽路径)
+    localEmbedModel: "Xenova/bge-small-zh-v1.5",   // :312
+    localEmbedDimension: 512,                      // :313
+    localEmbedDevice: "cpu",                       // :314
+    localEmbedBatchSize: 8,                        // :315
+    localEmbedPooling: "auto",                     // :323(BGE 系 CLS 口径,改它=换向量空间)
+    ollamaBaseUrl: "http://localhost:11434",       // :326
+    ollamaModel: "nomic-embed-text",               // :331
+    embedModelCacheDir: "",                        // :336(空=local-embedder 内部解析 ~/.dsh/mneme/models)
+    embedModelMirror: "https://hf-mirror.com",     // :337
+    resilientModelDownload: true,                  // :342
+    runtimeDir: process.env.DSH_MNEME_RUNTIME_DIR || "",  // :348(空=defaultRuntimeDir;取件/加载同源)
+    rerankEnabled: false,                          // :419
+    rerankProvider: "none",                        // :420
+    autoReindexOnBoot: true                        // :367
+  };
+}
+
+/**
+ * 本地推理 runtime 取件(download 档)。返回 payload 是否可用:
+ * 已存在(含收编/早前下载)→ true 不重复取;缺失 → 取件成功 true / 失败 false(内部
+ * 已打降级日志)。并发安全由 provisionRuntime 的 IN_FLIGHT 锁保证(按归一化 runtimeDir 串行)。
+ */
+async function ensureRuntimePayload(logger) {
+  const runtimeDir = process.env.DSH_MNEME_RUNTIME_DIR || "";
+  const dir = runtimeDir || defaultRuntimeDir();
+  if (listPayloadDirs(dir).length > 0) return true;
+  logger?.info?.("[dsh-mneme] 本地推理运行时缺失,开始取件(download 档,约 200MB;离线可用 DSH_MNEME_RUNTIME_TARBALL_DIR / DSH_MNEME_RUNTIME_MIRROR)…");
+  try {
+    const result = await provisionRuntime({ runtimeDir, localTarballDir: process.env.DSH_MNEME_RUNTIME_TARBALL_DIR || "", mirror: process.env.DSH_MNEME_RUNTIME_MIRROR || "" });
+    if (!result.ok) throw new Error(result.reason);
+    logger?.info?.(`[dsh-mneme] 运行时就绪(${result.strategy}):${result.packages} 包 / ${result.files} 文件`);
+    return true;
+  } catch (error) {
+    logger?.warn?.(`[dsh-mneme] runtime provisioning failed, search degrades to keyword: ${String(error)}`);
+    return false;
+  }
+}

package/lib/service.js

@@ -359,6 +359,22 @@ export function createService({ store, mirror, config, onWrite, logger, document
     }
   }
 
+  /**
+   * v0.8.0 A3（issue #17）strictScope 硬过滤的**唯一实现**。三处共用：融合池、
+   * `entity:` 与 `attr:` 两条前缀路。
+   *
+   * 抽成单一实现是为了让「过滤点写在哪」不再漂移——那两条前缀路在 searchMemories
+   * 的入口就 return（见那里的路由块），早于融合池那道过滤，曾经整条绕过硬墙；三处
+   * 各写一份判断，只会让下一个新增通路再漏一次（同 #349 把阈值口径收进
+   * activeStoreSize 的理由：两处各写一份过滤条件，漂移只在某条路径上显形）。
+   *
+   * strictScope 关（默认）或 scope 解析不到时原样返回：行为与改动前逐字节一致。
+   */
+  function gateByScope(rows, scope) {
+    if (config?.strictScope !== true || !scope) return rows;
+    return rows.filter((m) => isVisibleInScope(m, scope));
+  }
+
   /**
    * Search for memories attached to a named entity (v0.3.0 Phase 3).
    * 合并优先级：entity_attrs.memory_id 精确关联 = 1.0 > 关键词提及 = 0.7；
@@ -366,23 +382,34 @@ export function createService({ store, mirror, config, onWrite, logger, document
    * @param {string} entityName
    * @param {object} [options]
    * @param {number} [options.topK=20]
+   * @param {object|null} [options.scope] 当前会话 scope，供 strictScope 闸门使用
    * @returns {any[]}
    */
-  function searchByEntity(entityName, { topK = 20 } = {}) {
+  function searchByEntity(entityName, { topK = 20, scope = null } = {}) {
     const entity = store.findEntityByName(entityName);
     if (!entity) return [];
     const attrs = store.getCurrentAttrs(entity.id);
     const memoryIds = [...new Set(attrs.map((a) => a.memory_id).filter(Boolean))];
     const attrHits = memoryIds.map((id) => store.getById(id)).filter(Boolean);
-    const keywordHits = store.search(entityName, { limit: topK });
+    // 关键词这一路的窗口取两倍：闸门在截断之前生效，出局的候选会让位，窗口按最终条数
+    // 取就会不够（与融合路给向量检索取 lim * 2 同一个理由）。没有候选被闸掉时结果与
+    // 取 topK 逐字节一致——多出来的是排在后面的低分候选，进不了 topK。
+    const keywordHits = store.search(entityName, { limit: topK * 2 });
     const merged = new Map();
     for (const mem of attrHits) merged.set(mem.id, { ...mem, _source: "entity_attr", _score: 1.0 });
     for (const mem of keywordHits) {
       if (!merged.has(mem.id)) merged.set(mem.id, { ...mem, _source: "keyword", _score: 0.7 });
     }
-    const hits = Array.from(merged.values()).sort((a, b) => b._score - a._score).slice(0, topK);
-    touchRecalled(hits);
-    return hits;
+    // 先过闸、再截 topK：反过来做的话，出局的候选会占掉名额、可见的补不进来——topK=1
+    // 而首位出局时直接返回空数组。排序本身不动，只是把闸门插在截断之前，与融合池那条
+    // 路同序（那边也是先 filter 后 slice）。
+    const ranked = Array.from(merged.values()).sort((a, b) => b._score - a._score);
+    const visible = gateByScope(ranked, scope).slice(0, topK);
+    // 闸门还必须在 touchRecalled **之前**：放在后面的话，一次越权检索照样会给出局的
+    // 行刷回温时钟，并在被动确认开启时 bump 它们的关联边——命中反馈落到了调用方
+    // 本不该看见的行上。
+    touchRecalled(visible);
+    return visible;
   }
 
   /**
@@ -392,17 +419,19 @@ export function createService({ store, mirror, config, onWrite, logger, document
    * @param {string | undefined} value
    * @param {object} [options]
    * @param {number} [options.topK=20]
+   * @param {object|null} [options.scope] 当前会话 scope，供 strictScope 闸门使用
    * @returns {any[]}
    */
-  function searchByAttr(key, value, { topK = 20 } = {}) {
+  function searchByAttr(key, value, { topK = 20, scope = null } = {}) {
     if (!key) return [];
     // value 可能为 undefined（attr:key 无 = 值）：归一为空串后交给
     // store.findMemoriesByAttr —— 空 value 契约 = 返回该 attr_key 的全部
     // 当前有效记忆（v0.3.0，store.js 已实现）。
     const rows = store.findMemoriesByAttr(key, value ?? "");
-    const hits = rows.slice(0, topK);
-    touchRecalled(hits);
-    return hits;
+    // 同 searchByEntity：先过闸再截 topK，且闸门在 touchRecalled 之前。
+    const visible = gateByScope(rows, scope).slice(0, topK);
+    touchRecalled(visible);
+    return visible;
   }
 
   /**
@@ -896,9 +925,7 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // （区别于 A2 的降权保留可见）；未标注行与命中行保留。strict 与 A2 加权
     // 叠加：过滤后剩下的命中行仍吃加成。scope 未传（flag 关）或完全解析不到
     // 时跳过——identity 为空的对象（{null,null}）按 fail-closed 过滤。
-    if (config.strictScope === true && scope) {
-      merged = merged.filter((m) => isVisibleInScope(m, scope));
-    }
+    merged = gateByScope(merged, scope);
     // v0.8.0 A2：occurred_at 时间过滤——在融合池上先滤再 dedup/slice，rerank
     // 只看窗内候选，topK 槽位不被窗外行占用。
     const occurredBounds = updatedAtBounds(occurredFrom, occurredTo);
@@ -1503,7 +1530,11 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // 合序都不动）。heat 关闭时不建表、不算 heat，权重恒 1，排序与改动前一致。
     // selectiveInject 相似度重排（下方）开启且向量可用时相似度优先——heat 只
     // 生效于规则路排序与语义路回填序。
-    const heatMap = config?.heatEnabled === true
+    // issue #218 / E5 效用考卷：heat 乘进注入排序在真实年龄混合下饿死老约束
+    // （现行量级 ≡ 拟合参数，importance-only 遵从 +12.7pp），故注入侧 heat 拆出
+    // 独立开关 injectHeatEnabled（默认关）：不开时权重恒 1，排序与 heat 关闭
+    // 逐字节一致；召回侧时钟（touchLastAccess）与 sleep 降级联判不受影响。
+    const heatMap = config?.heatEnabled === true && config?.injectHeatEnabled === true
       ? new Map(filtered.map((m) => [m.id, computeHeat(m, Date.now(), config)]))
       : null;
     const heatOf = (m) => (heatMap ? heatMap.get(m.id) ?? 1 : 1);
@@ -1631,11 +1662,6 @@ export function createService({ store, mirror, config, onWrite, logger, document
         }
       } catch { /* topic re-rank unavailable: keep rule-based order */ }
     }
-    // v0.8.0 A3（issue #17）：strictScope 硬过滤同样作用于自动注入——scoped 记忆
-    // 泄进无关注入上下文是最典型的越权通道，检索侧过滤挡不住这里。
-    if (config?.strictScope === true && scope) {
-      candidates = candidates.filter((m) => isVisibleInScope(m, scope));
-    }
     // #24 块3：图召回候选打标。entityRecall 只在 entityRecallEnabled 开启时
     // 有产出，这里为命中者贴 graphHint 标签——注入侧据此（a）graphInjectHint
     // 开=标成 [检索线索] 前缀的线索行（独立预算），（b）关=线索行只参与排序
@@ -1656,6 +1682,16 @@ export function createService({ store, mirror, config, onWrite, logger, document
         }
       } catch { /* graph hint is best-effort */ }
     }
+    // v0.8.0 A3（issue #17）：strictScope 硬过滤同样作用于自动注入——scoped 记忆
+    // 泄进无关注入上下文是最典型的越权通道，检索侧过滤挡不住这里。
+    // 位置纪律：必须在**图召回合并之后**、pin 池之前——entityRecall 不做 scope
+    // 门控，过滤放在它前面时，出局行会被图召回重新打上 graphHint 带回候选池
+    // （graphInjectHint 开时作为线索行进注入块；CodeRabbit on #371 的可达性分析，
+    // /context 与宿主注入同受影响）。pin 池 eligible 取自本过滤之后的候选，
+    // 顺带保证越权行进不了 pin。
+    if (config?.strictScope === true && scope) {
+      candidates = candidates.filter((m) => isVisibleInScope(m, scope));
+    }
     // #249 第一批：B1 pin 池。取在相关性排序之后、轮换之前——取谁按此刻的候选
     // 次序（即相关性次序），取到后从候选中摘除，于是下面的轮换重排碰不到它们
     // （验收：pin 不参与跨轮轮换）。独立预算的两层意义：pin 既不占 maxItems

package/lib/settings.js

@@ -83,6 +83,8 @@ const FEATURE_FLAG_BOOLEANS = [
   "autoDreamFailureBackoff",
   "sleepModeEnabled",
   "heatEnabled",
+  // issue #218 / E5：注入侧 heat 独立开关（默认关，老用户 injectHeatEnabled=true 回滚）。
+  "injectHeatEnabled",
   "hybridInject",
   "selectiveInjectEnabled",
   "searchSemanticDedup",
@@ -123,7 +125,11 @@ const FEATURE_FLAG_BOOLEANS = [
   // enforce 真拦；都默认关。同上，点号键平铺存、合并时展开回
   // writeAdmission 对象。
   "writeAdmission.enabled",
-  "writeAdmission.enforce"
+  "writeAdmission.enforce",
+  // Issue #164 A2：写入边界的密钥 / PII 判据（src/sensitive-scan.js）。与上面两个
+  // 键分层——本键决定「这类判据参不参与」（默认关），命中之后是仅告警还是真拦仍由
+  // writeAdmission.enforce 决定（#164 口径：默认仅告警、拦截 opt-in）。
+  "sensitiveScanEnabled"
 ];
 // 整数开关的闭区间，与 config.js 里 z.natural().min().max() 对齐。
 const FEATURE_FLAG_INT_RANGES = {

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.12",
+  "version": "0.8.14",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,12 +16,16 @@
   "icon": "assets/icon.svg",
   "bin": {
     "dsh-mneme": "bin/cli.mjs",
-    "dsh-mneme-mcp": "bin/dsh-mneme-mcp.mjs"
+    "dsh-mneme-mcp": "bin/dsh-mneme-mcp.mjs",
+    "dsh-mneme-serve": "bin/dsh-mneme-serve.mjs"
   },
   "exports": {
     ".": {
       "default": "./lib/index.js"
     },
+    "./serve": {
+      "default": "./lib/serve.js"
+    },
     "./client": {
       "default": "./lib/client.js"
     },

package/scripts/changelog-prep.mjs

@@ -0,0 +1,36 @@
+// 发布准备里「在 CHANGELOG 顶部插版本占位节」这一步的单一实现。
+//
+// 为什么抽成模块而不是留在入口里：入口 scripts/release-prep.mjs 在仓库根、import 即
+// 执行，测不了；而这一步恰恰踩过坑——原先的实现在 **CRLF 检出**上用 /^(# Changelog\n\n)/
+// 匹配文件头，命中不了于是 replace 退化成 no-op，**脚本却照样打印 ✓**，git status 里
+// 什么也看不见。发版时最怕的就是这种假成功（CI 跑在 ubuntu 上是 LF，所以只有本机会中招）。
+// 抽出来之后：行尾两种都能吃，匹配不上则**如实回报**，由入口报错退出。
+//
+// 与 scripts/test-count-sync.mjs 同一个理由：规则收在共用模块里才测得到、也才不会两处各写一份。
+
+/** 取出文本的行尾风格：插入的内容跟着它走，避免把 CRLF 文件混成一半 CRLF 一半 LF。 */
+export function detectEol(text) {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
+
+/**
+ * 在 `# Changelog` 标题之后插入 `## [version] - date` 占位节（幂等：已含该版本则不改）。
+ *
+ * 返回 `{ok:false, reason}` 而不是静默返回原文——调用方必须能区分「没什么可做」与
+ * 「该做但没做成」，后者要报错退出。`reason` 取值：`already-present` / `header-not-found`。
+ *
+ * @param {string} text CHANGELOG 全文
+ * @param {string} version 如 "0.8.13"
+ * @param {string} date 如 "2026-10-03"
+ * @returns {{ok: true, text: string} | {ok: false, reason: "already-present" | "header-not-found"}}
+ */
+export function insertReleaseSection(text, version, date) {
+  if (text.includes(`## [${version}]`)) return { ok: false, reason: "already-present" };
+  const eol = detectEol(text);
+  const head = `## [${version}] - ${date}${eol}${eol}## 🐛 修复${eol}${eol}- （待填）${eol}${eol}`;
+  // BOM 可选：带 BOM 的检出上 `^#` 同样匹配不到，属于同一类「形状变了就静默失败」。
+  // 行尾 `\r?\n` 两种都吃——这就是本模块存在的首要理由。
+  const out = text.replace(/^(\uFEFF?# Changelog\r?\n\r?\n)/, `$1${head}`);
+  if (out === text) return { ok: false, reason: "header-not-found" };
+  return { ok: true, text: out };
+}