@modusensus/dsh-mneme 0.11.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/document.js

@@ -276,8 +276,9 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
       }
       // #275 拍板 5（#230 验收口径的补丁）：升格吸收的 evidence 行随之退出活跃面——
       // 一次吸收 20 条，库里就是「21 行不是 1 行」。四条口径：①与本行同一事务（要么
-      // 都成、要么都不成）；②pinned（constraint / preference，即 #249 的逐字保真池）
-      // 永不自动归档——升格不能绕过它；③自有生命周期的类型（document / summary，见
+      // 都成、要么都不成）；②pinned 永不自动归档——升格不能绕过它，而 pinned 有**两个**
+      // 判据：显式钉住的行（pinned_memories，#593 起为唯一正源）与 #249 的逐字保真池
+      // 类型（constraint / preference）；③自有生命周期的类型（document / summary，见
       // ABSORB_EXEMPT_TYPES）不吸收，吸收的是原子条；④只翻标志位、内容与审计全留
       // （可恢复），opt-out 走 archiveEvidence。
       // pinnedTypes 拿不到就不做这一步：宁可少做，也不能把保真池当普通行收走。
@@ -294,7 +295,12 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
           const row = store.getById(id);
           if (!row || row.archived || row.forgotten) continue;
           if (isImportedRow(row)) { evidenceSkipped += 1; continue; }
-          if (pinnedTypes.has(row.type) || ABSORB_EXEMPT_TYPES.has(row.type)) continue;
+          // #593：显式 pin（pinned_memories）与类型保真池是**两个**判据。上一版只问
+          // pinnedTypes.has(row.type)，等于把「被钉住的 pattern / decision」当普通行
+          // 收走——用户钉过的东西在文档升格时被静默归档，正是「钉着 ≠ 会注入」的
+          // 反面：这里连「钉着」都没保住。store.isPinned 缺席时退回类型口径（旧行为）。
+          const explicitlyPinned = typeof store.isPinned === "function" && store.isPinned(row.id);
+          if (explicitlyPinned || pinnedTypes.has(row.type) || ABSORB_EXEMPT_TYPES.has(row.type)) continue;
           store.setArchived(id, true);
           evidenceArchived += 1;
         }

package/src/dream/clustering.js

@@ -1,7 +1,12 @@
 // Cosine similarity of two equal-length numeric vectors. Returns 0 for empty
 // or mismatched-length inputs, and for zero-norm vectors (numerically stable).
+// Accepts typed arrays (Float32Array) as well as plain arrays: store.js caches
+// vectors as Float32Array and `Array.isArray` is false for typed arrays — guarding
+// on it alone would silently score every cached vector as 0.
+const isVec = (v) => Array.isArray(v) || (ArrayBuffer.isView(v) && !(v instanceof DataView));
+
 export function cosineSimilarity(a, b) {
-  if (!Array.isArray(a) || !Array.isArray(b) || a.length === 0 || a.length !== b.length) return 0;
+  if (!isVec(a) || !isVec(b) || a.length === 0 || a.length !== b.length) return 0;
   let dot = 0, na = 0, nb = 0;
   for (let i = 0; i < a.length; i++) {
     dot += a[i] * b[i];