dsh-memu-memory 1.2.1 → 1.2.2

package/tests/curator-calibrate.test.mjs

@@ -0,0 +1,173 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  buildReport,
+  confusionMatrix,
+  evaluateGates,
+  loadFixture,
+  MARK,
+  scorePairs,
+  sweepAt,
+  sweepThresholds,
+} from '../scripts/curator-pair-calibrate.mjs'
+
+// Calibration harness test (spec §8.1 校准层)：fixture 结构、评分确定性、指标数学。
+// The §4.13 gates themselves are a report, not a CI gate (§8.2) — they are
+// asserted here only as data plumbing, never as a pass/fail of the algorithm.
+
+const FIXTURE = path.resolve('tests/fixtures/curator-pairs/labeled.v1.jsonl')
+
+test('fixture: 90 pairs in three equal bands with unique pair and entry ids', () => {
+  const pairs = loadFixture(FIXTURE)
+  assert.equal(pairs.length, 90)
+  for (const label of ['same-fact', 'related', 'none']) {
+    assert.equal(pairs.filter((p) => p.label === label).length, 30, label)
+  }
+  const pairIds = new Set()
+  const entryIds = new Set()
+  for (const pair of pairs) {
+    assert.ok(!pairIds.has(pair.id), `duplicate pair id ${pair.id}`)
+    pairIds.add(pair.id)
+    for (const side of ['a', 'b']) {
+      const entry = pair[side]
+      assert.ok(entry.id, `${pair.id}.${side} carries an id`)
+      assert.ok(!entryIds.has(entry.id), `duplicate entry id ${entry.id}`)
+      entryIds.add(entry.id)
+      assert.ok(String(entry.title || '').length > 0, `${entry.id} has a title`)
+      assert.ok(String(entry.content || '').length >= 8, `${entry.id} has content`)
+      assert.ok(['memory', 'skill'].includes(entry.track), `${entry.id} has a valid track`)
+      assert.ok(Array.isArray(entry.appliesTo), `${entry.id} has an appliesTo array`)
+    }
+  }
+})
+
+test('fixture: covers zh/en/mixed plus length-gap, negation, dates and alias tags', () => {
+  const pairs = loadFixture(FIXTURE)
+  const tags = new Set(pairs.flatMap((p) => p.tags || []))
+  for (const tag of ['length-gap', 'negation-same', 'negation-differ', 'dates-same', 'dates-differ', 'alias', 'punctuation']) {
+    assert.ok(tags.has(tag), `missing coverage tag: ${tag}`)
+  }
+  const langs = new Set(pairs.map((p) => p.lang))
+  for (const lang of ['zh', 'en', 'mixed']) assert.ok(langs.has(lang), `missing language coverage: ${lang}`)
+  // every declared tag is one of the known ones (typo guard)
+  const known = new Set(['paraphrase', 'length-gap', 'containment', 'negation-same', 'negation-differ',
+    'dates-same', 'dates-differ', 'alias', 'alias-related', 'punctuation', 'same-prefix', 'same-topic',
+    'time-shift', 'different-topic', 'different-domain', 'cross-track', 'length-gap-none', 'skill'])
+  for (const tag of tags) assert.ok(known.has(tag), `unknown tag: ${tag}`)
+  // the length-gap tags must be honest: real gap >0.5 on the raw text pair
+  for (const pair of pairs.filter((p) => (p.tags || []).includes('length-gap'))) {
+    const aLen = String(pair.a.title + pair.a.content).length
+    const bLen = String(pair.b.title + pair.b.content).length
+    assert.ok(Math.abs(aLen - bLen) / Math.max(aLen, bLen) > 0.5, `${pair.id} claims length-gap but the gap is small`)
+  }
+})
+
+test('fixture header marks the data as a synthetic draft, never a gold set', () => {
+  assert.equal(MARK, 'synthetic-draft-not-gold')
+  const report = buildReport(loadFixture(FIXTURE))
+  assert.equal(report.mark, MARK)
+  assert.match(report.note, /synthetic draft/i)
+  assert.match(report.note, /NOT a production gold set/i)
+})
+
+test('scoring is deterministic: two passes agree exactly', () => {
+  const pairs = loadFixture(FIXTURE)
+  assert.deepEqual(scorePairs(pairs), scorePairs(pairs))
+  const report1 = buildReport(pairs)
+  const report2 = buildReport(pairs)
+  assert.deepEqual(report1.pairs, report2.pairs)
+  assert.deepEqual(report1.confusion, report2.confusion)
+  assert.deepEqual(report1.candidateRecall, report2.candidateRecall)
+})
+
+test('sweepAt: precision/recall/F1 arithmetic on a hand-checked population', () => {
+  const results = [
+    { label: 'same-fact', score: 0.9 },
+    { label: 'same-fact', score: 0.7 },
+    { label: 'related', score: 0.6 },
+    { label: 'none', score: 0.75 },
+    { label: 'none', score: 0.2 },
+  ]
+  const at082 = sweepAt(results, ['same-fact'], 0.82)
+  assert.deepEqual(
+    { tp: at082.tp, fp: at082.fp, fn: at082.fn },
+    { tp: 1, fp: 0, fn: 1 },
+  )
+  assert.equal(at082.precision, 1)
+  assert.equal(at082.recall, 0.5)
+  assert.equal(at082.f1, 0.6667)
+  const at055 = sweepAt(results, ['same-fact', 'related'], 0.55)
+  assert.deepEqual({ tp: at055.tp, fp: at055.fp, fn: at055.fn }, { tp: 3, fp: 1, fn: 0 })
+  assert.equal(at055.precision, 0.75)
+  assert.equal(at055.recall, 1)
+  // empty predictions → null precision, not NaN
+  const empty = sweepAt(results, ['same-fact'], 1.5)
+  assert.equal(empty.precision, null)
+  assert.equal(empty.recall, 0)
+})
+
+test('sweepThresholds walks 0.50→0.95 inclusive with 0.01 steps', () => {
+  const rows = sweepThresholds([{ label: 'none', score: 0.6 }], ['same-fact'], {})
+  assert.equal(rows.length, 46)
+  assert.equal(rows[0].threshold, 0.5)
+  assert.equal(rows.at(-1).threshold, 0.95)
+})
+
+test('confusionMatrix: label × decision counts sum to the population', () => {
+  const results = [
+    { label: 'same-fact', decision: 'duplicate' },
+    { label: 'same-fact', decision: 'absorb' },
+    { label: 'related', decision: 'link' },
+    { label: 'none', decision: 'none' },
+  ]
+  const { matrix } = confusionMatrix(results)
+  assert.equal(matrix['same-fact'].duplicate, 1)
+  assert.equal(matrix['same-fact'].absorb, 1)
+  assert.equal(matrix.related.link, 1)
+  assert.equal(matrix.none.none, 1)
+  const total = Object.values(matrix).reduce((sum, row) => sum + Object.values(row).reduce((a, b) => a + b, 0), 0)
+  assert.equal(total, 4)
+})
+
+test('evaluateGates: the four §4.13 thresholds flip pass/fail at their bounds', () => {
+  const pass = evaluateGates({
+    absorbAt082: { precision: 0.96 },
+    linkAt055: { precision: 0.9 },
+    noneAt055: { rate: 0.05 },
+    recall20: { recall: 0.97 },
+  })
+  assert.ok(pass.every((gate) => gate.pass))
+  const fail = evaluateGates({
+    absorbAt082: { precision: 0.94 },
+    linkAt055: { precision: 0.84 },
+    noneAt055: { rate: 0.11 },
+    recall20: { recall: 0.94 },
+  })
+  assert.ok(fail.every((gate) => !gate.pass))
+  // null precision (empty population) never counts as a pass
+  const degenerate = evaluateGates({
+    absorbAt082: { precision: null },
+    linkAt055: { precision: null },
+    noneAt055: { rate: null },
+    recall20: { recall: null },
+  })
+  assert.ok(degenerate.every((gate) => !gate.pass))
+})
+
+test('candidateRecall: every same-fact partner is reachable through rankPairCandidates', () => {
+  const report = buildReport(loadFixture(FIXTURE))
+  assert.equal(report.candidateRecall.total, 30)
+  assert.equal(report.candidateRecall.limit, 20)
+  // data plumbing only — the gate value is reported in the calibration run
+  assert.ok(report.candidateRecall.recall >= 0 && report.candidateRecall.recall <= 1)
+})
+
+test('fixture file ends with a newline and parses as strict JSONL', () => {
+  const raw = fs.readFileSync(FIXTURE, 'utf8')
+  assert.match(raw, /\n$/, 'trailing newline (CRLF conversion friendly)')
+  const lines = raw.split(/\r?\n/).filter((line) => line.trim())
+  assert.equal(lines.length, 90)
+  for (const line of lines) JSON.parse(line)
+})

package/tests/curator-clusters.test.mjs

@@ -0,0 +1,281 @@
+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'
+
+// Candidate clusters (spec §4.4) + curator context packing (§4.5).
+//
+// buildCandidateClusters is pure (text-retrieval), but packCuratorIndexContext /
+// packCuratorClusterContext live in curator.js, which pulls the module stack —
+// so this file uses the same hermetic rig as tests/curator-commit.test.mjs:
+// './memu.js' is replaced before production modules load and DSH_MEMU_HOME
+// points at a temp root.
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-clusters-'))
+process.env.DSH_MEMU_HOME = home
+process.env.DSH_MEMU_MEMORY_HOME = home
+
+globalThis.__curatorClusterTest = {
+  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.__curatorClusterTest;'
+  + '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 { buildCandidateClusters } = await import('../lib/text-retrieval.js')
+const curator = await import('../lib/curator.js')
+
+test.after(async () => {
+  try { hooks.unregister?.() } catch {}
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+const entryOf = (id, title, content, extra = {}) => ({
+  id, track: 'memory', domain: 'general', status: 'active',
+  title, content, updatedAt: '2026-01-01T00:00:00.000Z', ...extra,
+})
+
+const index = (entries) => ({ version: 1, entries: Object.fromEntries(entries.map((e) => [e.id, e])) })
+
+// —— blocking ——
+
+// 1440 distinct CJK words; each filler picks 6 with its own PRNG stream, so two
+// fillers share at most a stray bigram (never enough Dice for an edge) and the
+// pair under test is the only real signal in the corpus. The one-char title
+// keeps both probe entries' token sets to their content words ('x' is dropped
+// by tokenize) while the title bigrams keep Dice high.
+const VOCAB = []
+for (const first of '甲乙丙丁戊己庚辛壬癸') {
+  for (const second of '子丑寅卯辰巳午未申酉戌亥') {
+    for (const third of '東南西北中發白裏乾坤') VOCAB.push(`词${first}${second}${third}`)
+  }
+}
+function mulberry32(seed) {
+  let state = seed >>> 0
+  return () => {
+    state = (state + 0x6D2B79F5) | 0
+    let t = Math.imul(state ^ (state >>> 15), 1 | state)
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+function fillers(count, from = 0) {
+  const out = []
+  for (let i = from + 1; i <= from + count; i++) {
+    const random = mulberry32(i * 7919)
+    const deck = [...VOCAB.keys()]
+    const words = []
+    for (let t = 0; t < 6; t++) {
+      const pick = Math.floor(random() * deck.length)
+      words.push(VOCAB[deck.splice(pick, 1)[0]])
+    }
+    out.push(entryOf(`filler-${i}`, 'x', words.join('、') + '。'))
+  }
+  return out
+}
+
+test('N=300 exact all-pairs still cluster a high-Dice one-shared-token pair', () => {
+  const entries = [
+    entryOf('deploy-a', 'x', 'deploy cache'),
+    entryOf('deploy-b', 'x', 'redeploy cache'),
+    ...fillers(298),
+  ]
+  const { clusters } = buildCandidateClusters(index(entries))
+  const pair = clusters.find((c) => c.members.some((m) => m.id === 'deploy-a'))
+  assert.ok(pair, 'at N<=300 the exact pass scores every same-track pair')
+  assert.deepEqual(pair.members.map((m) => m.id).sort(), ['deploy-a', 'deploy-b'])
+})
+
+test('N=301 switches to inverted blocking: the same pair shares only 1 token and must not cluster', () => {
+  const entries = [
+    entryOf('deploy-a', '部署', 'deploy cache'),
+    entryOf('deploy-b', '锚点', 'redeploy cache'),
+    ...fillers(299),
+  ]
+  const { clusters } = buildCandidateClusters(index(entries))
+  assert.equal(clusters.length, 0, 'shared token count 1 < blockMinShared 2 keeps the pair out')
+})
+
+// —— all-pairs clique growth ——
+
+// A-B ≈0.68, B-C ≈0.82, A-C ≈0.39: whichever edge seeds the cluster, the third
+// member always violates the all-pairs constraint against the opposite side.
+const chainIndex = () => index([
+  entryOf('A', '站会要点', '站会先过昨日进展，再排今日任务，最后收集阻塞。'),
+  entryOf('B', '站会要点', '站会先过昨日进展，然后直接进入深挖环节，限时十分钟。'),
+  entryOf('C', '站会要点', '站会先过昨日进展，然后直接进入深挖环节。'),
+])
+
+test('all-pairs constraint: an A-B-C chain never becomes one cluster', () => {
+  const { clusters } = buildCandidateClusters(chainIndex())
+  assert.ok(clusters.length >= 1, 'the two strong edges must form at least one cluster')
+  for (const cluster of clusters) {
+    const ids = cluster.members.map((m) => m.id)
+    assert.ok(!ids.includes('A') || !ids.includes('C'), `A and C must never cohabit: ${ids.join(',')}`)
+  }
+  // every kept edge honours the floor pair-wise, not just transitively
+  for (const cluster of clusters) {
+    for (const [key, score] of Object.entries(cluster.pair_scores)) {
+      assert.ok(score >= 0.55, `in-cluster pair ${key} below floor: ${score}`)
+    }
+  }
+})
+
+test('all-pairs constraint: deterministic across runs', () => {
+  assert.deepEqual(buildCandidateClusters(chainIndex()), buildCandidateClusters(chainIndex()))
+})
+
+// —— medoid ——
+
+test('medoid is the member with the highest average pairwise score; ties break updatedAt desc then id asc', () => {
+  const entries = [
+    entryOf('t1', '缓存策略', 'Redis 缓存统一设置 30 秒过期，过期回源并写回缓存。', { updatedAt: '2026-01-01T00:00:00.000Z' }),
+    entryOf('t2', '缓存策略', 'Redis 缓存统一设置 30 秒过期，过期回源并写回缓存集合。', { updatedAt: '2026-01-02T00:00:00.000Z' }),
+    entryOf('t3', '缓存策略', 'Redis 缓存统一设置 30 秒过期，过期回源写回缓存集合。', { updatedAt: '2026-01-03T00:00:00.000Z' }),
+  ]
+  const { clusters } = buildCandidateClusters(index(entries))
+  assert.equal(clusters.length, 1)
+  const cluster = clusters[0]
+  assert.equal(cluster.members.length, 3)
+  // medoid: recompute averages from the published upper-triangle pair scores
+  const scores = cluster.pair_scores
+  const pairsOf = (id) => Object.entries(scores).filter(([key]) => key.includes(id))
+  const avg = (id) => pairsOf(id).reduce((sum, [, value]) => sum + value, 0) / pairsOf(id).length
+  const best = cluster.members.map((m) => m.id).sort((x, y) => avg(y) - avg(x) || String(y).localeCompare(String(x)))[0]
+  assert.equal(cluster.medoid_id, best)
+  assert.ok(cluster.avg_score >= 0.82, `a tight triple must average in the absorb band, got ${cluster.avg_score}`)
+  assert.equal(cluster.suggested_op, 'absorb', '3 members, same domain, avg >=0.82')
+  assert.equal(cluster.cluster_id, 'cl-1')
+  assert.equal(Object.keys(scores).length, 3, 'upper triangle only')
+})
+
+test('a 2-member cluster never suggests absorb even at duplicate-level similarity', () => {
+  const { clusters } = buildCandidateClusters(index([
+    entryOf('p1', '发布清单', '发版前按清单逐项确认版本号、changelog 和回归标记。'),
+    entryOf('p2', '发布清单', '发版前按清单逐项确认版本号、changelog与回归标记。'),
+  ]))
+  assert.equal(clusters.length, 1)
+  assert.equal(clusters[0].members.length, 2)
+  assert.equal(clusters[0].suggested_op, 'link')
+})
+
+test('medoid average below the pair floor drops the whole cluster (defensive, via lowered minPairScore)', () => {
+  const { clusters } = buildCandidateClusters(index([
+    entryOf('w1', '杂项', '条目甲的内容讲预算审批流程。'),
+    entryOf('w2', '杂项', '条目甲的内容讲预算审批与报销流程。'),
+    entryOf('w3', '杂项', '条目甲的内容讲报销与发票流程。'),
+  ]), { minPairScore: 0.3 })
+  for (const cluster of clusters) {
+    assert.ok(cluster.avg_score >= 0.55 || cluster.medoid_avg_dropped !== true)
+  }
+  // with the floor at 0.3 edges form, but a medoid averaging <0.55 must be dropped
+  const weak = clusters.filter((c) => c.avg_score < 0.55)
+  assert.equal(weak.length, 0, 'no cluster below the 0.55 output floor survives')
+})
+
+test('clusters never span tracks', () => {
+  const { clusters } = buildCandidateClusters(index([
+    entryOf('m1', '发布清单', '发版前按清单逐项确认版本号、changelog 和回归标记。', { track: 'memory' }),
+    entryOf('s1', '发布清单', '发版前按清单逐项确认版本号、changelog 与回归标记。', { track: 'skill' }),
+  ]))
+  assert.equal(clusters.length, 0)
+})
+
+test('>12 clusters are truncated by avg_score desc', () => {
+  const entries = []
+  for (let i = 1; i <= 15; i++) {
+    entries.push(entryOf(`pair-${i}-a`, `主题${i}`, `主题甲${i}：独有词${i}${i}的内容陈述。`))
+    entries.push(entryOf(`pair-${i}-b`, `主题${i}`, `主题甲${i}：独有词${i}${i}的内容陈述变体。`))
+  }
+  const { clusters } = buildCandidateClusters(index(entries))
+  assert.equal(clusters.length, 12)
+  const avgs = clusters.map((c) => c.avg_score)
+  assert.deepEqual([...avgs].sort((a, b) => b - a), avgs, 'output stays avg_score-descending')
+  for (const cluster of clusters) assert.equal(cluster.suggested_op, 'link')
+})
+
+test('recentLimit cuts the pool to the most recent entries and flags truncation', () => {
+  const partner = entryOf('partner-old', '旧站会', '站会先过昨日进展，再排今日任务，最后收集阻塞。', { updatedAt: '2025-06-01T00:00:00.000Z' })
+  const seed = entryOf('seed-new', '旧站会', '站会先过昨日进展，再排今日任务，最后收集阻塞项。', { updatedAt: '2026-06-01T00:00:00.000Z' })
+  const entries = [partner, seed, ...fillers(58)]
+  const result = buildCandidateClusters(index(entries), { recentLimit: 30 })
+  assert.equal(result.truncated, true)
+  assert.equal(result.scanned, 30)
+  assert.equal(result.clusters.length, 0, 'the older partner fell outside the recent window')
+})
+
+// —— §4.5 context packing ——
+
+test('packCuratorIndexContext: deterministic, budgeted, BM25-ordered, archived out / pending in', () => {
+  const entries = {
+    'gmem-hot': entryOf('gmem-hot', '部署窗口', '每周四凌晨两点到四点是固定的部署窗口，窗口内只允许灰度发布。'),
+    'gmem-cold': entryOf('gmem-cold', '摄影器材', '用户的相机是全画幅微单，常用 35mm 定焦。'),
+    'gmem-pending': entryOf('gmem-pending', '部署告警', '部署失败要发告警到值班群。', { status: 'pending_review', updatedAt: '2026-02-01T00:00:00.000Z' }),
+    'gmem-archived': entryOf('gmem-archived', '旧部署窗口', '旧窗口已废弃不用。', { status: 'archived' }),
+    'gmem-linked': entryOf('gmem-linked', '回滚流程', '窗口结束前完成回滚。', { links: [{ id: 'lnk_1', to: 'gmem-hot', kind: 'related' }, { id: 'lnk_2', to: 'gmem-x', kind: 'refines' }] }),
+  }
+  const sessionText = '这次会话都在讨论部署窗口与灰度发布的安排'
+  const pack1 = curator.packCuratorIndexContext({ index: { entries }, sessionText })
+  const pack2 = curator.packCuratorIndexContext({ index: { entries }, sessionText })
+  assert.deepEqual(pack1, pack2)
+  const ids = pack1.entries.map((e) => e.id)
+  assert.ok(ids.includes('gmem-hot'), 'the BM25-best entry ranks first')
+  assert.equal(ids[0], 'gmem-hot')
+  assert.ok(ids.includes('gmem-pending'), 'pending_review stays in the pool')
+  assert.ok(!ids.includes('gmem-archived'), 'archived entries are filtered')
+  const linked = pack1.entries.find((e) => e.id === 'gmem-linked')
+  assert.equal(linked.linkCount, 2)
+  assert.deepEqual(linked.linkedTo, [
+    { to: 'gmem-hot', kind: 'related' },
+    { to: 'gmem-x', kind: 'refines' },
+  ], 'linkedTo carries the first 5 links without notes')
+  const hot = pack1.entries.find((e) => e.id === 'gmem-hot')
+  assert.ok(hot.content.includes('灰度发布'), 'content survives truncation at 900/600 chars')
+  assert.ok(pack1.tokens <= 4000, `index budget respected, got ${pack1.tokens}`)
+})
+
+test('packCuratorIndexContext: a tiny budget drops low-scoring entries instead of truncating JSON', () => {
+  const entries = {
+    'gmem-a': entryOf('gmem-a', '部署窗口', '每周四凌晨两点到四点是固定的部署窗口，窗口内只允许灰度发布。'),
+    'gmem-b': entryOf('gmem-b', '摄影器材', '用户的相机是全画幅微单，常用 35mm 定焦。'),
+    'gmem-c': entryOf('gmem-c', '咖啡偏好', '用户下午的咖啡只喝美式，上午喝拿铁。'),
+  }
+  const packed = curator.packCuratorIndexContext({ index: { entries }, sessionText: '部署窗口 灰度发布', tokenBudget: 120 })
+  assert.ok(packed.entries.length < 3, `a 120-token budget must drop entries, kept ${packed.entries.length}`)
+  assert.equal(packed.entries[0].id, 'gmem-a', 'the best-scoring entry survives a tiny budget')
+  assert.equal(packed.omitted, 3 - packed.entries.length)
+})
+
+test('packCuratorClusterContext: budget 2000 keeps whole clusters, drops the lowest scores', () => {
+  const clusterResult = buildCandidateClusters(index([
+    entryOf('k1', '缓存策略', 'Redis 缓存统一设置 30 秒过期，过期回源并写回缓存。'),
+    entryOf('k2', '缓存策略', 'Redis 缓存统一设置 30 秒过期，过期回源并写回缓存集合。'),
+    entryOf('k3', '缓存策略', 'Redis 缓存统一设置 30 秒过期，过期回源写回缓存集合。'),
+    entryOf('j1', '发布清单', '发版前按清单逐项确认版本号、changelog 和回归标记。'),
+    entryOf('j2', '发布清单', '发版前按清单逐项确认版本号、changelog与回归标记。'),
+  ]))
+  assert.equal(clusterResult.clusters.length, 2)
+  const packed = curator.packCuratorClusterContext(clusterResult)
+  assert.deepEqual(packed.clusters.map((c) => c.cluster_id), clusterResult.clusters.map((c) => c.cluster_id))
+  assert.ok(packed.tokens <= 2000)
+  assert.equal(packed.truncated, false)
+  const rendered = packed.clusters[0]
+  assert.ok(rendered.members[0].content.length <= 301, 'cluster member content is cut to 300 chars')
+  for (const score of Object.values(rendered.pair_scores)) {
+    assert.equal(Math.round(score * 100) / 100, score, 'pair_scores keep 2 decimals')
+  }
+  const squeezed = curator.packCuratorClusterContext(clusterResult, { tokenBudget: 100 })
+  assert.equal(squeezed.clusters.length, 1, 'a 100-token budget keeps only the best cluster')
+  assert.equal(squeezed.omitted, 1)
+  assert.equal(squeezed.truncated, true)
+})

package/tests/curator-commit.test.mjs

@@ -194,7 +194,7 @@ test('a clean create still carries the current-generation stamp and is counted b
       title: '独立的全新事实',
       content: '用户倾向于在正式汇报里先给结论再给细节。',
       confidence: 0.9,
-      evidence: [{ session_id: 's2', quote: '先说结论' }],
+      evidence: [{ session_id: 's2', quote: '汇报时先给结论再讲细节' }],
     }],
   }
   const result = await curator.commitCuratorOutput(output, { job: { step: 'committing' } })
@@ -213,8 +213,8 @@ test('a global-index write failure after the batch commit is compensated name by
   await activateVectorGeneration()
   const output = {
     memories: [
-      { op: 'create', domain: 'general', track: 'memory', title: '第一条', content: '第一条全新事实的内容，足够长以通过校验。', confidence: 0.9, evidence: [{ session_id: 's3', quote: '一' }] },
-      { op: 'create', domain: 'general', track: 'memory', title: '第二条', content: '第二条全新事实的内容，与第一条没有关系。', confidence: 0.9, evidence: [{ session_id: 's4', quote: '二' }] },
+      { op: 'create', domain: 'general', track: 'memory', title: '第一条', content: '第一条全新事实的内容，足够长以通过校验。', confidence: 0.9, evidence: [{ session_id: 's3', quote: '第一条内容的原话记录' }] },
+      { op: 'create', domain: 'general', track: 'memory', title: '第二条', content: '第二条全新事实的内容，与第一条没有关系。', confidence: 0.9, evidence: [{ session_id: 's4', quote: '第二条内容的原话记录' }] },
     ],
   }
   indexHook.failNext = 1
@@ -257,8 +257,8 @@ test('a compensation failure is reported per name and never hides the original e
   }
   const output = {
     memories: [
-      { op: 'create', domain: 'general', track: 'memory', title: '甲', content: '甲事实的内容，与乙无关。', confidence: 0.9, evidence: [{ session_id: 's5', quote: '甲' }] },
-      { op: 'create', domain: 'general', track: 'memory', title: '乙', content: '乙事实的内容，与甲无关。', confidence: 0.9, evidence: [{ session_id: 's6', quote: '乙' }] },
+      { op: 'create', domain: 'general', track: 'memory', title: '甲', content: '甲事实的内容，与乙无关。', confidence: 0.9, evidence: [{ session_id: 's5', quote: '甲条内容的原话记录' }] },
+      { op: 'create', domain: 'general', track: 'memory', title: '乙', content: '乙事实的内容，与甲无关。', confidence: 0.9, evidence: [{ session_id: 's6', quote: '乙条内容的原话记录' }] },
     ],
   }
   indexHook.failNext = 1
@@ -275,3 +275,50 @@ test('a compensation failure is reported per name and never hides the original e
   assert.match(event.detail.failed[0].error, /engine db is locked/)
   assert.match(event.message, /残留孤儿行/)
 })
+
+// Package A (spec §4.10): the risk score is an audit trail, so it must survive
+// the two paths that rewrite an entry after the decision was made: the held
+// clone (target changed mid-run) and the activity-log summary.
+test('a held clone from a target-changed conflict keeps the decision risk score for audit', async () => {
+  seedGlobalIndex({ [TARGET]: TARGET_ENTRY })
+  await activateVectorGeneration()
+  // mergeOutput is a clean risky-rewrite candidate: merge 0.20 + single evidence
+  // 0.10 → risk 0.30 < 0.70, so auto commits it and the concurrent writer turns
+  // the committed row into a held clone.
+  backend.onCommit = async () => {
+    state.updateGlobalIndex((fresh) => {
+      fresh.entries[TARGET] = { ...fresh.entries[TARGET], content: '内容已被并发修改', updatedAt: '2026-02-02T00:00:00.000Z' }
+    })
+  }
+  await curator.commitCuratorOutput(structuredClone(mergeOutput), { job: { step: 'committing' } })
+  backend.onCommit = null
+  const index = state.loadGlobalIndex()
+  const heldId = Object.keys(index.entries).find((id) => index.entries[id]?.reviewReason === 'target changed while curator was running')
+  assert.ok(heldId, 'the target-changed merge must be held for review')
+  const held = index.entries[heldId]
+  assert.equal(held.reviewRisk, 0.3, 'merge 0.20 + single evidence 0.10 survives the clone')
+  assert.deepEqual(held.reviewRiskReasons, ['merge', 'single evidence'])
+  assert.equal(held.status, 'pending_review')
+})
+
+test('the curate activity record carries the batch review-risk summary', async () => {
+  seedGlobalIndex({})
+  await activateVectorGeneration()
+  const output = {
+    memories: [
+      { op: 'create', domain: 'general', track: 'memory', title: '低风险条目', content: '低风险条目的内容，与另一条无关。', confidence: 0.9, evidence: [{ session_id: 's7', quote: '低风险条目的原话记录' }] },
+      { op: 'create', domain: 'general', track: 'memory', title: '高风险条目', content: '高风险条目的内容，模型自己标了待复核。', confidence: 0.9, needs_review: true, evidence: [{ session_id: 's8', quote: '高风险条目的原话记录' }] },
+    ],
+  }
+  const result = await curator.commitCuratorOutput(structuredClone(output), { job: { step: 'committing' } })
+  assert.equal(result.created, 2)
+  assert.deepEqual(result.reviewRisk, { max: 0.8, flagged: 1, reasons: { 'needs_review': 1, 'single evidence': 2 } })
+  // listEvents is newest-first; this run is the only successful curation with
+  // exactly two created entries, so match on that instead of list position.
+  const event = activity.listEvents({ kind: 'curate' })
+    .find((item) => item.ok === true && item.detail?.reviewRisk && item.detail?.created === 2)
+  assert.ok(event, 'the successful curation must be recorded')
+  assert.equal(event.detail.reviewRisk.max, 0.8)
+  assert.equal(event.detail.reviewRisk.flagged, 1)
+  assert.equal(event.detail.reviewRisk.reasons.needs_review, 1)
+})

package/tests/curator-evidence.test.mjs

@@ -0,0 +1,102 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { buildEvidenceCorpus, groundEvidence, groundLinkNote, normalizeEvidenceText } from '../lib/curator-evidence.js'
+
+const transcript = [
+  'User: 我们把每周的部署窗口定在周四凌晨两点到四点，只允许灰度发布。',
+  'Assistant: 好的，部署窗口已记录：周四 02:00-04:00，灰度 only。',
+  'User: 另外我的 api_key 是 sk-abcdef1234567890abcdef，别外传。',
+].join('\n')
+
+const corpus = buildEvidenceCorpus([{ id: 's1', transcript }])
+
+test('normalizeEvidenceText: NFKC + lowercase + strip whitespace/punctuation/symbols', () => {
+  assert.equal(normalizeEvidenceText('部署窗口！Ａｐｉ＿Key…'), '部署窗口ａｐｉkey'.replace('ａｐｉ', 'api'))
+  assert.equal(normalizeEvidenceText('  Hello, World! '), 'helloworld')
+  assert.equal(normalizeEvidenceText('灰度-发布_v2'), '灰度发布v2')
+})
+
+test('groundEvidence: exact quote grounds; punctuation differences do not block', () => {
+  const exact = groundEvidence([{ session_id: 's1', quote: '周四凌晨两点到四点' }], corpus)
+  assert.equal(exact.status, 'grounded')
+  assert.equal(exact.valid.length, 1)
+  assert.deepEqual(exact.invalid, [])
+  const punctuated = groundEvidence([{ session_id: 's1', quote: '部署窗口定在周四凌晨两点到四点，只允许灰度发布。' }], corpus)
+  assert.equal(punctuated.valid.length, 1, 'punctuation is stripped on both sides before matching')
+})
+
+test('groundEvidence: a fabricated quote fails grounding', () => {
+  const fabricated = groundEvidence([{ session_id: 's1', quote: '周五凌晨五点才部署呢' }], corpus)
+  assert.equal(fabricated.valid.length, 0)
+  assert.match(fabricated.invalid[0].reason, /not found in session/)
+})
+
+test('groundEvidence: session_id must belong to this curation', () => {
+  const stranger = groundEvidence([{ session_id: 's-other', quote: '周四凌晨两点到四点' }], corpus)
+  assert.equal(stranger.valid.length, 0)
+  assert.match(stranger.invalid[0].reason, /not part of this curation/)
+})
+
+test('groundEvidence: quotes shorter than 6 normalized chars are rejected', () => {
+  const short = groundEvidence([{ session_id: 's1', quote: '周四' }], corpus)
+  assert.equal(short.valid.length, 0)
+  assert.match(short.invalid[0].reason, /shorter than 6/)
+})
+
+test('groundEvidence: ellipsis quotes split into 2-3 segments, each >=4 chars and found', () => {
+  const ok = groundEvidence([{ session_id: 's1', quote: '周四凌晨两点到四点……只允许灰度发布' }], corpus)
+  assert.equal(ok.valid.length, 1, 'a two-segment ellipsis quote with both halves present grounds')
+  const missing = groundEvidence([{ session_id: 's1', quote: '周四凌晨两点到四点……周五凌晨五点开工' }], corpus)
+  assert.equal(missing.valid.length, 0)
+  assert.match(missing.invalid[0].reason, /ellipsis segment not found/)
+  const tooShort = groundEvidence([{ session_id: 's1', quote: '周四凌晨两点到四点……灰度' }], corpus)
+  assert.equal(tooShort.valid.length, 0)
+  assert.match(tooShort.invalid[0].reason, /ellipsis segment shorter than 4/)
+  const tooMany = groundEvidence([{ session_id: 's1', quote: '我们……周四凌晨……灰度发布……记录' }], corpus)
+  assert.equal(tooMany.valid.length, 0)
+  assert.match(tooMany.invalid[0].reason, /2-3 segments/)
+})
+
+test('groundEvidence: quotes are redactSecrets-ed before storage', () => {
+  // The transcript above contains a raw key; quoting it verbatim must fail the
+  // substring check (the corpus is redacted), and the stored quote is redacted.
+  const leaked = groundEvidence([{ session_id: 's1', quote: 'sk-abcdef1234567890abcdef' }], corpus)
+  assert.equal(leaked.valid.length, 0, 'a raw secret is not in the redacted corpus, so it cannot ground')
+  const mixed = groundEvidence([{ session_id: 's1', quote: 'api_key 是 sk-abcdef1234567890abcdef，别外传' }], corpus)
+  assert.equal(mixed.valid.length, 0, 'the secret-bearing span cannot ground either')
+  // Direct redaction check: groundEvidence never stores an unredacted secret.
+  const unverifiedCorpus = buildEvidenceCorpus([{ id: 'x', transcript: 'token sk-zzzz1111222233334444 inside' }])
+  const got = groundEvidence([{ session_id: 'x', quote: 'token sk-zzzz1111222233334444 inside' }], unverifiedCorpus)
+  assert.equal(got.valid.length, 0, 'even a self-consistent corpus fails when the quote redacts away')
+})
+
+test('groundEvidence: no sessionCorpus means shape-checked unverified, not rejected', () => {
+  const got = groundEvidence([{ session_id: 's9', quote: '完全没有出处的引用也可以' }], null)
+  assert.equal(got.status, 'unverified')
+  assert.equal(got.valid.length, 1)
+  assert.deepEqual(got.invalid, [])
+  const malformed = groundEvidence([{ session_id: '', quote: '完全没有出处的引用也可以' }], null)
+  assert.equal(malformed.valid.length, 0)
+  assert.match(malformed.invalid[0].reason, /missing session_id/)
+})
+
+test('buildEvidenceCorpus: ids and normalized transcripts; empty ids skipped', () => {
+  const c = buildEvidenceCorpus([
+    { id: 'a', transcript: '部署窗口！' },
+    { id: '', transcript: 'ignored' },
+    { id: 'b', text: 'second channel' },
+  ])
+  assert.deepEqual([...c.ids].sort(), ['a', 'b'])
+  assert.equal(c.text.get('a'), '部署窗口')
+  assert.equal(c.text.get('b'), 'secondchannel')
+})
+
+test('groundLinkNote: 8-500 chars and must contain one grounded quote verbatim', () => {
+  const evidence = [{ sessionId: 's1', quote: '周四凌晨两点到四点' }]
+  assert.equal(groundLinkNote('部署窗口与告警规则相关联', evidence).ok, false, 'note without the quote is rejected')
+  const ok = groundLinkNote('两条记忆都源于部署窗口的约定：周四凌晨两点到四点', evidence)
+  assert.equal(ok.ok, true, 'note quoting the evidence grounds')
+  assert.equal(groundLinkNote('太短了', evidence).ok, false)
+  assert.equal(groundLinkNote('x'.repeat(501), evidence).ok, false)
+  assert.equal(groundLinkNote('八到五百之间的正常说明文字', []).ok, false, 'no evidence, no note grounding')
+})