feat(document): 升格吸收的 evidence 随之归档 + 归档侧第五指标（#275）

dsh-mneme/docs/STORAGE.md

@@ -65,6 +65,25 @@ VACUUM 是 O(库大小)，且需要排他写锁：库越大越慢，期间的写
 - 窗口内（默认 7 天）的输入快照不动：近期 run 仍可能在离线回放里被用到。
 - `run_type='organize'` 的行任何窗口都不清：它们的 `input` 存的是 apply 的重放载荷（`src/organize.js` 直接读它重建候选索引），不是可重建的快照。置空会让那次 apply 静默空转并把报告锁死。
 
+## 升格吸收的 evidence（#230 × #275）
+
+`memory_register_document` 注册成功后，这份文档引用的 evidence 行会**在同一事务里**翻成归档（absorbed）。一次吸收 20 条，活跃面就少 20 行——而不是「21 行不是 1 行」。
+
+- 只翻标志位：内容、`content_history`、审计行一条不删，随时可以还原；
+- `constraint` / `preference` 永不自动归档（#249 的逐字保真池），要归档得手动来；
+- 只吸收**原子条**：别的 `document` 行与 `summary` 行不碰——前者本体是磁盘上的文件（归档它会让同一路径下次注册留下第二行），后者是 dream 总览与叙述（按 source 身份去重、按注入档位常驻）；
+- 想保留活跃面：工具带 `keep_evidence_active: true`（注册器参数是 `archiveEvidence: false`）；
+- 重注册同一份文档（出新版）时，那些已归档的 evidence 行仍可为**它所属的那份文档**背书；换个文档拿归档 id 当证据，照旧按捏造拒绝。
+
+## 第五指标：归档净增速率 + 可压掉行数
+
+面板「记忆复用」卡与 `GET /api/dsh-mneme/recall-stats` 的返回里多了一个 `archive` 块（#275 拍板：与既有指标同位）：
+
+- `total` / `addedInWindow` / `perDay`：归档区现有行数、窗口内新进的、以及日均净增速率。归档时刻取行的 `updated_at`（`setArchived` 会刷它）——代理口径：再改一次已归档行就会被算进本窗口，精确口径要一个 `archived_at` 列（属第二批题材）；
+- `compressible.rows` / `.groups`：**可压掉行数**——同 type、同 scope、内容归一化后逐字节相同的归档行里，每组留下的那一行之外的那些。判据用内容哈希（与写入准入同一把尺），**不**建在向量近重复上：回收动作本身就会清掉归档行的向量，指标不能指望自己的输入还在。
+
+这是观察口，不是动作触发：真删仍属第二批（未立项）。
+
 ## 与 #254 的分界
 
 本入口止体积、不止重复。归档区里同主题条目堆积是**出口**问题，归 #254 的写入准入与后续整理动作面；这里一条记忆都不碰（维护者拍板 4）。

dsh-mneme/lib/client.js

@@ -559,6 +559,7 @@ window.__ModuleLoader__.load({
         "memory.status.recallStats": "记忆复用",
         "memory.status.recallHint": "复用率 {rate} · 僵尸 {zombie}/{active}（豁免 {exempt}）· 30 天回执 {runs} 次 · Top：{top}",
         "memory.status.recallInject": "注入 {runs} 轮 {count} 条，槽位填充 {fill}%",
+        "memory.status.recallArchive": "归档 {total} 行（{add}/天），精确重复可压掉 {compress} 行",
         "memory.status.viewAll": "查看全部",
         "memory.status.depositedCount": "沉淀的记忆（{n}）",
         "memory.status.archivedCount": "已归档的记忆（{n}）",
@@ -946,6 +947,7 @@ window.__ModuleLoader__.load({
         "memory.status.recallStats": "Recall reuse",
         "memory.status.recallHint": "reuse {rate} · zombie {zombie}/{active} (exempt {exempt}) · {runs} runs in 30d · top: {top}",
         "memory.status.recallInject": "injected {runs} turns · {count} items ({fill}% slots)",
+        "memory.status.recallArchive": "archived {total} rows (+{add}/day) · {compress} exactly-duplicate rows compressible",
         "memory.status.viewAll": "View all",
         "memory.status.depositedCount": "Deposited memories ({n})",
         "memory.status.archivedCount": "Archived memories ({n})",
@@ -3613,15 +3615,19 @@ window.__ModuleLoader__.load({
     // 口径不可信）或库为空时整卡不渲染，前端不感知；truncated（扫描超上限）
     // 只影响 hint 里的回执计数，不挡渲染。
     function RecallStatsCard({ t }) {
-      const [state, setState] = useState({ loading: true, off: false, rate: null, zombie: 0, active: 0, exempt: 0, runs: 0, top: "", inject: "" });
+      const [state, setState] = useState({ loading: true, off: false, rate: null, zombie: 0, active: 0, exempt: 0, runs: 0, top: "", inject: "", archive: "" });
       useEffect(() => {
         let cancelled = false;
         apiFetch("/api/dsh-mneme/recall-stats?window=30")
           .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
           .then((d) => {
             if (cancelled) return;
             const z = d.zombie || {};
-            const hasData = (d.coverage?.runsScanned ?? 0) > 0 || (z.activeCount ?? 0) > 0;
+            // 归档侧第五指标（#275）不能只靠 run/active 两路撑整张卡：整库归档是它的正常
+            // 工作状态，那种库「窗口内没有召回回执、也没有活跃僵尸行」时若 hasData 为假，
+            // 组件直接走 off 分支 return null，归档指标永远没机会显示。
+            const hasData = (d.coverage?.runsScanned ?? 0) > 0 || (z.activeCount ?? 0) > 0
+              || (d.archive?.total ?? 0) > 0;
             if (!hasData) {
               setState({ loading: false, off: true });
               return;
@@ -3638,10 +3644,19 @@ window.__ModuleLoader__.load({
                 .replace("{count}", String(inj.injectedCount ?? 0))
                 .replace("{fill}", inj.slotFillRate == null ? "—" : String(Math.round(inj.slotFillRate * 100)))
               : "";
+            // 第五指标（#275）：归档净增速率 + 可压掉行数。与注入口径同款自门控
+            // ——归档区为空时整段省略，不往卡里塞一个恒 0 的数字。
+            const ar = d.archive || {};
+            const archive = (ar.total ?? 0) > 0
+              ? t("memory.status.recallArchive")
+                .replace("{total}", String(ar.total ?? 0))
+                .replace("{add}", String(ar.perDay ?? 0))
+                .replace("{compress}", String(ar.compressible?.rows ?? 0))
+              : "";
             setState({
               loading: false, off: false, rate,
               zombie: z.zombieCount ?? 0, active: z.activeCount ?? 0,
-              exempt: z.exemptCount ?? 0, runs: d.coverage?.runsScanned ?? 0, top, inject
+              exempt: z.exemptCount ?? 0, runs: d.coverage?.runsScanned ?? 0, top, inject, archive
             });
           })
           .catch(() => { if (!cancelled) setState({ loading: false, off: true }); });
@@ -3660,7 +3675,7 @@ window.__ModuleLoader__.load({
           .replace("{active}", String(state.active))
           .replace("{exempt}", String(state.exempt))
           .replace("{runs}", String(state.runs))
-          .replace("{top}", state.top || "—") + (state.inject ? " · " + state.inject : "")
+          .replace("{top}", state.top || "—") + (state.inject ? " · " + state.inject : "") + (state.archive ? " · " + state.archive : "")
       });
     }
 

dsh-mneme/lib/document.js

@@ -60,20 +60,34 @@ export function isManagedDocumentPath(dir, path) {
 // id + 旧行 content_history 里的旧摘要（source=superseded）。
 const supersededByPointer = (id) => `\n\n[superseded by ${id}]`;
 
+// 升格吸收不碰的类型（#275 拍板 5 的边界）：吸收的对象是「原子条」，而下面这两种
+// 行各有自己的生命周期，被归档会各自留下第二行——
+//   document：本体是磁盘上的文件。归档它等于替用户撤下外档；而且 supersede 探测
+//     只看活跃行（store.list 默认排除归档），同一 path 下次注册会在旧行还挂着
+//     「新版本」语义时再铸一行，指针注记与 content_history 记账也走不到。
+//   summary：dream 总览与叙述按 source 身份去重、并按注入档位常驻。归档它会让下一
+//     次做梦把它当不存在（候选集同样只取活跃行），于是库里多出一行同源总览。
+// 口径是保守方向的：拿不准的行一律不吸收——少做一步没有代价，收错一步是内容事故。
+const ABSORB_EXEMPT_TYPES = new Set(["document", "summary"]);
+
 /**
  * Build the document registrar. Injected deps are service.js closure members
  * (store / embedQuery / transaction / finalize) so this module stays free of
  * service-internal wiring; `finalize` is the single write epilogue (mirror
  * sync + notify + re-embed) so callers never duplicate it.
  *
- * @returns {(payload: object) => Promise<object>}
+ * `pinnedTypes` 是注入的 #249 逐字保真池（service.js 的 PINNED_MEMORY_TYPES）：
+ * 这里不 import 它在 service.js 里，是因为 service.js 反向 import 本模块——
+ * 方向反了会成环。
+ *
+ * @returns {(payload: object, opts?: object) => Promise<object>}
  *   `{ action: "created"|"superseded", memory, superseded?, evidence_kept,
- *      evidence_dropped, degraded }`
+ *      evidence_dropped, evidence_archived, degraded }`
  * @throws flag 关 / 路径非法或文件缺失 / title 或 summary 为空 / evidence 全部
  *   捏造 / 仅 vector 近重复（疑似重复外档，交 agent 裁决而不是静默二选一）。
  */
-export function createDocumentRegistrar({ store, config, embedQuery, pushContentHistory, transaction, finalize }) {
-  return async function registerDocument(payload, { hiddenEvidenceIds = [] } = {}) {
+export function createDocumentRegistrar({ store, config, embedQuery, pushContentHistory, transaction, finalize, pinnedTypes }) {
+  return async function registerDocument(payload, { hiddenEvidenceIds = [], archiveEvidence = true } = {}) {
     // opt-in 总闸（#230 对齐 #228 形态）：关 = 注册入口整体不存在，错误信息
     // 指回配置键，agent 能准确转告用户去开。
     if (config?.documentMemoryEnabled !== true) {
@@ -121,15 +135,14 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
     const hidden = new Set((Array.isArray(hiddenEvidenceIds) ? hiddenEvidenceIds : []).map((id) => String(id)));
     const kept = [];
     const dropped = [];
+    // 存在但已归档的引用另记一份：它可能是被上一版文档升格吸收走的行（见下方
+    // supersede 目标探测后的「认回」），不能一律按「不可用」处理。
+    const archivedRefs = new Set();
     for (const id of wanted) {
       const row = hidden.has(id) ? null : store.getById(id);
+      if (row?.archived) archivedRefs.add(id);
       (row && !row.archived ? kept : dropped).push(id);
     }
-    if (wanted.length > 0 && kept.length === 0) {
-      throw new Error(
-        `registerDocument: all ${wanted.length} evidence ids are unknown, archived or out of scope — fabricated evidence is rejected`
-      );
-    }
 
     const title = String(payload?.title ?? "").trim();
     if (!title) throw new Error("registerDocument: title is required");
@@ -162,6 +175,25 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
       .filter((m) => scopeMatches(m));
     const explicitTarget = scopeMatched.find((m) => samePath(m.doc_path, expanded))
       ?? scopeMatched.find((m) => m.title.trim() === title);
+    // 升格吸收过的引用认回（#275 拍板 5 的配套）：evidence 行在文档注册成功后就翻了
+    // archived，于是「同一份文档出新版、evidence 照旧」这一最常规的路径会整批落在
+    // dropped——那会被下面的捏造判据误报成「证据都是编的」。口径：已归档行仍可为
+    // **吸收它的那份文档**背书（loser.evidence 就是它吸收走的名单），不为别的文档
+    // 背书；捏造与跨 scope 照旧拒绝。
+    if (explicitTarget) {
+      const own = new Set(explicitTarget.evidence ?? []);
+      for (const id of archivedRefs) {
+        if (!own.has(id)) continue;
+        const at = dropped.indexOf(id);
+        if (at >= 0) dropped.splice(at, 1);
+        kept.push(id);
+      }
+    }
+    if (wanted.length > 0 && kept.length === 0) {
+      throw new Error(
+        `registerDocument: all ${wanted.length} evidence ids are unknown, archived or out of scope — fabricated evidence is rejected`
+      );
+    }
     if (!explicitTarget) {
       // vector 档：embedder 不可用/向量缺失一律跳过——去重是增强不是写入依赖
       // （findSessionDuplicate 同原则）。probe 用 title+summary，与行向量
@@ -237,7 +269,25 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
         store.setArchived(loser.id, true);
         superseded = store.getById(loser.id);
       }
-      return { created, superseded };
+      // #275 拍板 5（#230 验收口径的补丁）：升格吸收的 evidence 行随之退出活跃面——
+      // 一次吸收 20 条，库里就是「21 行不是 1 行」。四条口径：①与本行同一事务（要么
+      // 都成、要么都不成）；②pinned（constraint / preference，即 #249 的逐字保真池）
+      // 永不自动归档——升格不能绕过它；③自有生命周期的类型（document / summary，见
+      // ABSORB_EXEMPT_TYPES）不吸收，吸收的是原子条；④只翻标志位、内容与审计全留
+      // （可恢复），opt-out 走 archiveEvidence。
+      // pinnedTypes 拿不到就不做这一步：宁可少做，也不能把保真池当普通行收走。
+      let evidenceArchived = 0;
+      if (archiveEvidence && pinnedTypes && typeof pinnedTypes.has === "function") {
+        for (const id of kept) {
+          // 事务内重读：期间被别的进程归档/遗忘的行不重复计数，也不误伤 pinned。
+          const row = store.getById(id);
+          if (!row || row.archived || row.forgotten) continue;
+          if (pinnedTypes.has(row.type) || ABSORB_EXEMPT_TYPES.has(row.type)) continue;
+          store.setArchived(id, true);
+          evidenceArchived += 1;
+        }
+      }
+      return { created, superseded, evidenceArchived };
     });
     finalize(result.superseded ? [result.created, result.superseded] : [result.created]);
     return {
@@ -246,6 +296,7 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
       ...(result.superseded ? { superseded: result.superseded } : {}),
       evidence_kept: kept.length,
       evidence_dropped: dropped.length,
+      evidence_archived: result.evidenceArchived,
       degraded: dropped.length > 0
     };
   };

dsh-mneme/lib/recall-stats.js

@@ -5,6 +5,8 @@
 // 新内聚块从第一行就落在自己的文件里，service.js 保留 barrel 出口、调用方零改动。
 // 纯读不写，绝不触发任何 write hook。
 
+import { scopeKeyOf } from "./scope.js";
+
 /**
  * 口径（issue #217 评论 2026-09-18，锚 5bd2dab）：
  *  - Top-N：窗口内 recall_runs.candidates（最终返回集）按 id 计数，join
@@ -20,6 +22,17 @@
  *  - coverage：recallRecordDefault 开启前的窗口算不到，earliestRunAt 为
  *    null（窗口内无回执）或早于窗口起点时，前端标注可信度；扫描行数有
  *    上限，超出标 truncated（degraded 口径），不静默少算。
+ *  - archive（#275 拍板的第五指标，与上面几项同位）：
+ *    · total = 归档区现有行数；addedInWindow / perDay = 窗口内进入归档区的行数
+ *      与其日均（净增速率）。归档时刻只能取 updated_at（setArchived 翻标志位时刷
+ *      它）——这是代理口径：对已归档行做一次 memory_update，或对同一行重复调
+ *      setArchived(…, true)，都会被算成「本窗口新进归档」，perDay 因此偏高。精确
+ *      口径要一个 archived_at 列（schema 变更，属第二批题材），本版不加；真正的
+ *      「净」增本来也要跨快照比 total（物理删除落地后，差值才会由负向变化体现）。
+ *    · compressible = 可压掉行数：同 type、同 scope 三维且内容哈希完全相同的归档
+ *      行里，多出来的那些（每组留一行）。用内容哈希而不是向量近重复，是因为回收
+ *      动作本身会清掉归档行向量（clearArchivedEmbeddings）——指标不能建在它自己
+ *      的输入会被回收掉的数据上；精确重复与 #254 的计量口径同一把尺。
  *
  * @param {object} store - createStore 产物（只调用 listRecallRunsSince / all）
  * @param {{ windowDays?: number, exemptDays?: number }} [options]
@@ -36,7 +49,8 @@ export function recallStats(store, options = {}) {
   const rawSlots = Number(options.maxInjectSlots ?? 5);
   const maxInjectSlots = Number.isInteger(rawSlots) && rawSlots >= 1 ? rawSlots : 5;
   const now = Date.now();
-  const since = new Date(now - windowDays * 86400000).toISOString();
+  const sinceMs = now - windowDays * 86400000;
+  const since = new Date(sinceMs).toISOString();
 
   const { rows: runs, total } = store.listRecallRunsSince(since);
   const hits = new Map(); // id -> { count, title, source }
@@ -67,8 +81,29 @@ export function recallStats(store, options = {}) {
   let activeCount = 0;
   let zombieCount = 0;
   let exemptCount = 0;
+  // 第五指标（#275）：归档区一侧单独累计，分组键与 #254 的去重候选集同构
+  // （type + 哈希 + scope 三维）——可压掉的必须是「本来就会被判成同一件事」的行。
+  let archivedTotal = 0;
+  let archivedInWindow = 0;
+  const hashGroups = new Map();
   for (const m of memories) {
-    if (m.archived || m.forgotten) continue;
+    if (m.archived) {
+      archivedTotal += 1;
+      const archivedMs = Date.parse(m.updated_at ?? "");
+      if (Number.isFinite(archivedMs) && archivedMs >= sinceMs) archivedInWindow += 1;
+      if (m.content_hash) {
+        const key = [
+          m.type ?? "",
+          m.content_hash,
+          scopeKeyOf(m.agent_scope) ?? "",
+          scopeKeyOf(m.workspace_scope) ?? "",
+          scopeKeyOf(m.sensitivity) ?? ""
+        ].join("\u0000");
+        hashGroups.set(key, (hashGroups.get(key) ?? 0) + 1);
+      }
+      continue;
+    }
+    if (m.forgotten) continue;
     const createdMs = Date.parse(m.created_at ?? "");
     // created_at 解析不了时无法证明已过机会期 → 归入豁免，宁漏勿误伤
     if (!Number.isFinite(createdMs) || now - createdMs < EXEMPT_MS) {
@@ -98,6 +133,14 @@ export function recallStats(store, options = {}) {
     .sort((a, b) => b.count - a.count || a.id.localeCompare(b.id))
     .slice(0, 10);
 
+  let compressibleGroups = 0;
+  let compressibleRows = 0;
+  for (const n of hashGroups.values()) {
+    if (n < 2) continue;
+    compressibleGroups += 1;
+    compressibleRows += n - 1;
+  }
+
   return {
     windowDays,
     generatedAt: new Date(now).toISOString(),
@@ -113,6 +156,13 @@ export function recallStats(store, options = {}) {
       slotFillRate: injectRuns > 0 ? injectedCount / (injectRuns * maxInjectSlots) : null
     },
     topRecalled,
+    // #275 第五指标：归档净增速率 + 可压掉行数（口径见文件头）
+    archive: {
+      total: archivedTotal,
+      addedInWindow: archivedInWindow,
+      perDay: Math.round((archivedInWindow / windowDays) * 100) / 100,
+      compressible: { rows: compressibleRows, groups: compressibleGroups }
+    },
     zombie: {
       activeCount,
       zombieCount,

dsh-mneme/lib/service.js

@@ -2181,6 +2181,9 @@ export function createService({ store, mirror, config, onWrite, logger, document
     embedQuery,
     pushContentHistory,
     transaction,
+    // #275 拍板 5：升格吸收的 evidence 行随之归档，但 pinned 池（#249）永不自动归档
+    // ——注册器不 import 这个集合，方向反了会成环，所以在这里注入。
+    pinnedTypes: PINNED_MEMORY_TYPES,
     finalize: (rows) => {
       for (const row of rows) scheduleEmbed(row);
     }