@modusensus/dsh-mneme 0.12.0 → 0.13.0

package/src/diary/library.js

@@ -0,0 +1,189 @@
+/**
+ * 日记库：把 `<memoryDir>/diaries/` 底下的所有分桶读成「谁写了多少篇」的清单。
+ *
+ * 和 `dir.js` 的分工：那边管**一个桶在哪**（给定 projectRoot 算键与路径），
+ * 这边管**有哪些桶**——左侧面板要的是后者，它拿不到「当前会话的项目」，
+ * 因为 `main` 座位不注入 sessionId。
+ *
+ * 「谁写的」只记在正文 frontmatter 里（`persona: settings (amarre)`），库里
+ * 没有第二份。所以这里读最新一篇的 frontmatter 来认人：读不到就退回桶名，
+ * 绝不猜——猜错会把 A 的日记挂到 B 名下，而那在界面上看不出来。
+ */
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { DIARY_FILE_RE, diaryRoot } from "./dir.js";
+
+/** frontmatter 块：文件必须以 `---` 起头，第二道横线收尾。 */
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+
+/**
+ * 桶键 → 项目根与写日记的 agent。来源是 diaries/state.json（compose 自己写的账本）。
+ *
+ * 为什么面板要这个：一个桶就是一份 `projectKey(projectRoot)` 的产物，桶名里只有
+ * 目录名和 8 位哈希，**反推不回绝对路径**。而「现在再写一篇」必须给 `project`。
+ * 读不到就返回空表——那是「这个桶是别人手工放的」或「账本丢了」，面板那时候
+ * 就不该长出一个点了必然 400 的按钮。
+ */
+function readBucketState(root) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(join(root, "state.json"), "utf8"));
+  } catch {
+    return {};
+  }
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+
+/**
+ * 桶名合法性：**不按字符集白名单**，按「它是个单层目录名」判。
+ *
+ * 一开始写的是 `^[A-Za-z0-9._-]+$`，理由是路径成分越严越好——但现场就有一个
+ * 保留中文的桶（`QQ对话-4f061790`，用户那天让另一个会话手工写的）。白名单会把
+ * 那一本从导航栏里抹掉，等于把用户写过的日记藏起来，而界面上看不出来。
+ *
+ * 所以要挡的是**路径语义**，不是字符：分隔符、上跳、控制字符、首尾空白、
+ * 以及 `.` / `..` 这两个特殊目录名。挡完这些，桶名就只剩「单层目录名」这一种
+ * 可能，下游可以直接拼路径，不需要再比一次路径前缀（见 `bucketDir` 的注释）。
+ */
+export function isBucketName(name) {
+  const s = String(name ?? "");
+  if (!s || s !== s.trim()) return false;
+  if (s === "." || s === "..") return false;
+  if (/[/\\]/.test(s)) return false;
+  // eslint-disable-next-line no-control-regex
+  if (/[\u0000-\u001f\u007f]/.test(s)) return false;
+  return true;
+}
+
+/**
+ * 桶名 → 目录绝对路径。名字不合法就是 `null`。
+ *
+ * 这里**没有**第二道「解析后比对根前缀」的校验：`isBucketName` 已经挡住了
+ * 分隔符与上跳，剩下的只可能是单层名字，前缀比对永远走不到。试过写它，
+ * 变异测试（把比对删掉）一跑八条用例全绿，正说明它是死代码——那就别留，
+ * 留着的防御没人能验证，反而让人以为这里有一层额外的兜底。
+ */
+function bucketDir(root, bucket) {
+  if (!isBucketName(bucket)) return null;
+  return join(root, bucket);
+}
+
+function readFrontmatter(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    return {};
+  }
+  const hit = FRONTMATTER_RE.exec(text);
+  if (!hit) return {};
+  const out = {};
+  for (const line of hit[1].split(/\r?\n/)) {
+    const at = line.indexOf(":");
+    if (at <= 0) continue;
+    const key = line.slice(0, at).trim();
+    const value = line.slice(at + 1).trim();
+    if (key) out[key] = value;
+  }
+  return out;
+}
+
+/**
+ * 列一个桶里的日记文件。与 `export.js` 的 `listDiaries` 同一口径
+ * （只认 `YYYY-MM-DD.md`、跳过空文件、新的在前），这里不重复实现。
+ */
+function diaryFiles(dir) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const name of names) {
+    if (!DIARY_FILE_RE.test(name)) continue;
+    const path = join(dir, name);
+    let st;
+    try {
+      st = statSync(path);
+    } catch {
+      continue;
+    }
+    if (!st.isFile() || st.size <= 0) continue;
+    rows.push({ date: name.slice(0, 10), path, bytes: st.size, mtime: st.mtimeMs });
+  }
+  return rows.sort((a, b) => (a.date < b.date ? 1 : a.date > b.date ? -1 : 0));
+}
+
+/**
+ * 全部桶。读不到根目录返回空清单而不是抛——「还没写过第一篇」与「路径坏了」
+ * 在面板上是两种不同的话，但这一层分不出来，交给调用方去看 `root`。
+ */
+export function listDiaryLibrary({ memoryDir, configured = "" } = {}) {
+  const root = diaryRoot({ memoryDir, configured });
+  let names;
+  try {
+    names = readdirSync(root);
+  } catch {
+    return { root, buckets: [] };
+  }
+  const buckets = [];
+  const state = readBucketState(root);
+  for (const name of names) {
+    // `.deleted` 一类是回收站，不是日记。
+    if (name.startsWith(".")) continue;
+    if (!isBucketName(name)) continue;
+    const dir = join(root, name);
+    let st;
+    try {
+      st = statSync(dir);
+    } catch {
+      continue;
+    }
+    if (!st.isDirectory()) continue;
+    const files = diaryFiles(dir);
+    // 空桶（文件被删光、只剩 runs.jsonl）不列：导航栏里挂一个点开是空的项
+    // 比不列更糟。
+    if (!files.length) continue;
+    let persona = "";
+    let project = "";
+    for (const file of files) {
+      const fm = readFrontmatter(file.path);
+      if (!project && fm.project) project = fm.project;
+      // persona 只认第一篇带它的：同一桶里可能先后住过两个人格（#613 要拆的那种），
+      // 面板先按最新那篇记的人显示，不混。
+      if (fm.persona) {
+        persona = fm.persona;
+        break;
+      }
+    }
+    const meta = state[name] && typeof state[name] === "object" ? state[name] : {};
+    buckets.push({
+      key: name,
+      project,
+      // 「现在再写一篇」需要的两样：绝对路径与写作者身份。账本里没有就留空，
+      // 面板据此把按钮禁掉——不猜路径，猜错会写在别的项目里。
+      projectRoot: typeof meta.projectRoot === "string" ? meta.projectRoot : "",
+      agentId: typeof meta.agentId === "string" ? meta.agentId : "",
+      persona,
+      latest: files[0].date,
+      count: files.length,
+      entries: files.map((file) => ({ date: file.date, bytes: file.bytes, mtime: file.mtime }))
+    });
+  }
+  buckets.sort((a, b) => (a.latest < b.latest ? 1 : a.latest > b.latest ? -1 : 0));
+  return { root, buckets };
+}
+
+/** 读一篇的正文。桶名与日期都要过校验：这条路径直接拼文件系统。 */
+export function readLibraryEntry({ memoryDir, configured = "", bucket, date } = {}) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(String(date ?? ""))) return null;
+  const root = diaryRoot({ memoryDir, configured });
+  const dir = bucketDir(root, bucket);
+  if (dir === null) return null;
+  try {
+    return readFileSync(join(dir, `${date}.md`), "utf8");
+  } catch {
+    return null;
+  }
+}

package/src/diary/qq-inbox.js

@@ -0,0 +1,142 @@
+/**
+ * 素材来源之一：QQ 聊天收件箱（只读）。
+ *
+ * 这个模块**不 import `dsh-onebot-qq` 的任何东西**——那个包是 npm 装进来的普通目录，
+ * 每次升级都会被覆盖，边界靠这个 provider 的入参/返回值切开，而不是靠 require 路径。
+ *
+ * 素材口径（实测 `D:\\DSH\\.dsh\\media\\onebot\\qq-inbox.jsonl` 的 decision 分布定下来的）：
+ * 只取 `decision.stage === "dispatch" && decision.ok === true` 且消息里真有 text 段的行。
+ * 同一份样本里 70 行中，白名单挡掉的群聊 20 行、投递成功但无有效文本 5 行——不滤掉，
+ * 日记就会变成「今天什么也没干」的噪音，还占掉 document 注入预算。
+ *
+ * 已知缺口（照实写在这里，别当它不存在）：inbox 只有**入站**消息，机器人自己的回复
+ * 不在其中（样本里 message_sent 命中 0）。所以日记能写「今天她说了什么」，
+ * 写不了「我怎么回的」——需要时得另找来源，不能靠这一份编。
+ */
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { localDateString } from "./rollover.js";
+import { memoryBase } from "./dir.js";
+
+/** `qq-inbox.jsonl` = 当前代（0），`qq-inbox.N.jsonl` = 越旧 N 越大。 */
+export const INBOX_FILE_RE = /^qq-inbox(?:\.(\d+))?\.jsonl$/;
+
+function generationOf(name) {
+  const m = INBOX_FILE_RE.exec(name);
+  return m && m[1] ? Number(m[1]) : 0;
+}
+
+/**
+ * 收件箱文件，**新的在前**。
+ *
+ * 目录读不到返回 null（= 没有这个来源），与「目录在但没有消息」严格区分：
+ * 前者是 `no-inbox-dir`，后者是 `no-material`，两者的处置完全不同。
+ */
+export function inboxFiles(dir) {
+  if (!dir) return null;
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  return names
+    .filter((n) => INBOX_FILE_RE.test(n))
+    .sort((a, b) => generationOf(a) - generationOf(b));
+}
+
+/** 只打码长度 ≥6 的数字串（与 onebot `lib/record.js:47-49` 的 redactDigits 同口径）。 */
+export function redactDigits(text) {
+  return String(text ?? "").replace(/\d{6,}/g, (m) => m.slice(0, 3) + "****");
+}
+
+/** 一条消息里所有 text 段的拼接。图片/表情/语音段没有可读正文，直接跳过。 */
+export function textOf(frame) {
+  const msg = frame && frame.message;
+  if (!Array.isArray(msg)) return "";
+  return msg
+    .filter((s) => s && s.type === "text" && s.data && typeof s.data.text === "string")
+    .map((s) => s.data.text)
+    .join("")
+    .trim();
+}
+
+/** 有效投递：`dispatch` 且 `ok === true`。其余（whitelist / command / 失败）都不算素材。 */
+export function isEffective(frame) {
+  const d = frame && frame.decision;
+  return !!d && d.stage === "dispatch" && d.ok === true;
+}
+
+/**
+ * 采一段窗口内的素材。
+ *
+ * 返回三选一：
+ * - `{items, scanned, ignored}` 拿到东西（items 可以为空 = 当天确实没聊）
+ * - `{error: "no-inbox-dir"}` 没有这个来源（目录不在）
+ * - `{error: "inbox-unreadable", detail}` 目录在但一个文件都读不出来
+ */
+export function collectQqInbox({ dir, dateLocal, maxItems = 400 } = {}) {
+  if (!dir) return { error: "no-inbox-dir" };
+  const files = inboxFiles(dir);
+  if (files === null) return { error: "no-inbox-dir", detail: String(dir) };
+  if (files.length === 0) return { error: "inbox-unreadable", detail: String(dir) };
+  const items = [];
+  let scanned = 0;
+  let ignored = 0;
+  let readable = 0;
+  for (const name of files) {
+    let text;
+    try {
+      text = readFileSync(join(dir, name), "utf8");
+    } catch {
+      continue;
+    }
+    readable += 1;
+    for (const line of text.split("\n")) {
+      if (!line.trim()) continue;
+      scanned += 1;
+      let row;
+      try {
+        row = JSON.parse(line);
+      } catch {
+        // 坏行跳过但计数（与 loadObservations 同一条纪律）。
+        ignored += 1;
+        continue;
+      }
+      if (!row || row.kind !== "message" || !isEffective(row.frame)) {
+        ignored += 1;
+        continue;
+      }
+      const ts = Number(row.ts);
+      if (!Number.isFinite(ts)) {
+        ignored += 1;
+        continue;
+      }
+      // 不在当天窗口内的行不算「忽略」，它属于别的日子。
+      if (localDateString(new Date(ts)) !== dateLocal) continue;
+      const body = textOf(row.frame);
+      if (!body) {
+        ignored += 1;
+        continue;
+      }
+      items.push({ ts, role: "user", text: redactDigits(body).slice(0, 2000) });
+    }
+  }
+  if (readable === 0) return { error: "inbox-unreadable", detail: String(dir) };
+  items.sort((a, b) => a.ts - b.ts);
+  return { items: items.slice(-maxItems), scanned, ignored };
+}
+
+/**
+ * 把 `<DSH_HOME>/media/onebot` 推出来：memoryDir 默认就是 `<DSH_HOME>/memory`。
+ *
+ * 推不出来（memoryDir 被指到别处、或给了显式配置）就用配置值；两者都没有时这个来源
+ * 直接报 `no-inbox-dir`——宁可这一路没有素材，也不去猜别的盘。
+ */
+export function resolveInboxDir({ memoryDir, configured = "" } = {}) {
+  const custom = String(configured ?? "").trim();
+  if (custom) return custom;
+  // 必须走 memoryBase 而不是直接用配置串：默认值就是带 `~` 的字面量，
+  // 不展开的话 join 出来的路径永远落空，旁挂会静默读不到（CodeRabbit #458 F2）。
+  return join(memoryBase(memoryDir), "..", "media", "onebot");
+}

package/src/diary/rollover.js

@@ -0,0 +1,61 @@
+/**
+ * 跨天判定：本机没有日历调度原语（cordis.patch.yml 没有 schedules 服务，
+ * node_modules 里唯一的 scheduler 是 React 那个），所以「每天 0 点写一篇」写不出来。
+ *
+ * 可实现的等价形态是**跨天惰性判定**：在 turn/end 与插件启动两个既有挂载点上问
+ * 「上一次写的日期是不是今天」，不是才写。差别只在于「今天一句话没说」那天没有日记
+ * ——而那恰好是对的：没有素材就不该编。
+ *
+ * 全部是纯函数（时间由调用方注入），所以「跨 5 天只补 1 天」这类边界能被真的测出来。
+ */
+
+/** 宿主本地时区的 `YYYY-MM-DD`。刻意不用 UTC：日记的「今天」是用户感知的今天。 */
+export function localDateString(date) {
+  const d = date instanceof Date ? date : new Date(date);
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+function toUtcMs(dateLocal) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(String(dateLocal ?? ""));
+  if (!m) return null;
+  return Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+}
+
+/** `to - from` 的整数天数；任一参数形状不对返回 null（调用方据此走「当作首次」）。 */
+export function dayGap(fromDate, toDate) {
+  const a = toUtcMs(fromDate);
+  const b = toUtcMs(toDate);
+  if (a === null || b === null) return null;
+  return Math.round((b - a) / 86400000);
+}
+
+/** 一次最多回补几天。默认 1：睡得久一点就补一篇，不该醒来一次补十篇把模型配额烧光。 */
+export const MAX_CATCH_UP_DAYS = 1;
+
+/**
+ * 今天该不该写。
+ *
+ * 返回 `{roll, gapDays, gap}`：
+ * - `roll` 要不要写。`lastDate` 为空（从没写过）→ 写。
+ * - `gapDays` 距上次写的天数（null = 没写过或日期形状不对）。
+ * - `gap` 中间有没有「永久丢掉」的日子（超过回补上限）——必须如实写进日记头部，
+ *   不能假装连续。这是本模块唯一允许对读者撒谎的地方，所以它必须是个返回值，
+ *   不是一个可选参数。
+ *
+ * 时钟往回调（`lastDate` 比今天还新）时不写：那不是「跨天」，那是同一份时间被
+ * 重算了一次，再写一次只会覆盖掉今天已经写好的那篇。
+ */
+export function shouldRollDay(lastDate, today, { maxCatchUpDays = MAX_CATCH_UP_DAYS } = {}) {
+  const now = String(today ?? "");
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(now)) return { roll: false, gapDays: null, gap: false };
+  const last = String(lastDate ?? "");
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(last)) return { roll: true, gapDays: null, gap: false };
+  if (last === now) return { roll: false, gapDays: 0, gap: false };
+  const gapDays = dayGap(last, now);
+  if (gapDays === null || gapDays < 0) return { roll: false, gapDays, gap: false };
+  const limit = Number.isFinite(maxCatchUpDays) && maxCatchUpDays >= 0 ? maxCatchUpDays : MAX_CATCH_UP_DAYS;
+  return { roll: true, gapDays, gap: gapDays > limit };
+}

package/src/diary/session-provider.js

@@ -0,0 +1,122 @@
+/**
+ * 素材来源之二：当前会话自己的转录（**主来源**）。
+ *
+ * 需求原话是「与人格注入绑定，当前的拥有人格的 agent 写日记」——那就意味着日记的
+ * 素材首先得是**这个 agent 自己这一天经历过的对话**，而不是 QQ 收件箱里别人的消息。
+ * QQ inbox 只是没有会话上下文时（启动补写）的兜底来源。
+ *
+ * 口径与 summarize.js 的蒸馏转录**刻意同源**（那里已把隐私边界定完，不重写第二份）：
+ * - 只认 `user/message` 与 `assistant/message`；
+ * - 机器注入内容（AGENTS.md、skill 正文、文件变更通知）按 `source.kind` 挡掉；
+ * - assistant 的 reasoning 私有思考块不采集（textOf 只认 `type:"text"`）；
+ * - 工具调用/结果不进日记（那是过程，不是这一天发生的事）。
+ *
+ * 这个模块是纯的：会话对象由调用方给，时间由事件带，不读盘、不联网、不碰 ctx。
+ */
+import { localDateString } from "./rollover.js";
+import { redactDigits } from "./qq-inbox.js";
+
+/** 单条消息进 prompt 的上限：一条超长粘贴不该把整篇日记的预算吃掉。 */
+export const MAX_ITEM_CHARS = 1200;
+
+/**
+ * 会话身份（决定用哪张人格卡）。与 `src/inject.js:311-336` 同一口径。
+ *
+ * ⚠️ 不能先读 `requestHeader()`：那返回的是请求级模型路由头，会把 `agentPreset`
+ * 遮蔽成空（scope.js 里记着本地 web 实测踩中过）。身份只在 `session.header` 里。
+ */
+export function sessionAgentId(session) {
+  try {
+    const header = session?.header ?? null;
+    const preset = header?.agentPreset;
+    return typeof preset === "string" && preset.trim() ? preset.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 会话事件里可选的时间字段。三个都试是因为宿主各版本用过不同的名字。 */
+function eventTimeMs(event) {
+  for (const key of ["at", "time", "ts"]) {
+    const v = event?.[key];
+    if (typeof v === "number" && Number.isFinite(v)) return v;
+    if (typeof v === "string" && v.trim()) {
+      const parsed = Date.parse(v);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+  }
+  return null;
+}
+
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => (typeof block === "string" ? block : block && block.type === "text" && typeof block.text === "string" ? block.text : ""))
+    .filter(Boolean)
+    .join("\n");
+}
+
+/** 事件里有没有**可公开的会话正文**。与 summarize.js 的 publicTranscriptParts 同一套判据。 */
+function bodyOf(event) {
+  const data = event?.data ?? {};
+  const kind = data?.source?.kind;
+  if (event?.type === "user/message") {
+    // 机器注入内容（kind 非 user）不进素材：那不是「你们今天聊的」。
+    if (kind !== undefined && kind !== "user") return null;
+    const text = textOf(data?.content).trim();
+    return text ? { role: "user", text } : null;
+  }
+  if (event?.type === "assistant/message") {
+    const text = textOf(data?.message?.content).trim();
+    return text ? { role: "assistant", text } : null;
+  }
+  return null;
+}
+
+/**
+ * 采当前会话的转录。
+ *
+ * `dateLocal` 为 null 时取**全部**事件（手动按钮的语义：「就把现在这段写下来」，
+ * 不按自然日切）。给日期时只留那一天的事件——事件没有时间戳的一律丢弃：无法证明
+ * 它属于今天，就不能把它写进今天。
+ *
+ * 返回 `{items, scanned, ignored}`（items 可以为空）或 `{error}`。
+ */
+export function collectSessionTranscript({ session, dateLocal = null, maxItems = 400, maxChars = MAX_ITEM_CHARS } = {}) {
+  if (!session) return { error: "no-session" };
+  let events = null;
+  try {
+    events = typeof session.snapshotEvents === "function" ? session.snapshotEvents() : session.events;
+  } catch {
+    events = session?.events ?? null;
+  }
+  if (!Array.isArray(events)) return { error: "session-unreadable" };
+
+  const items = [];
+  let scanned = 0;
+  let ignored = 0;
+  for (const event of events) {
+    const body = bodyOf(event);
+    if (!body) {
+      // 工具调用/系统事件占了绝对多数，数进 ignored 会让「忽略」这个词失真。
+      // 只把它们跳过，不计入 ignored。
+      continue;
+    }
+    scanned += 1;
+    const ts = eventTimeMs(event);
+    if (dateLocal !== null && dateLocal !== undefined) {
+      if (ts === null || localDateString(new Date(ts)) !== dateLocal) {
+        // 别的日子不算「忽略」，无时间戳才算读不懂。
+        if (ts === null) ignored += 1;
+        continue;
+      }
+    }
+    items.push({
+      ts,
+      role: body.role,
+      text: redactDigits(body.text).slice(0, maxChars)
+    });
+  }
+  return { items: items.slice(-maxItems), scanned, ignored };
+}

package/src/dream/decisions.js

@@ -119,6 +119,16 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // 不够的——ACTIONS 是两个模块共用的，模型自发出 supersede / differentiate 时校验器
   // 照样放行，"opt-in 零行为变化"就成了空话。省略 / null = 不限制（沿用全局 ACTIONS）。
   const allowedActions = Array.isArray(options.allowedActions) ? new Set(options.allowedActions) : null;
+  // reflectionUpdateEnabled=false：update 在本次调用里不算合法动作。走与
+  // allowedActions 同一条单条跳过的通路（不是整单拒绝）——用户关掉的是「改写已有
+  // 记忆」这一种动作，模型多输出了几条 update 不该连带丢掉同批的 merge/archive。
+  // 与 prompt 侧后缀双闸：prompt 让模型别写，这里兜住模型仍然写了的情况。
+  const allowUpdate = options.allowUpdate !== false;
+  // 被用户开关关掉的动作单独计数：它们进 skipped（要留痕），但不该触发下面的
+  // 「全部跳过 = 模型坏了」整单拒绝——那是防幻觉 id / 截断输出的护栏，而这里是
+  // 用户自己关掉的动作。混在一起会让「只输出了 update」的一轮被判 failed、调度器
+  // 拿同一批输入重跑同一条必被拒的输出，无限循环。
+  let policySkipped = 0;
   if (!Array.isArray(decisions)) {
     return { ok: false, errors: ["decision list must be an array"], resolvedShortIds: 0 };
   }
@@ -168,6 +178,7 @@ export function validateDecisions(decisions, snapshot, options = {}) {
     // 单条校验错误先进 local：skipInvalid 模式下整条跳过，严格模式下才并入
     // 全局 errors（沿用 v0.6.9 的双轨结构）。
     const local = [];
+    let policyDisabled = false;
     // Issue #126：supersede 与 conflict 一样用 winner/loser 定位双方（沿用同一套
     // 字段，校验与 receipt 逻辑因此可以直接复用）。
     const ids = d && (d.action === "conflict" || d.action === "supersede") ? [d.winner, d.loser] : (d?.ids ?? []);
@@ -176,6 +187,12 @@ export function validateDecisions(decisions, snapshot, options = {}) {
     } else if (allowedActions && !allowedActions.has(d.action)) {
       // 动作本身合法，但不在当前档位允许的集合里（例如默认档收到 supersede）。
       local.push(`${at}: action ${JSON.stringify(d.action)} not allowed in this mode`);
+    } else if (d.action === "update" && !allowUpdate) {
+      // reflectionUpdateEnabled=false：旧记忆永不被自动改写。这条要排在
+      // allowedActions 之后、update 字段校验之前——先判「这个动作本次不许用」，
+      // 再谈字段合不合规，否则同一条会同时报两个错、日志里读不出真实原因。
+      local.push(`${at}: update action is disabled (reflectionUpdateEnabled=false)`);
+      policyDisabled = true;
     } else if (d.action === "conflict" || d.action === "supersede") {
       if (!d.winner || !d.loser || d.winner === d.loser) {
         local.push(`${at}: ${d.action} needs distinct winner and loser`);
@@ -328,11 +345,15 @@ export function validateDecisions(decisions, snapshot, options = {}) {
         // title/content）、还是字段给了但值不合规（has_* 为 true 仍报错）。
         // 只加布尔不加原文：原文进 llm_audit_logs.metadata 与 dream_runs.raw_output，
         // 这里保持每条记录足够小（skipped 会按轮累积进一行 JSON）。
+        if (policyDisabled) policySkipped++;
         skipped.push({
           index,
           action: d?.action,
           ids,
           error: local.join("; "),
+          // true = 用户开关关掉了这个动作（不是模型输出有问题）。调用方据此区分
+          // 「这轮白跑」与「这轮输出坏了」。
+          ...(policyDisabled ? { policyDisabled: true } : {}),
           has_keepSource: d?.keepSource !== undefined && d?.keepSource !== null,
           has_title: typeof d?.title === "string" && d.title.trim().length > 0,
           has_content: typeof d?.content === "string" && d.content.trim().length > 0
@@ -391,7 +412,9 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // 子集为空时仍整单拒绝——宽容的前提是「有合法子集可应用」；模型输出整体
   // 非法（如全部幻觉 id）是真故障，不能被隐式 keep 洗成 ok。#104 只豁免
   // 「有合法子集但覆盖率不足」的良性挑重点（见下方 coverageShortfall）。
-  if (options.skipInvalid === true && skipped.length > 0 && survivors.length === 0 && errors.length === 0) {
+  // 只把「非策略性跳过」算进这条：policySkipped 是用户关掉的动作，不是模型故障。
+  const modelSkipped = skipped.length - policySkipped;
+  if (options.skipInvalid === true && modelSkipped > 0 && survivors.length === 0 && errors.length === 0) {
     errors.push(`all ${skipped.length} decision(s) invalid — nothing valid survived validation`);
     return { ok: false, errors, skipped, resolvedShortIds };
   }
@@ -514,6 +537,7 @@ function casGuard(service, snapshot, ids) {
  */
 export function applyDecisions(decisions, service, logger = null, snapshot = null, config = {}) {
   let applied = 0;
+  let merged = 0;
   const conflicts = [];
   const failures = [];
   const committed = [];
@@ -528,6 +552,12 @@ export function applyDecisions(decisions, service, logger = null, snapshot = nul
       const outcome = applyOne(d, service, snapshot, config, logger);
       if (outcome === "skipped") continue;
       applied += outcome.applied;
+      // `merged` counts creates that hit a same-title row instead of minting a
+      // new one. Kept apart from `applied` on purpose: a create that vanished
+      // into an existing row is not a new conclusion, and folding it in is how
+      // two different dispositions ended up looking like two minted patterns
+      // (#619 audit round 5).
+      if (outcome.merged) merged += outcome.merged;
       committed.push(outcome.committed);
     } catch (error) {
       if (error instanceof CasConflictError) {
@@ -539,7 +569,7 @@ export function applyDecisions(decisions, service, logger = null, snapshot = nul
       }
     }
   }
-  return { applied, conflicts, failures, committed };
+  return { applied, merged, conflicts, failures, committed };
 }
 
 function applyOne(d, service, snapshot, config = {}, logger = null) {
@@ -597,20 +627,41 @@ function applyCreate(d, service, config = {}, logger = null) {
   // 信它就等于让模型给自造条目盖「人写的」戳（见 applyDecisions 的 @param config）。
   // 取不到就一个字段都不传，落回 saveWithDedupe 原有的兜底，行为与改前一致。
   const mintSource = typeof config?.mintSource === "string" ? config.mintSource.trim() : "";
+  // pattern 是「整句重写」而不是「增量补充」：同一 (人, 对象, 情绪) 的标题天然
+  // 相同，saveWithDedupe 命中后若走 appendContent，重放一轮就把同一段结论再粘
+  // 一遍（实测 161 → 355 → 549 字，外加一串重复的 [证据: …] 尾巴），而 pattern
+  // 正是注入面消费的东西。`_overwrite` 是既有逃生口（bootstrap / dream summary /
+  // narrative 三处先例）：命中同题行时原地刷新而不是追加，旧文进 content_history。
+  // 只对 pattern 放开——其他类型被 create 撞上同题行时仍按合并语义走，那多半是
+  // 模型自造了不该出现的类型，把既有行整段覆盖掉比追加更危险。
+  const overwrite = type === "pattern";
   const created = service.saveWithDedupe({
     type,
     title,
     content: body,
     importance,
-    ...(mintSource ? { source: mintSource } : {})
+    ...(mintSource ? { source: mintSource } : {}),
+    ...(overwrite ? { _overwrite: true } : {})
   });
   const memory = created?.memory;
   if (!memory) return "skipped"; // deduped/subsumed: nothing minted, clean no-op
+  // 命中同题活跃行 ⇒ saveWithDedupe 返回 action:"merged"。它确实动过库（刷新了
+  // 那一行），但**没有铸出新条目**：把它算进 applied 会让「一条真实结论被同题行
+  // 吃掉了」这种情况看起来像成功（#619 审计第五轮：两个不同对象铸出同一条
+  // pattern，applied 照样报 2）。两类结局分开报：applied 只数新铸，merged 数刷新。
+  const refreshed = created?.action !== "created";
   // #512：这条记忆出生自哪一轮。只记 create——merge/conflict/update/supersede 对
   // 既有行的改动已由 receipt_chain 按 (run_id, record_id) 记账，再造一份就是第二套账。
+  //
+  // #619 / Ephor 第七轮 ③：`refreshed` 也在这条规矩里。原地刷新没有铸新条目，
+  // 它改的是既有行——同一条记忆不该有两份「出生记录」。此前 create_merged 这条
+  // 新路没被上面那句规矩覆盖，于是一个 pattern 跑两轮，`memory_mints` 就有两行、
+  // run_id 各不相同，面板上显示成「这条记忆出生过两次」（`mintsFor` 由
+  // provenance-http.js 读取）。live 库当时还没显形，是因为同题刷新刚上线。
+  //
   // 记账失败不许拖垮这次铸造：归因是审计，记忆已经落盘了。
   try {
-    if (typeof service?.saveMemoryMint === "function" && config?.runId) {
+    if (!refreshed && typeof service?.saveMemoryMint === "function" && config?.runId) {
       service.saveMemoryMint({
         memoryId: memory.id,
         runId: config.runId,
@@ -622,7 +673,7 @@ function applyCreate(d, service, config = {}, logger = null) {
   } catch (mintError) {
     logger?.warn?.(`dsh-mneme dream: failed to record memory mint: ${String(mintError?.message ?? mintError)}`);
   }
-  return { applied: 1, committed: { action: "create", id: memory.id, type } };
+  return { applied: refreshed ? 0 : 1, merged: refreshed ? 1 : 0, committed: { action: refreshed ? "create_merged" : "create", id: memory.id, type } };
 }
 
 function applyArchive(d, service, snapshot) {