dsh-memu-memory 1.2.1 → 1.2.2

package/tests/curator-link.test.mjs

@@ -0,0 +1,316 @@
+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'
+
+// Global links (spec §3.2/§4.9/§6.6): symmetric/directed writes, opId
+// idempotency, caps, evidence grounding, cross-domain rules, review-mode
+// behaviour, and removal. Unit level through lib/global-graph.js, integration
+// level through commitCuratorOutput's link branch — same hermetic rig as
+// tests/curator-commit.test.mjs.
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-curator-link-'))
+process.env.DSH_MEMU_HOME = home
+process.env.DSH_MEMU_MEMORY_HOME = home
+
+globalThis.__curatorLinkTest = {
+  async commit() { return { ok: true } },
+  async forget() { 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.__curatorLinkTest;'
+  + '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 state = await import('../lib/state.js')
+const graph = await import('../lib/global-graph.js')
+const evidence = await import('../lib/curator-evidence.js')
+const activity = await import('../lib/activity-log.js')
+
+test.after(async () => {
+  try { hooks.unregister?.() } catch {}
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+const sessionCorpus = evidence.buildEvidenceCorpus([
+  { id: 's1', transcript: 'User: 部署窗口只在周四凌晨两点到四点开放，其余时间不发版。' },
+])
+
+const A = () => ({
+  track: 'memory', domain: 'general', status: 'active', title: '部署窗口约定',
+  content: '每周四凌晨两点到四点是固定的部署窗口，窗口内只允许灰度发布。',
+  createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-01-01T00:00:00.000Z',
+})
+const B = (over = {}) => ({
+  track: 'memory', domain: 'general', status: 'active', title: '灰度发布规则',
+  content: '窗口内的发布全部走灰度，全量要等监控确认。',
+  createdAt: '2026-01-02T00:00:00.000Z', updatedAt: '2026-01-02T00:00:00.000Z', ...over,
+})
+
+function seed(entries) {
+  state.saveGlobalIndex({ version: 1, entries: structuredClone(entries) })
+}
+
+const linkOp = (over = {}) => ({
+  op: 'link', from_id: 'gmem-a', to_id: 'gmem-b', kind: 'related',
+  note: '两条记忆同讲部署窗口：部署窗口只在周四凌晨两点到四点开放',
+  confidence: 0.8,
+  evidence: [{ session_id: 's1', quote: '部署窗口只在周四凌晨两点到四点开放' }],
+  ...over,
+})
+
+const validateArgs = (over = {}) => ({
+  index: state.loadGlobalIndex(),
+  fromId: 'gmem-a', toId: 'gmem-b', kind: 'related',
+  note: '两条记忆同讲部署窗口：部署窗口只在周四凌晨两点到四点开放',
+  confidence: 0.8,
+  evidence: [{ session_id: 's1', quote: '部署窗口只在周四凌晨两点到四点开放' }],
+  sessionCorpus,
+  ...over,
+})
+
+// —— validateGlobalLink ——
+
+test('validateGlobalLink: related is symmetric — both ends carry the same id and opId', () => {
+  seed({ 'gmem-a': A(), 'gmem-b': B() })
+  const verdict = graph.validateGlobalLink(validateArgs())
+  assert.equal(verdict.ok, true, verdict.reason || '')
+  const writes = [verdict]
+  const { applied } = graph.applyGlobalLinks(JSON.parse(JSON.stringify(state.loadGlobalIndex().entries)), writes)
+  assert.equal(applied.length, 1)
+  seed({
+    'gmem-a': { ...A(), links: [{ ...verdict.link, to: 'gmem-b' }] },
+    'gmem-b': { ...B(), links: [{ ...verdict.link, to: 'gmem-a' }] },
+  })
+  const a = state.loadGlobalIndex().entries['gmem-a']
+  const b = state.loadGlobalIndex().entries['gmem-b']
+  assert.equal(a.links[0].id, b.links[0].id)
+  assert.equal(a.links[0].opId, b.links[0].opId)
+  assert.equal(a.links[0].to, 'gmem-b')
+  assert.equal(b.links[0].to, 'gmem-a')
+  assert.match(a.links[0].id, /^lnk_[0-9a-f]{16}$/)
+})
+
+test('validateGlobalLink: a contradictory pair is rejected instead of becoming a link', () => {
+  const sameTitle = A().title
+  seed({
+    'gmem-a': A(),
+    'gmem-b': B({ title: sameTitle, content: '部署窗口在周五，窗口内禁止任何灰度发布。' }),
+  })
+  const verdict = graph.validateGlobalLink(validateArgs())
+  assert.equal(verdict.ok, false)
+  assert.match(verdict.reason, /conflict pair detected/)
+})
+
+test('link writes an audit trail on both ends; unlink appends a removal event', () => {
+  seed({ 'gmem-a': A(), 'gmem-b': B() })
+  const verdict = graph.validateGlobalLink(validateArgs())
+  assert.equal(verdict.ok, true, verdict.reason || '')
+  const entries = JSON.parse(JSON.stringify(state.loadGlobalIndex().entries))
+  graph.applyGlobalLinks(entries, [verdict])
+  assert.equal(entries['gmem-a'].auditTrail?.at(-1)?.op, 'link')
+  assert.equal(entries['gmem-b'].auditTrail?.at(-1)?.op, 'link')
+  assert.equal(entries['gmem-a'].auditTrail.at(-1).linkId, verdict.link.id)
+  state.saveGlobalIndex({ version: 1, entries })
+  const removed = graph.removeGlobalLink({ linkId: verdict.link.id })
+  assert.equal(removed.removed, 2)
+  const index = state.loadGlobalIndex()
+  assert.equal(index.entries['gmem-a'].auditTrail.at(-1).op, 'unlink')
+  assert.equal(index.entries['gmem-b'].auditTrail.at(-1).op, 'unlink')
+})
+
+test('validateGlobalLink: refines/supports are directed — only the source end stores the edge', () => {
+  seed({ 'gmem-a': A(), 'gmem-b': B() })
+  const verdict = graph.validateGlobalLink(validateArgs({ kind: 'supports' }))
+  assert.equal(verdict.ok, true, verdict.reason || '')
+  assert.equal(verdict.symmetric, false)
+  const entries = { 'gmem-a': A(), 'gmem-b': B() }
+  const { applied } = graph.applyGlobalLinks(entries, [verdict])
+  assert.equal(applied.length, 1)
+  assert.equal(entries['gmem-a'].links.length, 1)
+  assert.equal(entries['gmem-b'].links, undefined, 'the target end gains nothing for a directed edge')
+  // opId uses the ordered pair, so swapping ends changes it
+  const swapped = graph.validateGlobalLink(validateArgs({ kind: 'supports', fromId: 'gmem-b', toId: 'gmem-a' }))
+  assert.notEqual(swapped.link.opId, verdict.link.opId)
+})
+
+test('validateGlobalLink: rejections — endpoints, self, kinds, note bounds, confidence, evidence', () => {
+  seed({ 'gmem-a': A(), 'gmem-b': B(), 'gmem-dead': B({ status: 'archived' }) })
+  const cases = [
+    [{ ...validateArgs(), fromId: 'gmem-missing' }, /endpoint not found/],
+    [{ ...validateArgs(), toId: 'gmem-dead' }, /endpoint not active/],
+    [{ ...validateArgs(), fromId: 'gmem-a', toId: 'gmem-a' }, /self link/],
+    [{ ...validateArgs(), kind: 'contradicts' }, /unknown kind/],
+    [{ ...validateArgs(), note: '短' }, /note length 1 outside 8-500/],
+    [{ ...validateArgs(), note: 'x'.repeat(501) }, /note length 501 outside 8-500/],
+    [{ ...validateArgs(), confidence: 0.4 }, /confidence 0.4 outside 0.5-1/],
+    [{ ...validateArgs(), evidence: [] }, /evidence must be 1-3/],
+    [{ ...validateArgs(), evidence: [{ session_id: 's1', quote: 'nope' }, { session_id: 's1', quote: '部署窗口只在周四凌晨两点到四点开放' }, { session_id: 's1', quote: '部署窗口只在周四凌晨两点到四点开放' }, { session_id: 's1', quote: '部署窗口只在周四凌晨两点到四点开放' }] }, /evidence must be 1-3/],
+    [{ ...validateArgs(), evidence: [{ session_id: 's9', quote: '部署窗口只在周四凌晨两点到四点开放' }] }, /evidence not grounded/],
+    [{ ...validateArgs(), note: '这句注记没有引用任何原话内容' }, /note must quote at least one grounded evidence verbatim/],
+  ]
+  for (const [args, expected] of cases) {
+    const verdict = graph.validateGlobalLink(args)
+    assert.equal(verdict.ok, false, `${JSON.stringify(args.note || args.kind)} should be rejected`)
+    assert.match(verdict.reason, expected)
+  }
+})
+
+test('validateGlobalLink: cross-domain links must be related; rp and coding never link', () => {
+  seed({
+    'gmem-a': A(),
+    'gmem-b': B({ domain: 'coding' }),
+    'gmem-rp': B({ domain: 'rp' }),
+  })
+  const refines = graph.validateGlobalLink(validateArgs({ kind: 'refines', toId: 'gmem-b' }))
+  assert.equal(refines.ok, false)
+  assert.match(refines.reason, /cross-domain links must be related/)
+  const clash = graph.validateGlobalLink(validateArgs({ toId: 'gmem-rp' }))
+  assert.equal(clash.ok, true, 'general↔rp cross-domain related is allowed')
+  const rpCoding = graph.validateGlobalLink(validateArgs({ fromId: 'gmem-b', toId: 'gmem-rp' }))
+  assert.equal(rpCoding.ok, false)
+  assert.match(rpCoding.reason, /rp and coding never link/)
+})
+
+test('applyGlobalLinks: (to,kind) idempotent; cap 20 per end; one full end blocks a symmetric pair', () => {
+  const third = B({ title: '第三条', content: '另一条不相关的记忆内容，用来测上限。' })
+  seed({ 'gmem-a': A(), 'gmem-b': B(), 'gmem-c': third })
+  const first = graph.validateGlobalLink(validateArgs())
+  const entries = { 'gmem-a': A(), 'gmem-b': B(), 'gmem-c': structuredClone(third) }
+  graph.applyGlobalLinks(entries, [first])
+  // same (to, kind) again → skipped
+  const again = graph.applyGlobalLinks(entries, [first])
+  assert.equal(again.applied.length, 0)
+  assert.match(again.skipped[0].reason, /duplicate link/)
+  // fill gmem-a to 20 links → the next link out of gmem-a hits the cap
+  entries['gmem-a'].links.push(...Array.from({ length: 19 }, (_, i) => ({ id: `lnk_pad_${i}`, to: `pad-${i}`, kind: 'related' })))
+  assert.equal(entries['gmem-a'].links.length, 20)
+  const capped = graph.validateGlobalLink(validateArgs({ index: { entries }, toId: 'gmem-c' }))
+  assert.equal(capped.ok, false)
+  assert.match(capped.reason, /link cap reached on gmem-a/)
+  // a forced write against the full end blocks BOTH ends of a symmetric pair
+  const forced = { fromId: 'gmem-a', toId: 'gmem-b', kind: 'related', symmetric: true, link: first.link }
+  const blocked = graph.applyGlobalLinks(entries, [forced])
+  assert.equal(blocked.applied.length, 0)
+  assert.equal(entries['gmem-b'].links.length, 1, 'the non-full end gains nothing when the other end is full')
+})
+
+test('applyGlobalLinks: directed edges reject cycles within depth 3', () => {
+  const entries = {
+    'n1': { ...A(), links: [{ id: 'lnk_1', to: 'n2', kind: 'refines' }] },
+    'n2': { ...B(), links: [{ id: 'lnk_2', to: 'n3', kind: 'refines' }] },
+    'n3': { ...B({ title: 'C' }), links: [] },
+  }
+  // n3 → n1 would close n1→n2→n3→n1
+  const cyclic = { fromId: 'n3', toId: 'n1', kind: 'refines', symmetric: false, link: { id: 'lnk_x', opId: 'x', to: 'n1', kind: 'refines', note: 'x', confidence: 0.8, evidence: [], createdAt: 'now' } }
+  const { applied, skipped } = graph.applyGlobalLinks(entries, [cyclic])
+  assert.equal(applied.length, 0)
+  assert.match(skipped[0].reason, /directed cycle/)
+  // depth 4 is out of the check's reach by design (§4.9: depth ≤3)
+  const deep = {
+    'd1': { ...A(), links: [{ id: 'l1', to: 'd2', kind: 'refines' }] },
+    'd2': { ...B(), links: [{ id: 'l2', to: 'd3', kind: 'refines' }] },
+    'd3': { ...B(), links: [{ id: 'l3', to: 'd4', kind: 'refines' }] },
+    'd4': { ...B(), links: [] },
+  }
+  assert.equal(graph.directedReaches(deep, 'd4', 'd1', 3), false, 'a depth-4 path is beyond the cycle check')
+})
+
+test('removeGlobalLink: deletes both ends of a symmetric edge and only metadata', () => {
+  seed({
+    'gmem-a': { ...A(), links: [{ id: 'lnk_sym', opId: 'op1', to: 'gmem-b', kind: 'related' }, { id: 'lnk_keep', to: 'gmem-c', kind: 'related' }] },
+    'gmem-b': { ...B(), links: [{ id: 'lnk_sym', opId: 'op1', to: 'gmem-a', kind: 'related' }] },
+  })
+  const result = graph.removeGlobalLink({ linkId: 'lnk_sym' })
+  assert.equal(result.removed, 2)
+  assert.deepEqual(result.entries.sort(), ['gmem-a', 'gmem-b'])
+  const index = state.loadGlobalIndex()
+  assert.deepEqual(index.entries['gmem-a'].links, [{ id: 'lnk_keep', to: 'gmem-c', kind: 'related' }])
+  assert.equal(index.entries['gmem-b'].links.length, 0)
+  assert.equal(index.entries['gmem-a'].status, 'active', 'removal never touches entry status')
+  const miss = graph.removeGlobalLink({ linkId: 'lnk_absent' })
+  assert.equal(miss.removed, 0)
+})
+
+// —— commitCuratorOutput link branch ——
+
+test('commitCuratorOutput: a grounded link lands in both modes and never enters files', async () => {
+  seed({ 'gmem-a': A(), 'gmem-b': B() })
+  state.updateSettings({ curatorReviewMode: 'review-all' })
+  const result = await curator.commitCuratorOutput({ memories: [linkOp()] }, { job: { step: 'committing' }, sessionCorpus })
+  assert.equal(result.linked, 1)
+  assert.equal(result.files.length, 0, 'links never enter the vector commit')
+  assert.equal(result.pending, 0, 'review-all does not hold links (C2)')
+  const index = state.loadGlobalIndex()
+  assert.equal(index.entries['gmem-a'].links[0].to, 'gmem-b')
+  const event = activity.listEvents({ kind: 'curate' }).find((item) => item.detail?.op === 'link')
+  assert.ok(event, 'each applied link gets its own activity record')
+  assert.equal(event.detail.kind, 'related')
+  assert.equal(event.detail.from, 'gmem-a')
+  assert.match(event.detail.linkId, /^lnk_/)
+  state.updateSettings({ curatorReviewMode: 'auto' })
+})
+
+test('commitCuratorOutput: ungrounded evidence means no edge and a skipped entry (C10)', async () => {
+  seed({ 'gmem-a': A(), 'gmem-b': B() })
+  // grounded corpus present but the quote is fabricated
+  const bad = await curator.commitCuratorOutput({
+    memories: [linkOp({ evidence: [{ session_id: 's1', quote: '凭空编造的引用根本不在会话里' }] })],
+  }, { job: { step: 'committing' }, sessionCorpus })
+  assert.equal(bad.linked, 0)
+  assert.equal(bad.skipped.length, 1)
+  assert.match(bad.skipped[0].reason, /link rejected/)
+  // no corpus at all (direct call): shape-valid evidence stays unverified and lands
+  const direct = await curator.commitCuratorOutput({ memories: [linkOp()] }, { job: { step: 'committing' } })
+  assert.equal(direct.linked, 1)
+  // empty evidence is always rejected
+  const empty = await curator.commitCuratorOutput({ memories: [linkOp({ evidence: [] })] }, { job: { step: 'committing' } })
+  assert.equal(empty.linked, 0)
+  assert.match(empty.skipped[0].reason, /evidence must be 1-3/)
+})
+
+test('commitCuratorOutput: duplicate (to,kind) is idempotent and links ride the same transaction as content', async () => {
+  seed({ 'gmem-a': A(), 'gmem-b': B(), 'gmem-c': B({ title: '第三条', content: '另一条不相关的记忆内容，用来测上限。' }) })
+  const firstOutput = { memories: [structuredClone(linkOp())] }
+  const result = await curator.commitCuratorOutput(firstOutput, { job: { step: 'committing' }, sessionCorpus })
+  assert.equal(result.linked, 1)
+  const again = await curator.commitCuratorOutput(firstOutput, { job: { step: 'committing' }, sessionCorpus })
+  assert.equal(again.linked, 0, 'the second run is fully idempotent')
+  assert.equal(again.skipped.length, 1)
+  // links + a create share one commit (same updateGlobalIndex transaction)
+  const mixed = await curator.commitCuratorOutput({
+    memories: [
+      linkOp({ from_id: 'gmem-b', to_id: 'gmem-c' }),
+      {
+        op: 'create', domain: 'general', track: 'memory', title: '全新独立事实',
+        content: '用户倾向在代码评审里先看测试再看过渡逻辑。',
+        confidence: 0.9,
+        evidence: [{ session_id: 's1', quote: '部署窗口只在周四凌晨两点到四点开放' }],
+      },
+    ],
+  }, { job: { step: 'committing' }, sessionCorpus })
+  assert.equal(mixed.linked, 1)
+  assert.equal(mixed.created, 1)
+})
+
+test('commitCuratorOutput: absorb ops now flow into commitCuratorPlans (wired; missing target skips)', async () => {
+  // F2 接线后：absorb 不再走 relay skip，而是由 commitCuratorPlans 直接提交。
+  // 空索引里 target 不存在 → 提交层按校验顺序跳过（不是 create，也不是 relay）。
+  seed({})
+  const result = await curator.commitCuratorOutput({
+    memories: [{ op: 'absorb', target_id: 'gmem-a', source_ids: ['gmem-b'], title: 'x', content: 'y', confidence: 0.9, evidence: [{ session_id: 's1', quote: 'zzzzzz' }] }],
+  }, { job: { step: 'committing' } })
+  assert.equal(result.created, 0, 'absorb never falls through to create')
+  assert.equal(Object.keys(state.loadGlobalIndex().entries).length, 0, 'nothing lands without a real target')
+  assert.ok(result.skipped.length >= 1, 'the dead-end absorb is reported in skipped')
+  assert.ok(!result.skipped.some((item) => /absorb lands in a later pass/.test(item.reason)), 'the relay reason is gone: absorb is wired')
+})

package/tests/curator-pairing.test.mjs

@@ -0,0 +1,252 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  bm25,
+  buildCorpus,
+  globalConflictCheck,
+  negationPolarity,
+  numericSetsDiffer,
+  pairDecision,
+  pairFeatures,
+  pairScore,
+  rankPairCandidates,
+  tokenize,
+} from '../lib/text-retrieval.js'
+import { similarityDetail, similarTexts, bigrams, dice } from '../lib/text-similarity.js'
+
+// —— §4.1 tokenize ——
+
+test('tokenize: latin runs of >=2 chars keep ._ - joins, single chars drop', () => {
+  assert.deepEqual(tokenize('use dsh-memu-memory_v2.today ok'), ['use', 'dsh-memu-memory_v2.today', 'ok'])
+  assert.deepEqual(tokenize('a b cd'), ['cd'])
+  assert.deepEqual(tokenize('per-turn retry'), ['per-turn', 'retry'])
+})
+
+test('tokenize: CJK runs become overlapping bigrams, isolated chars stay single', () => {
+  assert.deepEqual(tokenize('部署窗口'), ['部署', '署窗', '窗口'])
+  assert.deepEqual(tokenize('猫'), ['猫'])
+  // two CJK runs separated by latin/punct stay separate runs
+  assert.deepEqual(tokenize('猫。狗'), ['猫', '狗'])
+})
+
+test('tokenize: NFKC folds full-width forms, lowercases, dedupes', () => {
+  assert.deepEqual(tokenize('ＲＩＳＣＶ ＣＡＣＨＥ CACHE'), ['riscv', 'cache'])
+  assert.deepEqual(tokenize('缓存 缓存'), ['缓存'])
+})
+
+// —— §4.1 buildCorpus + bm25 ——
+
+function corpusFor() {
+  return buildCorpus([
+    { id: 'a', title: '部署窗口', content: '每周四凌晨部署窗口只做灰度', track: 'memory', domain: 'general' },
+    { id: 'b', title: '缓存策略', content: 'Redis 缓存统一 30 秒过期', track: 'memory', domain: 'coding' },
+    { id: 'c', title: '站会安排', content: '每周一上午十点开站会', track: 'memory', domain: 'general' },
+  ])
+}
+
+test('buildCorpus: tf/df/avgdl account for every doc and term', () => {
+  const corpus = corpusFor()
+  assert.equal(corpus.size, 3)
+  assert.equal(corpus.df.get('缓存'), 1)
+  assert.equal(corpus.df.get('每周'), 2)
+  const doc = corpus.docs.get('a')
+  assert.equal(doc.tf.get('部署'), 2)
+  assert.equal(doc.len, [...doc.tf.values()].reduce((sum, n) => sum + n, 0))
+  assert.ok(corpus.avgdl > 0)
+})
+
+test('bm25: docs containing query terms outscore non-matching docs', () => {
+  const corpus = corpusFor()
+  const query = tokenize('缓存 过期')
+  const scores = ['a', 'b', 'c'].map((id) => bm25(query, corpus.docs.get(id), corpus))
+  assert.ok(scores[1] > scores[0] && scores[1] > scores[2])
+  assert.equal(scores[2], 0)
+})
+
+test('bm25: queries wider than 64 terms keep the matching terms (junk never evicts them)', () => {
+  const corpus = corpusFor()
+  const junk = [...Array(80).keys()].map((i) => `raretoken${i}`)
+  const query = [...junk, '缓存']
+  // Absent terms carry the highest nominal IDF but zero scoring mass; the top-64
+  // quota must not spend itself on them and drop the one term that can score.
+  const hits = query.filter((t) => (corpus.df.get(t) || 0) > 0)
+  assert.equal(bm25(query, corpus.docs.get('b'), corpus), bm25(hits, corpus.docs.get('b'), corpus))
+  assert.ok(bm25(hits, corpus.docs.get('b'), corpus) > 0)
+})
+// —— §4.2 similarityDetail / pairFeatures / pairScore ——
+
+test('similarityDetail: length-comparable pairs report dice, pruned pairs report the containment floor', () => {
+  const near = similarityDetail('每周四凌晨部署窗口只做灰度', '每周四凌晨部署窗口只做灰度发布')
+  assert.equal(near.containment, 0)
+  assert.ok(near.dice > 0.9)
+  const contained = similarityDetail('Redis 缓存统一设置 30 秒过期。', 'Redis 缓存统一设置 30 秒过期。过期之后直接回源查询并把回源结果写回缓存，缓存击穿时用互斥锁保护。')
+  assert.equal(contained.dice, 0)
+  assert.equal(contained.containment, 0.92)
+  // similarTexts stays the max of the two — the pre-existing ruler, unchanged
+  assert.equal(similarTexts('每周四凌晨部署窗口只做灰度', '每周四凌晨部署窗口只做灰度发布'), near.dice)
+  assert.equal(similarTexts('Redis 缓存统一设置 30 秒过期。', 'Redis 缓存统一设置 30 秒过期。过期之后直接回源查询并把回源结果写回缓存，缓存击穿时用互斥锁保护。'), 0.92)
+  assert.ok(dice(bigrams('缓存策略'), bigrams('缓存策略')) > 0.99)
+})
+
+test('pairFeatures: entityJaccard is 0.5 neutral when both sides are empty, 1 when identical', () => {
+  const bothEmpty = pairFeatures({ title: 'A', content: '缓存策略内容' }, { title: 'A', content: '缓存策略内容' })
+  assert.equal(bothEmpty.entityJaccard, 0.5)
+  assert.equal(bothEmpty.titleExact, true)
+  const same = pairFeatures(
+    { title: 'A', content: '缓存策略内容', appliesTo: ['Deploy', ' coding '] },
+    { title: 'A', content: '缓存策略内容', appliesTo: ['deploy', 'CODING'] },
+  )
+  assert.equal(same.entityJaccard, 1)
+  const disjoint = pairFeatures(
+    { title: 'A', content: '缓存策略内容', appliesTo: ['deploy'] },
+    { title: 'A', content: '缓存策略内容', appliesTo: ['backend'] },
+  )
+  assert.equal(disjoint.entityJaccard, 0)
+})
+
+test('pairScore: weighted sum 0.50 lexical + 0.20 token + 0.15 title + 0.15 entity', () => {
+  const features = { lexical: 1, tokenJaccard: 1, titleDice: 1, entityJaccard: 1 }
+  assert.ok(Math.abs(pairScore(features) - 1) < 1e-9)
+  assert.ok(Math.abs(pairScore({ ...features, entityJaccard: 0.5 }) - 0.925) < 1e-9)
+  // entries form is accepted too
+  const entryScore = pairScore(
+    { title: '缓存策略', content: '缓存策略内容一致', appliesTo: ['x'] },
+    { title: '缓存策略', content: '缓存策略内容一致', appliesTo: ['x'] },
+  )
+  assert.ok(entryScore > 0.95)
+})
+
+// —— §4.2 pairDecision ——
+
+const base = { track: 'memory', domain: 'general', title: '缓存策略', content: 'Redis 缓存统一 30 秒过期', appliesTo: [] }
+
+test('pairDecision: different track is always none, even at identical text', () => {
+  const b = { ...base, track: 'skill' }
+  assert.equal(pairDecision(base, b), 'none')
+})
+
+test('pairDecision: cross-domain links only at >=0.65, never absorbs, rp<->coding never links', () => {
+  const same = { ...base, domain: 'coding', title: '缓存策略', content: 'Redis 缓存统一 30 秒过期，额外上下文让分数降下来一些' }
+  const d = pairDecision(base, same)
+  assert.ok(['link', 'none'].includes(d), `cross-domain must be link/none, got ${d}`)
+  const coding = { ...base, domain: 'coding' }
+  const rp = { ...base, domain: 'rp', title: '缓存策略', content: 'Redis 缓存统一 30 秒过期' }
+  assert.equal(pairDecision(coding, rp), 'none', 'rp and coding never link')
+})
+
+test('pairDecision: same-title different-body is conflict; identical text is duplicate', () => {
+  const different = { ...base, title: '缓存策略', content: '缓存全部走内存队列，不落 Redis' }
+  assert.equal(pairDecision(base, different), 'conflict')
+  assert.equal(pairDecision(base, { ...base }), 'duplicate')
+})
+
+test('pairDecision: band boundaries 0.90/0.82/0.55 come from the policy table', () => {
+  const probe = (tweakA, tweakB) => {
+    const a = { ...base, ...tweakA }
+    const b = { ...base, ...tweakB }
+    return { score: pairScore(pairFeatures(a, b)), decision: pairDecision(a, b) }
+  }
+  // construct scores inside each band by mixing known-similar/known-different text
+  const absorbish = probe(
+    { content: 'Redis 缓存统一设置 30 秒过期，命中直接返回' },
+    { content: 'Redis 缓存统一设置 30 秒过期，命中直接返回数据' },
+  )
+  assert.ok(absorbish.score >= 0.82 && absorbish.score < 0.90, `expected absorb band, got ${absorbish.score}`)
+  assert.equal(absorbish.decision, 'absorb')
+})
+
+// —— §4.3 rankPairCandidates ——
+
+function bigCorpus({ withTarget = true } = {}) {
+  // 301 fillers push the corpus past the exact-pair limit → blocking only.
+  const entries = []
+  for (let i = 1; i <= 301; i++) {
+    entries.push({
+      id: `filler-${i}`,
+      track: 'memory',
+      domain: 'filler',
+      title: `填充条目 ${i}`,
+      content: `这是第 ${i} 条填充记忆，用于撑大语料规模，内容彼此不同填充。`,
+      updatedAt: '2026-01-01T00:00:00.000Z',
+    })
+  }
+  if (withTarget) {
+    entries.push({ id: 'target', track: 'memory', domain: 'general', title: '缓存过期', content: 'Redis 缓存统一设置 30 秒过期，命中直接返回，不做全量。', appliesTo: ['deploy'], updatedAt: '2026-01-02T00:00:00.000Z' })
+    entries.push({ id: 'title-only', track: 'memory', domain: 'general', title: '缓存过期', content: '完全不同的词汇组织起来的另一段内容。', updatedAt: '2026-01-03T00:00:00.000Z' })
+    entries.push({ id: 'single-token', track: 'memory', domain: 'elsewhere', title: '项目排期', content: '安排下季度的路线图评审。', updatedAt: '2026-01-04T00:00:00.000Z' })
+  }
+  return buildCorpus(entries)
+}
+
+test('rankPairCandidates: blocking finds the shared-token target in a >300 corpus', () => {
+  const corpus = bigCorpus()
+  assert.ok(corpus.size > 300, 'corpus must exceed the exact-pair limit')
+  const proposal = { id: 'p', track: 'memory', domain: 'general', title: '缓存过期', content: 'Redis 缓存统一设置 30 秒过期，命中直接返回。', appliesTo: ['deploy'] }
+  const found = rankPairCandidates({ corpus, proposal, limit: 20 })
+  const ids = found.map((c) => c.id)
+  assert.ok(ids.includes('target'), `shared >=2 rare tokens must block, got ${ids.join(',')}`)
+  const target = found.find((c) => c.id === 'target')
+  assert.ok(['duplicate', 'absorb'].includes(target.decision), `same-fact band decision, got ${target.decision}`)
+  assert.ok(target.score >= 0.82)
+})
+
+test('rankPairCandidates: exact-title entries enter even without shared tokens', () => {
+  const corpus = bigCorpus()
+  const proposal = { id: 'p', track: 'memory', domain: 'general', title: '缓存过期', content: '完全无重叠词元的新内容组合安排。', appliesTo: [] }
+  const found = rankPairCandidates({ corpus, proposal, limit: 20 })
+  assert.ok(found.some((c) => c.id === 'title-only'))
+})
+
+test('rankPairCandidates: a one-shared-token candidate outside the proposal domain stays out', () => {
+  const corpus = bigCorpus()
+  const proposal = { id: 'p', track: 'memory', domain: 'general', title: '缓存过期', content: '完全无重叠词元的新内容组合安排。', appliesTo: [] }
+  const found = rankPairCandidates({ corpus, proposal, limit: 20 })
+  // 'single-token' shares exactly one rare token (安排) with the proposal and
+  // sits in a different domain: blocking needs >=2 shared tokens and the
+  // same-domain backfill never reaches a foreign domain.
+  assert.ok(!found.some((c) => c.id === 'single-token'))
+})
+
+test('rankPairCandidates: small corpora score every same-track entry and rank the partner first', () => {
+  const corpus = buildCorpus([
+    { id: 'partner', track: 'memory', domain: 'general', title: '部署窗口约定', content: '每周四凌晨两点到四点是固定的部署窗口，窗口内只允许灰度发布。', appliesTo: ['deploy'] },
+    { id: 'other', track: 'memory', domain: 'general', title: '咖啡偏好', content: '用户下午的咖啡只喝美式，上午喝拿铁。', appliesTo: [] },
+  ])
+  const proposal = { id: 'p', track: 'memory', domain: 'general', title: '部署窗口约定', content: '每周四凌晨两点到四点是固定部署窗口，窗口里只允许灰度发布操作。', appliesTo: ['deploy'] }
+  const found = rankPairCandidates({ corpus, proposal, limit: 20 })
+  assert.equal(found[0].id, 'partner')
+  assert.equal(found[0].decision, 'absorb')
+  assert.ok(found.some((c) => c.id === 'other'), 'same-domain backfill keeps the weak partner visible')
+})
+
+test('rankPairCandidates: deterministic — same input, same output', () => {
+  const corpus = bigCorpus()
+  const proposal = { id: 'p', track: 'memory', domain: 'general', title: '缓存过期', content: 'Redis 缓存统一设置 30 秒过期。', appliesTo: [] }
+  const run1 = rankPairCandidates({ corpus, proposal, limit: 20 })
+  const run2 = rankPairCandidates({ corpus, proposal, limit: 20 })
+  assert.deepEqual(run1, run2)
+})
+
+// —— §4.8 全局冲突预筛 ——
+
+test('globalConflictCheck: same title + different body is same_title; negation flips conflict', () => {
+  const a = { title: '缓存策略', content: 'Redis 缓存统一设置 30 秒过期' }
+  const b = { title: '缓存策略', content: '缓存全部走内存队列不落 Redis' }
+  assert.equal(globalConflictCheck(a, b), 'same_title')
+  // different titles (so same_title cannot fire first) + one side negated
+  const c = { title: '告警偏好', content: '用户希望每次部署失败都发告警通知' }
+  const d = { title: '告警设置', content: '用户不希望每次部署失败都发告警通知' }
+  assert.equal(globalConflictCheck(c, d), 'negation')
+  assert.equal(negationPolarity('不发告警'), true)
+  assert.equal(negationPolarity('每次都发告警'), false)
+})
+
+test('globalConflictCheck: differing numbers on similar titles raise value, containment exempts', () => {
+  const a = { title: '备份保留', content: '备份保留 14 天后轮转删除' }
+  const b = { title: '备份保留期', content: '备份保留 90 天后轮转删除' }
+  assert.equal(numericSetsDiffer(a.content, b.content), true)
+  assert.equal(globalConflictCheck(a, b), 'value')
+  const superset = { title: '备份保留', content: '备份保留 14 天后轮转删除，删除前先校验快照完整性' }
+  const detail = globalConflictCheck(a, superset)
+  assert.notEqual(detail, 'value', 'a long refinement of the same fact is not a value conflict')
+})

package/tests/curator-probe.test.mjs

@@ -296,7 +296,7 @@ test('six channels, layer by layer: transcript -> prompt -> simulated output ->
   const prompt = captured.request.prompt[0].text
   assert.match(prompt, /全局记忆提炼任务/)
   const input = promptInput(prompt)
-  assert.deepEqual(Object.keys(input).sort(), ['existing_global_index', 'sessions'])
+  assert.deepEqual(Object.keys(input).sort(), ['candidate_clusters', 'clusters_truncated', 'existing_global_index', 'index_truncated', 'sessions'])
   assert.equal(input.sessions.length, 1)
   assert.deepEqual(
     Object.keys(input.sessions[0]).sort(),
@@ -336,15 +336,23 @@ test('six channels, layer by layer: transcript -> prompt -> simulated output ->
     CHANNELS.map((channel) => channel.layers),
   )
 
-  // The simulated model echoed only what reached the prompt: four transcript
-  // channels plus the two visible existing-index entries.
-  assert.equal(job.result.created, 6)
-  for (const key of ['user', 'assistant', 'toolArgs', 'recallSecret', 'existing', 'pending']) {
+  // The simulated model echoed what reached the prompt: four transcript channels
+  // commit as active; the two index-only echoes (existing/pending never entered the
+  // transcript) fail evidence grounding and are held for review — §4.6 的防幻觉
+  // 门槛正是为这种情况设计的：prompt 里见过 ≠ 转录里说过。
+  assert.equal(job.result.created, 4)
+  for (const key of ['user', 'assistant', 'toolArgs', 'recallSecret']) {
     const entry = Object.values(loadGlobalIndex().entries).find((item) => item.title === 'Copied ' + key)
     assert.ok(entry, 'expected a committed entry copied from ' + key)
     assert.equal(entry.status, 'active')
     assert.match(entry.content, new RegExp(M[key]))
   }
+  for (const key of ['existing', 'pending']) {
+    const held = Object.values(loadGlobalIndex().entries).find((item) => item.title === 'Copied ' + key)
+    assert.ok(held, 'expected the index-only echo to be held, not committed')
+    assert.equal(held.status, 'pending_review')
+    assert.match(held.reviewReason, /missing evidence/)
+  }
   const secretEntry = Object.values(loadGlobalIndex().entries).find((item) => item.title === 'Copied recallSecret')
   assert.match(JSON.stringify(secretEntry.evidence), new RegExp(M.recallSecret))
   for (const key of ['secretAuto', 'recallPlain', 'toolTail', 'archived', 'modelOnly', 'invalidDomain']) {
@@ -391,7 +399,8 @@ test('commit accepts model output without provenance or secret filtering', async
         op: 'create', domain: 'general', track: 'memory', title: 'Credential shaped',
         content: 'api key: ' + M.credential,
         confidence: 0.9,
-        evidence: [{ session_id: 'probe-session', quote: 'q' }],
+        // 1 字 quote 不满足 grounding 的 ≥6 字门槛（§4.6）——加长，测试意图不变。
+        evidence: [{ session_id: 'probe-session', quote: 'credential quote for grounding' }],
       },
     ],
   }