dsh-memu-memory 1.2.1 → 1.2.2

package/scripts/lexicon-dedupe.mjs

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+// scripts/lexicon-dedupe.mjs — 历史重复词条迁移工具（docs/lexicon-design.md §10 P2）
+//
+// 背景：词条冲突检查（findScopeCollision）落地之前的历史数据可能存在「同一作用域
+// 内同规范词多条」的重复。本工具扫描 data/lexicon/*.json，按 normalizedTerm +
+// sameFactContext 作用域找重复组，dry-run（默认）只打印报告，--apply 才执行合并。
+//
+// 判定与核心写入侧（lib/lexicon.js findScopeCollision）同口径：
+//   * 组键 = normalizedTerm + IDENTITIES（channelId/speakerId/characterId/worldId/
+//     branchId），与 lib/context.js sameFactContext 完全一致；knownBy 是可见性边界
+//     （contextVisible），不算作用域。
+//   * archived 条目不参与：归档不占用冲突位置（与核心一致）。
+//   * pending 且带 revisionOf 的条目不参与：它是某个 active 词条的待审修订草稿，
+//     与其目标同词同 scope 是设计内的，不是重复。
+//
+// 保留规则：status active > pending > rejected（未知 status 按 rejected 档）；
+// 同档 updatedAt 新者优先；再按 termId 字典序收尾（结果稳定、可复算）。
+// 合并规则（写入前按核心 lib/lexicon.js 的 §1.2 上限裁剪）：
+//   * meaning 取组内最长（clip 500）；usage 保留保留条目的；
+//   * aliases / examples 并集去重（按规范化形式 / 原文），clip 8×80 / 5×200；
+//   * strength / confidence 取 max；evidence 合并去重，clip 10 条 × quote 200；
+//   * hitCounts 三计数求和（审计历史不丢），lastInjectedAt 取最新；
+//   * status / kind / sensitivity / visibility / context 沿用保留条目（context 含
+//     knownBy，不并集——并集会放宽可见边界，交集会无故收紧，都不是"合并"该做的事）；
+//   * createdAt 取组内最早（首次出现的时间）；updatedAt = 本次合并时间；
+//   * 被并条目删除前，其 id 记入保留条目的 mergedFrom: []（可审计）；指向被并
+//     条目的 rejected 指纹改指保留条目（拒绝记忆不丢）。
+// active+sensitive 的词条永不触碰：所在组整体跳过并报告。
+//
+// 用法：node scripts/lexicon-dedupe.mjs [--apply] [--library <id>]
+//   --apply          执行合并（默认 dry-run 只报告）
+//   --library <id>   只处理指定库（默认扫 data/lexicon/ 下全部安全命名的文件）
+import fs from 'node:fs'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { dataDir, readJsonStrict, readFailure, writeJson, withFileLock, isSafeId, shortHash, stamp } from '../lib/paths.js'
+
+// 与 lib/context.js IDENTITIES 同组：作用域身份字段（knownBy 不在内）。
+const IDENTITIES = ['channelId', 'speakerId', 'characterId', 'worldId', 'branchId']
+// 核心 §1.2 上限（与 lib/lexicon.js 常量一致；这里不复用模块私有常量，写死并注释同源）。
+const CAPS = { meaning: 500, usage: 300, aliases: 8, alias: 80, examples: 5, example: 200, evidence: 10, evidenceQuote: 200 }
+const STATUS_RANK = { active: 3, pending: 2, rejected: 1 }
+const STATUS_LABEL = { active: 'active', pending: 'pending', rejected: 'rejected' }
+
+function clip(text, max) {
+  const s = String(text ?? '')
+  return s.length > max ? s.slice(0, max) : s
+}
+
+/** 严格读取（与 lib/lexicon.js readLexiconStrict 同口径的本地副本，不走读缓存）。 */
+function strictReadLexicon(file) {
+  const failure = readFailure(file)
+  if (failure) throw new Error(`write-protected by an earlier read failure (${failure.code || failure.message})`)
+  const result = readJsonStrict(file)
+  if (result.missing) return null
+  if (!result.ok) throw new Error(`could not be read (${result.kind === 'corrupt' ? 'invalid JSON' : result.error?.code || 'read failed'})`)
+  const value = result.value
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || (value.version !== undefined && value.version !== 1)
+    || !value.terms || typeof value.terms !== 'object' || Array.isArray(value.terms)) {
+    throw new Error('has an invalid data shape')
+  }
+  for (const [termId, entry] of Object.entries(value.terms)) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      throw new Error(`entry ${termId} is not an object`)
+    }
+  }
+  return value
+}
+
+function scopeKeyOf(entry) {
+  return IDENTITIES.map(key => String(entry?.context?.[key] || '')).join('\u0001')
+}
+
+function scopeLabelOf(entry) {
+  const parts = IDENTITIES.filter(key => entry?.context?.[key]).map(key => `${key}=${entry.context[key]}`)
+  return parts.length ? parts.join(', ') : '(全场景)'
+}
+
+/**
+ * 判定词条是否参与重复分组。返回 null 表示排除（排除原因用于报告）。
+ */
+function participation(entry) {
+  const status = entry.status || 'active'
+  if (status === 'archived') return 'archived（不占用冲突位置，跳过）'
+  if (status === 'pending' && entry.revisionOf) return 'pending revision 草稿（active 词条的待审修订，跳过）'
+  if (!String(entry.normalizedTerm || '')) return '缺少 normalizedTerm，跳过'
+  return null
+}
+
+/** 扫描一本词典，返回 duplicate 组列表（每组 ≥2 条可参与成员）。 */
+export function scanDuplicateGroups(data) {
+  const groups = new Map()
+  for (const [termId, entry] of Object.entries(data.terms || {})) {
+    const excluded = participation(entry)
+    if (excluded) continue
+    const key = `${String(entry.normalizedTerm)}\u0000${scopeKeyOf(entry)}`
+    if (!groups.has(key)) groups.set(key, [])
+    groups.get(key).push({ termId, entry })
+  }
+  return [...groups.values()].filter(members => members.length >= 2)
+}
+
+/** 保留规则：active > pending > rejected → updatedAt 新者 → termId 字典序。 */
+function keptFirst(a, b) {
+  const ra = STATUS_RANK[a.entry.status || 'active'] || 1
+  const rb = STATUS_RANK[b.entry.status || 'active'] || 1
+  if (ra !== rb) return rb - ra
+  const ta = String(a.entry.updatedAt || ''), tb = String(b.entry.updatedAt || '')
+  if (ta !== tb) return tb.localeCompare(ta)
+  return String(a.termId).localeCompare(String(b.termId))
+}
+
+/** 为一个组产出合并计划；含 active+sensitive 成员的组整组跳过。 */
+export function planGroup(members) {
+  const sensitiveMember = members.find(m => (m.entry.status || 'active') === 'active' && m.entry.sensitivity === 'sensitive')
+  if (sensitiveMember) {
+    return { skip: true, reason: `含 active+sensitive 词条 ${sensitiveMember.termId}，工具永不触碰，整组跳过` }
+  }
+  const ordered = [...members].sort(keptFirst)
+  const kept = ordered[0]
+  const removed = ordered.slice(1)
+  const keptEntry = kept.entry
+  const normalizedTerm = String(keptEntry.normalizedTerm)
+
+  // meaning 取组内最长；usage 沿用保留条目。
+  let meaning = String(keptEntry.meaning || '')
+  for (const { entry } of removed) {
+    if (String(entry.meaning || '').length > meaning.length) meaning = String(entry.meaning || '')
+  }
+  meaning = clip(meaning.trim(), CAPS.meaning)
+
+  // aliases/examples 并集去重（aliases 按规范化形式去重，examples 按原文去重）。
+  const aliases = []
+  const seenAlias = new Set()
+  for (const { entry } of ordered) {
+    for (const alias of (Array.isArray(entry.aliases) ? entry.aliases : [])) {
+      const text = clip(String(alias ?? '').trim(), CAPS.alias)
+      const normalized = text.normalize('NFKC').toLowerCase().replace(/[\s\p{P}\p{S}]+/gu, '')
+      if (!text || normalized === normalizedTerm || seenAlias.has(normalized)) continue
+      seenAlias.add(normalized)
+      aliases.push(text)
+      if (aliases.length >= CAPS.aliases) break
+    }
+    if (aliases.length >= CAPS.aliases) break
+  }
+  const examples = []
+  const seenExample = new Set()
+  for (const { entry } of ordered) {
+    for (const example of (Array.isArray(entry.examples) ? entry.examples : [])) {
+      const text = clip(String(example ?? '').trim(), CAPS.example)
+      if (!text || seenExample.has(text)) continue
+      seenExample.add(text)
+      examples.push(text)
+      if (examples.length >= CAPS.examples) break
+    }
+    if (examples.length >= CAPS.examples) break
+  }
+
+  // strength/confidence 取 max；evidence 合并去重；三计数求和；lastInjectedAt 取最新。
+  const numOf = value => (Number.isFinite(Number(value)) ? Number(value) : null)
+  let strength = numOf(keptEntry.strength)
+  let confidence = numOf(keptEntry.confidence)
+  const hitCounts = { candidate: 0, injection: 0, query: 0 }
+  let lastInjectedAt = keptEntry.lastInjectedAt || null
+  let createdAt = String(keptEntry.createdAt || '')
+  const evidence = []
+  const seenEvidence = new Set()
+  for (const { entry } of ordered) {
+    strength = Math.max(strength ?? 0, numOf(entry.strength) ?? 0)
+    confidence = Math.max(confidence ?? 0, numOf(entry.confidence) ?? 0)
+    for (const key of Object.keys(hitCounts)) {
+      hitCounts[key] += Number(entry.hitCounts?.[key]) || 0
+    }
+    if (entry.lastInjectedAt && (!lastInjectedAt || String(entry.lastInjectedAt) > String(lastInjectedAt))) {
+      lastInjectedAt = entry.lastInjectedAt
+    }
+    const entryCreated = String(entry.createdAt || '')
+    if (entryCreated && (!createdAt || entryCreated < createdAt)) createdAt = entryCreated
+    for (const item of (Array.isArray(entry.evidence) ? entry.evidence : [])) {
+      if (!item || typeof item !== 'object') continue
+      const quote = clip(typeof item.quote === 'string' ? item.quote : '', CAPS.evidenceQuote)
+      const id = clip(typeof item.id === 'string' ? item.id : '', 160)
+      const kind = clip(typeof item.kind === 'string' ? item.kind : 'message', 40)
+      if (!quote.trim() && !id) continue
+      const sig = JSON.stringify([kind, id, quote])
+      if (seenEvidence.has(sig)) continue
+      seenEvidence.add(sig)
+      evidence.push({ kind, id, quote })
+      if (evidence.length >= CAPS.evidence) break
+    }
+    if (evidence.length >= CAPS.evidence) break
+  }
+
+  const merged = {
+    ...keptEntry,
+    meaning,
+    aliases,
+    normalizedAliases: aliases.map(alias => alias.normalize('NFKC').toLowerCase().replace(/[\s\p{P}\p{S}]+/gu, '')).filter(Boolean),
+    examples,
+    strength: strength ?? 0.6,
+    confidence: confidence ?? 0.8,
+    evidence,
+    hitCounts,
+    lastInjectedAt,
+    createdAt: createdAt || keptEntry.createdAt,
+    fingerprint: keptEntry.fingerprint || shortHash(normalizedTerm),
+    // 被并条目的 id 记入保留条目，历史可审计。
+    mergedFrom: [...(Array.isArray(keptEntry.mergedFrom) ? keptEntry.mergedFrom : []), ...removed.map(item => item.termId)],
+  }
+  return { skip: false, keptId: kept.termId, keptEntry, removeIds: removed.map(item => item.termId), merged }
+}
+
+/** 把计划应用到词典对象上（CAS：调用方必须在 withFileLock 内对最新读取执行）。 */
+export function applyPlans(data, plans, now = stamp()) {
+  for (const plan of plans) {
+    if (plan.skip) continue
+    for (const removeId of plan.removeIds) {
+      const removed = data.terms[removeId]
+      if (removed?.fingerprint && data.rejected && data.rejected[removed.fingerprint]?.termId === removeId) {
+        // 拒绝指纹改指保留条目：同一规范词的 model-proposal 依旧被拦。
+        data.rejected[removed.fingerprint].termId = plan.keptId
+      }
+      delete data.terms[removeId]
+    }
+    data.terms[plan.keptId] = { ...plan.merged, updatedAt: now }
+  }
+  data.revision = (Number(data.revision) || 0) + 1
+  data.version = 1
+  return data
+}
+
+function listLibraryFiles(onlyId) {
+  const dir = path.join(dataDir(), 'lexicon')
+  if (onlyId) {
+    if (!isSafeId(onlyId)) throw new Error(`invalid library id: ${clip(onlyId, 40)}`)
+    const file = path.join(dir, `${onlyId}.json`)
+    if (!fs.existsSync(file)) throw new Error(`lexicon file not found: ${onlyId}.json`)
+    return [{ libraryId: onlyId, file }]
+  }
+  if (!fs.existsSync(dir)) return []
+  return fs.readdirSync(dir)
+    .filter(name => name.endsWith('.json') && isSafeId(name.slice(0, -'.json'.length)))
+    .sort()
+    .map(name => ({ libraryId: name.slice(0, -'.json'.length), file: path.join(dir, name) }))
+}
+
+function reportLibrary({ libraryId, file }, apply) {
+  const data = strictReadLexicon(file)
+  if (!data) {
+    console.log(`${libraryId}: 无文件，跳过`)
+    return { groups: 0, merges: 0, skipped: 0 }
+  }
+  const groups = scanDuplicateGroups(data)
+  const plans = groups.map(members => ({ label: `${String(members[0].entry.normalizedTerm)} @ ${scopeLabelOf(members[0].entry)}`, plan: planGroup(members) }))
+  const mergePlans = plans.filter(item => !item.plan.skip)
+  console.log(`${libraryId}: revision ${data.revision ?? 0}，词条 ${Object.keys(data.terms || {}).length} 条，重复组 ${groups.length} 组`)
+  for (const { label, plan } of plans) {
+    if (plan.skip) {
+      console.log(`  [跳过] ${label}：${plan.reason}`)
+      continue
+    }
+    console.log(`  [合并] ${label}：${plan.removeIds.length + 1} 条 → 保留 ${plan.keptId} (${plan.keptEntry.status || 'active'}, updatedAt ${plan.keptEntry.updatedAt || 'null'})`)
+    console.log(`         并入并删除: ${plan.removeIds.join(', ')}`)
+    console.log(`         meaning 取最长(${plan.merged.meaning.length} 字), aliases 并集 ${plan.merged.aliases.length}, examples 并集 ${plan.merged.examples.length}, strength max ${plan.merged.strength}, evidence ${plan.merged.evidence.length} 条`)
+    console.log(`         mergedFrom 记入: [${plan.merged.mergedFrom.join(', ')}]`)
+  }
+  if (groups.length === 0) console.log('  无历史重复')
+  if (apply && mergePlans.length) {
+    withFileLock(file, () => {
+      // CAS：锁内重读最新落盘内容再套用计划，plan 基于「扫描时快照」之外的变化重算。
+      const fresh = strictReadLexicon(file)
+      if (!fresh) throw new Error('disappeared during apply')
+      const freshPlans = scanDuplicateGroups(fresh).map(members => planGroup(members))
+      applyPlans(fresh, freshPlans)
+      writeJson(file, fresh)
+      console.log(`  [写入] revision → ${fresh.revision}，词条 ${Object.keys(fresh.terms).length} 条`)
+    })
+  }
+  return { groups: groups.length, merges: apply ? mergePlans.length : 0, skipped: plans.filter(item => item.plan.skip).length }
+}
+
+function main() {
+  const args = process.argv.slice(2)
+  const apply = args.includes('--apply')
+  const libraryFlagIndex = args.indexOf('--library')
+  const onlyId = libraryFlagIndex >= 0 ? String(args[libraryFlagIndex + 1] || '').trim() : null
+  if (args.some(arg => arg === '--help' || arg === '-h')) {
+    console.log('用法: node scripts/lexicon-dedupe.mjs [--apply] [--library <id>]')
+    console.log('  默认 dry-run 只打印报告；--apply 才执行合并。')
+    process.exit(0)
+  }
+  console.log(apply ? 'lexicon-dedupe: --apply（将执行合并）' : 'lexicon-dedupe: dry-run（加 --apply 执行合并）')
+  let files
+  try {
+    files = listLibraryFiles(onlyId)
+  } catch (error) {
+    console.error(`lexicon-dedupe: ${String(error?.message || error)}`)
+    process.exit(2)
+  }
+  let totals = { groups: 0, merges: 0, skipped: 0 }
+  for (const entry of files) {
+    try {
+      const result = reportLibrary(entry, apply)
+      totals.groups += result.groups
+      totals.merges += result.merges
+      totals.skipped += result.skipped
+    } catch (error) {
+      console.log(`${entry.libraryId}: 读取失败，跳过（${String(error?.message || error)}）`)
+    }
+  }
+  console.log(`汇总: 重复组 ${totals.groups}，${apply ? `已合并 ${totals.merges}` : 'dry-run 未写入'}，含 active+sensitive 跳过 ${totals.skipped} 组`)
+}
+
+/* istanbul ignore next */
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+  main()
+}

package/tests/absorb-review.test.mjs

@@ -0,0 +1,353 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { registerHooks } from 'node:module'
+
+// Package F2 (spec §4.11 / §6.7): the pendingAbsorb review path and undo.
+//
+// Covered here:
+//   1. listReviews carries reviewRisk / reviewRiskReasons / pendingAbsorb;
+//   2. accept: resolution must be replace (coexist throws), the duplicate gate
+//      excludes target+sources, the snapshot check catches a concurrently changed
+//      source ('review changed; reload and retry'), the vector store receives ONLY
+//      the proposal id (never the sources), and the single index transaction
+//      supersedes the target, archives the sources, rewires links and writes the
+//      snapshot while clearing pendingAbsorb/reviewReason/conflictingWith;
+//   3. reject: the proposal is archived and target/sources stay untouched;
+//   4. undo-absorb through the RPC: restores target/sources/rewired links in one
+//      transaction, archives the merged entry, refuses a second undo, refuses a
+//      libraryId, refuses an entry without a snapshot, and refuses when a member
+//      was edited after absorption.
+//
+// Same hermetic pattern as tests/curator-commit.test.mjs. A managed vector
+// generation is active so the accept path's commit lands in the stub backend
+// and can be counted.
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-absorb-review-'))
+process.env.DSH_MEMU_HOME = home
+process.env.DSH_MEMU_MEMORY_HOME = home
+
+const backend = {
+  commits: [],
+  forgets: [],
+}
+globalThis.__curatorAbsorbReviewTest = {
+  async commit(args) {
+    const names = (args.payload?.recall_files || []).map((file) => file.name)
+    backend.commits.push({ names, route: args.route, db: args.db })
+    return { ok: true }
+  },
+  async forget(args) {
+    backend.forgets.push({ name: args.name, db: args.db })
+    return { deleted: 1, segments: 1 }
+  },
+  async retrieve() { return { files: [], segments: [], resources: [], raw: null } },
+  async listFiles() { return { recall_files: [], resources: [], raw: null } },
+}
+
+const memuSource = 'const bridge = globalThis.__curatorAbsorbReviewTest;'
+  + 'export const commit = (args) => bridge.commit(args), forget = (args) => bridge.forget(args),'
+  + 'retrieve = (args) => bridge.retrieve(args), listFiles = (args) => bridge.listFiles(args);'
+const hooks = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (specifier === './memu.js') return { url: 'data:text/javascript,' + encodeURIComponent(memuSource), shortCircuit: true }
+    return nextResolve(specifier, context)
+  },
+})
+
+const curator = await import('../lib/curator.js')
+const memory = await import('../lib/memory.js')
+const rpc = await import('../lib/rpc.js')
+const state = await import('../lib/state.js')
+const vm = await import('../lib/vector-migration.js')
+const vp = await import('../lib/vector-profile.js')
+const catalog = await import('../lib/embedding-catalog.js')
+
+const BGE = 'bge-small-zh-v1.5-int8'
+const baseEntry = catalog.getEmbeddingModel(BGE)
+const altEntry = JSON.parse(JSON.stringify(baseEntry))
+altEntry.id = 'bge-small-zh-v1.5-int8-alt'
+altEntry.displayName = 'BGE alternative revision (absorb review fixture)'
+altEntry.sources.modelscope.revision = 'c'.repeat(40)
+altEntry.profileFingerprint = catalog.profileFingerprint(altEntry)
+const models = { [BGE]: baseEntry, [altEntry.id]: altEntry }
+vp.setCatalogEntryResolver((id) => models[id] ?? null)
+
+state.updateSettings({ memoryBackend: 'api', vectorSource: 'local' })
+
+test.after(async () => {
+  try { hooks.unregister?.() } catch {}
+  vp.resetCatalogEntryResolver()
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function seedGlobalIndex(entries = {}) {
+  state.saveGlobalIndex({ version: 1, entries: structuredClone(entries) })
+}
+
+async function activateVectorGeneration() {
+  const dbs = new Map()
+  const rowsOf = (db) => {
+    if (!dbs.has(db)) dbs.set(db, new Map())
+    return dbs.get(db)
+  }
+  const migrator = vm.createVectorMigrator({
+    async listLibraries() { return [] },
+    loadIndex(libraryId) {
+      return libraryId ? state.loadPrivateIndex(libraryId) : state.loadGlobalIndex()
+    },
+    async commit({ db, item }) { rowsOf(db).set(item.id, item.text) },
+    async forget({ db, itemId }) { rowsOf(db).delete(itemId) },
+    async listFiles({ db }) { return [...rowsOf(db).keys()] },
+    async smoke() { return { ok: true, checks: ['dimension=512'] } },
+  })
+  const switched = await migrator.switchProfile({ profile: BGE })
+  assert.ok(['switched', 'already-active'].includes(switched.status), 'an active generation must be available')
+  return { migrator, generation: switched.generation }
+}
+
+const CORE = '每周四凌晨两点到四点是固定的部署窗口，窗口内只允许灰度发布。'
+const AT = '2026-01-01T00:00:00.000Z'
+const A = 'gmem-review-a'
+const B = 'gmem-review-b'
+const C = 'gmem-review-c'
+const D = 'gmem-review-d'
+const E = 'gmem-review-e'
+
+function baseEntryOf(id, title, content, extra = {}) {
+  return {
+    track: 'memory', domain: 'general', title, content,
+    confidence: 0.9, status: 'active',
+    createdAt: AT, updatedAt: AT,
+    evidence: [{ sessionId: 's0', quote: '部署窗口只在周四' }],
+    ...extra,
+  }
+}
+
+function absorbEvidence(ids) {
+  return ids.map((id, index) => ({ session_id: `s-rev-${index}`, quote: `来源 ${id} 的落地引用内容`, source_id: id }))
+}
+
+function seedCluster({ withLinks = false } = {}) {
+  const entries = {
+    [A]: baseEntryOf(A, '部署窗口约定', CORE + '全量发布必须在监控确认通过之后才能执行。'),
+    [B]: baseEntryOf(B, '部署窗口细节', CORE + '灰度发布按服务分组逐步放量，异常时立即回滚。'),
+    [C]: baseEntryOf(C, '部署窗口约束', CORE + '窗口外禁止任何生产变更。'),
+  }
+  if (withLinks) {
+    entries[D] = baseEntryOf(D, '簇外条目', '另一个话题的内容，与吸收无关。', {
+      links: [{ id: 'lnk-in-9', opId: 'op9', to: A, kind: 'related', note: '这条入边在吸收后要改指合并稿。', confidence: 0.7, evidence: [], createdAt: AT }],
+    })
+    entries[A].links = [{ id: 'lnk-out-9', opId: 'op8', to: E, kind: 'refines', note: 'target 指向簇外的边要并入合并稿。', confidence: 0.7, evidence: [], createdAt: AT }]
+    entries[E] = baseEntryOf(E, '簇外条目2', '被 target 指向的条目。')
+  }
+  seedGlobalIndex(entries)
+}
+
+// review-all 让 absorb 计划一律落 pendingAbsorb 提案（spec §4.10 表格第三列）。
+state.updateSettings({ curatorReviewMode: 'review-all' })
+
+const ABSORB_PLAN = {
+  memories: [{
+    op: 'absorb', target_id: A, source_ids: [B, C],
+    confidence: 0.9,
+    evidence: absorbEvidence([A, B, C]),
+  }],
+}
+
+async function pendingProposalOf() {
+  const queue = await rpc.dispatch({}, 'listReviews', {})
+  const item = queue.items.find((row) => row.pendingAbsorb)
+  assert.ok(item, 'the absorb proposal must be in the review queue')
+  return item
+}
+
+test('listReviews exposes reviewRisk, reviewRiskReasons and pendingAbsorb for the queue UI', async () => {
+  seedCluster()
+  await activateVectorGeneration()
+  const result = await curator.commitCuratorPlans(structuredClone(ABSORB_PLAN), { job: { step: '' } })
+  assert.equal(result.pending, 1)
+  const item = await pendingProposalOf()
+  assert.equal(item.pendingAbsorb.targetId, A)
+  assert.deepEqual([...item.pendingAbsorb.sourceIds].sort(), [B, C].sort())
+  assert.ok(item.pendingAbsorb.opId)
+  assert.equal(item.pendingAbsorb.expectedUpdatedAt[A], AT)
+  assert.equal(typeof item.reviewRisk, 'number', 'reviewRisk rides along on every queue row')
+  assert.ok(Array.isArray(item.reviewRiskReasons))
+})
+
+test('accept turns the proposal active, archives the sources, commits only the proposal id to vectors and rewires links', async () => {
+  seedCluster({ withLinks: true })
+  await activateVectorGeneration()
+  await curator.commitCuratorPlans(structuredClone(ABSORB_PLAN), { job: { step: '' } })
+  const item = await pendingProposalOf()
+  const proposalId = item.id
+
+  const resolved = await rpc.dispatch({}, 'resolveReview', { id: proposalId, action: 'accept' })
+  assert.equal(resolved.status, 'active')
+
+  const index = state.loadGlobalIndex()
+  const merged = index.entries[proposalId]
+  assert.equal(merged.status, 'active')
+  // §3.3/§4.11：accept 写 absorbedFrom/absorbedAt/absorbOpId/representativeId，
+  // 并清 pendingAbsorb/reviewReason/conflictingWith。
+  assert.deepEqual(merged.absorbedFrom, [A, B, C].sort())
+  assert.ok(merged.absorbOpId)
+  assert.ok(merged.representativeId)
+  assert.ok(merged.absorbAt || merged.updatedAt)
+  assert.equal(merged.auditTrail?.at(-1)?.op, 'absorb')
+  assert.equal(index.entries[A].auditTrail?.at(-1)?.op, 'absorb')
+  assert.equal(index.entries[B].auditTrail?.at(-1)?.op, 'absorb')
+  assert.equal(merged.pendingAbsorb, undefined)
+  assert.equal(merged.reviewReason, undefined)
+  assert.equal(merged.conflictingWith, undefined)
+  assert.ok(merged.absorbSnapshot, 'the accept transaction writes the undo snapshot')
+  assert.ok(merged.vector, 'the accepted entry carries the vector stamp')
+
+  // 向量库只收到提案 id 这一行；sources 一行都没有。
+  const lastCommit = backend.commits.at(-1)
+  assert.deepEqual(lastCommit.names, [proposalId])
+
+  // target superseded；sources archived。
+  assert.equal(index.entries[A].status, 'superseded')
+  assert.equal(index.entries[A].absorbedInto, proposalId)
+  assert.equal(index.entries[B].status, 'archived')
+  assert.equal(index.entries[B].absorbedBy, proposalId)
+  assert.equal(index.entries[C].status, 'archived')
+  // links：入边改指 merged，出边并入 merged。
+  assert.equal(index.entries[D].links[0].to, proposalId)
+  assert.equal(merged.links[0].to, E)
+  // 快照保留吸收前状态。
+  assert.deepEqual(merged.absorbSnapshot.rewired.map((row) => row.id), [D])
+})
+
+test('reject archives the proposal and leaves target/sources untouched', async () => {
+  seedCluster()
+  await activateVectorGeneration()
+  await curator.commitCuratorPlans(structuredClone(ABSORB_PLAN), { job: { step: '' } })
+  const item = await pendingProposalOf()
+  await rpc.dispatch({}, 'resolveReview', { id: item.id, action: 'reject' })
+  const index = state.loadGlobalIndex()
+  assert.equal(index.entries[item.id].status, 'archived')
+  assert.equal(index.entries[A].status, 'active', 'the target stays active on reject')
+  assert.equal(index.entries[B].status, 'active')
+  assert.equal(index.entries[C].status, 'active')
+})
+
+test('accept with a coexist resolution is refused: a merged entry cannot coexist with its own sources', async () => {
+  seedCluster()
+  await activateVectorGeneration()
+  await curator.commitCuratorPlans(structuredClone(ABSORB_PLAN), { job: { step: '' } })
+  const item = await pendingProposalOf()
+  await assert.rejects(
+    () => rpc.dispatch({}, 'resolveReview', { id: item.id, action: 'accept', resolution: 'coexist', reason: '条件不同的并存说明文字' }),
+    /replace/,
+  )
+  assert.equal(state.loadGlobalIndex().entries[item.id].status, 'pending_review', 'the proposal stays pending')
+})
+
+test('accept with a concurrently changed source throws "review changed" and keeps the proposal pending', async () => {
+  seedCluster()
+  await activateVectorGeneration()
+  await curator.commitCuratorPlans(structuredClone(ABSORB_PLAN), { job: { step: '' } })
+  const item = await pendingProposalOf()
+  // 并发写：source 的 updatedAt 变了，快照校验必须拦下这次接受。
+  state.updateGlobalIndex((fresh) => {
+    fresh.entries[B] = { ...fresh.entries[B], content: '来源被并发修改。', updatedAt: '2026-03-03T00:00:00.000Z' }
+  })
+  await assert.rejects(
+    () => rpc.dispatch({}, 'resolveReview', { id: item.id, action: 'accept' }),
+    /review changed; reload and retry/,
+  )
+  const index = state.loadGlobalIndex()
+  assert.equal(index.entries[item.id].status, 'pending_review', 'the proposal stays pending')
+  assert.equal(index.entries[A].status, 'active', 'the target is not superseded by a failed accept')
+  assert.equal(index.entries[B].status, 'active')
+})
+
+test('undo-absorb restores target, sources and rewired links, archives the merged entry, and refuses a second undo', async () => {
+  seedCluster({ withLinks: true })
+  await activateVectorGeneration()
+  await curator.commitCuratorPlans(structuredClone(ABSORB_PLAN), { job: { step: '' } })
+  const item = await pendingProposalOf()
+  await rpc.dispatch({}, 'resolveReview', { id: item.id, action: 'accept' })
+  const mergedId = item.id
+
+  const undone = await rpc.dispatch({}, 'resolveReview', { id: mergedId, action: 'undo-absorb' })
+  assert.equal(undone.status, 'archived')
+
+  const index = state.loadGlobalIndex()
+  const merged = index.entries[mergedId]
+  assert.equal(merged.status, 'archived', 'the merged entry is archived, not deleted')
+  assert.ok(merged.absorbUndoneAt)
+  assert.ok(merged.content, 'the merged body is kept')
+  assert.equal(merged.auditTrail.at(-1).op, 'undo-absorb')
+  assert.equal(index.entries[A].auditTrail.at(-1).op, 'undo-absorb')
+  assert.equal(index.entries[B].auditTrail.at(-1).op, 'undo-absorb')
+  // target 恢复。
+  const target = index.entries[A]
+  assert.equal(target.status, 'active')
+  assert.equal(target.supersededBy, undefined)
+  assert.equal(target.absorbedInto, undefined)
+  assert.equal(target.validTo, undefined)
+  // sources 恢复。
+  for (const id of [B, C]) {
+    const source = index.entries[id]
+    assert.equal(source.status, 'active')
+    assert.equal(source.absorbedBy, undefined)
+    assert.equal(source.absorbedAt, undefined)
+    assert.equal(source.validTo, undefined)
+  }
+  // rewired 边恢复原状。
+  assert.equal(index.entries[D].links[0].to, A)
+
+  // 二次撤销：merged 已不是 active，直接报错。
+  await assert.rejects(
+    () => rpc.dispatch({}, 'resolveReview', { id: mergedId, action: 'undo-absorb' }),
+    /active merged entry with an absorb snapshot/,
+  )
+})
+
+test('undo-absorb refuses a libraryId payload, an entry without a snapshot, and members edited after absorption', async () => {
+  seedCluster({ withLinks: true })
+  await activateVectorGeneration()
+  await curator.commitCuratorPlans(structuredClone(ABSORB_PLAN), { job: { step: '' } })
+  const item = await pendingProposalOf()
+  await rpc.dispatch({}, 'resolveReview', { id: item.id, action: 'accept' })
+  const mergedId = item.id
+
+  // 带 libraryId 的 undo 是私有复核语义错位，必须报错（spec §6.7 RPC）。
+  await assert.rejects(
+    () => rpc.dispatch({}, 'resolveReview', { id: mergedId, action: 'undo-absorb', libraryId: 'some-lib' }),
+    /libraryId/,
+  )
+  // 没有 absorbSnapshot 的条目不能 undo。
+  await assert.rejects(
+    () => rpc.dispatch({}, 'resolveReview', { id: A, action: 'undo-absorb' }),
+    /absorb snapshot/,
+  )
+
+  // 吸收后 target 又被人工改过（updatedAt > absorbedAt）→ 拒绝整体撤销。
+  // （absorbedAt 是真实的当前时间，人工改动的时间必须落在它之后。）
+  state.updateGlobalIndex((fresh) => {
+    fresh.entries[A] = { ...fresh.entries[A], content: '人工修正后的部署窗口约定。', updatedAt: '2030-01-01T00:00:00.000Z' }
+  })
+  await assert.rejects(
+    () => rpc.dispatch({}, 'resolveReview', { id: mergedId, action: 'undo-absorb' }),
+    /absorb undo refused/,
+  )
+  const index = state.loadGlobalIndex()
+  assert.equal(index.entries[mergedId].status, 'active', 'the refused undo leaves the merge in place')
+})
+
+test('the review wrapper still records the review in the activity log', async () => {
+  seedCluster()
+  await activateVectorGeneration()
+  await curator.commitCuratorPlans(structuredClone(ABSORB_PLAN), { job: { step: '' } })
+  const item = await pendingProposalOf()
+  await rpc.dispatch({}, 'resolveReview', { id: item.id, action: 'reject' })
+  const event = [...await import('../lib/activity-log.js').then((m) => m.listEvents({ kind: 'write' }))]
+    .find((row) => row.detail?.id === item.id && row.message.includes('复核'))
+  assert.ok(event, 'the resolveReview wrapper logs the decision')
+})