dsh-memu-memory 1.2.0 → 1.2.2

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

@@ -0,0 +1,324 @@
+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'
+
+// commitCuratorOutput regressions :
+//   1. A held clone created by a target-changed conflict must NOT inherit the
+//      vector stamp of the batch commit (the batch committed `id`, not heldId),
+//      and membership must not count either the clone or the unindexed `id` row.
+//   2. A global-index write failure after the batch commit must be compensated:
+//      every committed name receives a forget, and partial/complete outcomes are
+//      recorded to the activity log (compensation design, not a transaction).
+//
+// No engine, no download: './memu.js' is replaced before production modules
+// load (same pattern as tests/managed-memory.test.mjs), and './state.js' is
+// wrapped with a one-shot updateGlobalIndex failure switch. Everything else is
+// the real module stack against a temp DSH_MEMU_HOME.
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-curator-commit-'))
+process.env.DSH_MEMU_HOME = home
+process.env.DSH_MEMU_MEMORY_HOME = home
+
+const backend = {
+  commits: [],
+  forgets: [],
+  onCommit: null,
+}
+globalThis.__curatorCommitTest = {
+  async commit(args) {
+    const names = (args.payload?.recall_files || []).map((file) => file.name)
+    backend.commits.push({ names, route: args.route, db: args.db })
+    if (backend.onCommit) await backend.onCommit()
+    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 } },
+}
+
+// One-shot failure switch on updateGlobalIndex; every other state.js export is
+// forwarded to the real module (local exports shadow the star re-export).
+const indexHook = { failNext: 0, thrown: [] }
+globalThis.__curatorIndexHook = indexHook
+
+const realStateUrl = new URL('../lib/state.js', import.meta.url).href
+const realMemuUrl = new URL('../lib/memu.js', import.meta.url).href
+const memuSource = 'const bridge = globalThis.__curatorCommitTest;'
+  + 'export const commit = (args) => bridge.commit(args), forget = (args) => bridge.forget(args),'
+  + 'retrieve = (args) => bridge.retrieve(args), listFiles = (args) => bridge.listFiles(args);'
+const stateSource = [
+  `import * as real from ${JSON.stringify(realStateUrl)}`,
+  'const hook = globalThis.__curatorIndexHook',
+  'export function updateGlobalIndex(mutator) {',
+  '  if (hook.failNext > 0) { hook.failNext -= 1; const error = new Error("disk full (simulated index failure)"); hook.thrown.push(String(error.message)); throw error }',
+  '  return real.updateGlobalIndex(mutator)',
+  '}',
+  `export * from ${JSON.stringify(realStateUrl)}`,
+].join('\n')
+const hooks = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (specifier === './memu.js') return { url: 'data:text/javascript,' + encodeURIComponent(memuSource), shortCircuit: true }
+    if (specifier === './state.js') return { url: 'data:text/javascript,' + encodeURIComponent(stateSource), shortCircuit: true }
+    return nextResolve(specifier, context)
+  },
+})
+
+const catalog = await import('../lib/embedding-catalog.js')
+const vp = await import('../lib/vector-profile.js')
+const vm = await import('../lib/vector-migration.js')
+const curator = await import('../lib/curator.js')
+const state = await import('../lib/state.js')
+const activity = await import('../lib/activity-log.js')
+
+const BGE = 'bge-small-zh-v1.5-int8'
+// A second resolvable catalog entry so switchProfile has a verified profile to
+// activate (same fixture trick as tests/vector-migration.test.mjs).
+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 (curator commit 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' })
+
+const TARGET = 'gmem-target'
+const TARGET_ENTRY = {
+  track: 'memory', domain: 'general', title: '部署窗口约定',
+  content: '每周四凌晨两点到四点是固定的部署窗口，窗口内只允许灰度发布。',
+  confidence: 0.9, status: 'active',
+  createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-01-01T00:00:00.000Z',
+  evidence: [{ sessionId: 'old', quote: 'old quote' }],
+}
+
+function seedGlobalIndex(entries = {}) {
+  state.saveGlobalIndex({ version: 1, entries: structuredClone(entries) })
+}
+
+async function activateVectorGeneration() {
+  // In-memory stand-in for the sqlite vector store so the migration readback
+  // (syncShadow verifies committed items via listFiles) is faithful.
+  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 [] },
+    // membership() 的戳腿/账本腿读的是真实索引；这里直接转发到真 state.js。
+    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 }
+}
+
+test.after(async () => {
+  try { hooks.unregister?.() } catch {}
+  vp.resetCatalogEntryResolver()
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+const mergeOutput = {
+  memories: [{
+    op: 'merge', domain: 'general', track: 'memory', target_id: TARGET,
+    title: '部署窗口的合并版本',
+    content: '每周四凌晨两点到四点是固定的部署窗口，窗口内只允许灰度发布，全量要等监控确认。',
+    confidence: 0.9,
+    evidence: [{ session_id: 's1', quote: '部署窗口只在周四凌晨' }],
+  }],
+}
+
+test('a held clone from a target-changed conflict carries no vector stamp and membership counts neither it nor the committed id row', async () => {
+  seedGlobalIndex({ [TARGET]: TARGET_ENTRY })
+  const { migrator, generation } = await activateVectorGeneration()
+
+  // The concurrent writer lands while the curator is between its index read and
+  // its index write: the backend commit is the only async seam in between.
+  backend.onCommit = async () => {
+    state.updateGlobalIndex((fresh) => {
+      fresh.entries[TARGET] = { ...fresh.entries[TARGET], content: '内容已被并发修改', updatedAt: '2026-02-02T00:00:00.000Z' }
+    })
+  }
+  const result = await curator.commitCuratorOutput(structuredClone(mergeOutput), { job: { step: 'committing' } })
+  backend.onCommit = null
+
+  assert.equal(result.merged, 1, 'the merge update is still accounted as attempted')
+  assert.equal(result.files.length, 1)
+  const committedId = result.files[0].name
+  assert.deepEqual(backend.commits.map((call) => call.names), [[committedId]], 'the batch committed exactly the new id')
+
+  const index = state.loadGlobalIndex()
+  // The held clone got its own id; the committed id row is NOT in the index.
+  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')
+  assert.notEqual(heldId, committedId)
+  assert.equal(index.entries[committedId], undefined, 'the committed id must not land in the index when held')
+  const held = index.entries[heldId]
+  assert.equal(held.status, 'pending_review')
+  assert.equal(held.conflictingWith, TARGET)
+  // The regression: the clone spread `...entry` after the stamp loop stamped it.
+  assert.equal(Object.hasOwn(held, 'vector'), false, 'a held clone never entered the vector store, so it must not carry the stamp')
+  assert.equal(index.entries[TARGET].status, 'active', 'the untouched target is not superseded by a held clone')
+
+  // membership: the ledger leg keeps TARGET; the stamp leg admits the new
+  // create/update stamps only. Neither heldId (no stamp, not in ledger) nor the
+  // committed `id` (row exists in the backend, but not in the index) may appear.
+  const membership = migrator.membership()
+  assert.ok(membership, 'an active generation must produce a membership map')
+  const globalIds = membership.global || []
+  assert.ok(globalIds.includes(TARGET), 'the migrated target stays counted')
+  assert.ok(!globalIds.includes(heldId), 'the held clone is not counted as vector membership')
+  assert.ok(!globalIds.includes(committedId), 'the backend row `id` must not be attributed to the index it never landed in')
+})
+
+test('a clean create still carries the current-generation stamp and is counted by membership', async () => {
+  seedGlobalIndex({})
+  const { migrator, generation } = await activateVectorGeneration()
+  const output = {
+    memories: [{
+      op: 'create', domain: 'general', track: 'memory',
+      title: '独立的全新事实',
+      content: '用户倾向于在正式汇报里先给结论再给细节。',
+      confidence: 0.9,
+      evidence: [{ session_id: 's2', quote: '汇报时先给结论再讲细节' }],
+    }],
+  }
+  const result = await curator.commitCuratorOutput(output, { job: { step: 'committing' } })
+  assert.equal(result.created, 1)
+  const index = state.loadGlobalIndex()
+  const entry = Object.values(index.entries)[0]
+  assert.equal(entry.status, 'active')
+  assert.equal(entry.vector?.route, 'managed-local')
+  assert.equal(Number(entry.vector?.generation), generation, 'the stamp names the active generation')
+  const membership = migrator.membership()
+  assert.deepEqual(membership.global, [result.files[0].name])
+})
+
+test('a global-index write failure after the batch commit is compensated name by name and reported', async () => {
+  seedGlobalIndex({})
+  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: '第二条内容的原话记录' }] },
+    ],
+  }
+  indexHook.failNext = 1
+  await assert.rejects(
+    curator.commitCuratorOutput(structuredClone(output), { job: { step: 'committing' } }),
+    /disk full/,
+    'the original index error must surface, not the compensation result',
+  )
+  const committedNames = backend.commits.at(-1).names
+  assert.equal(committedNames.length, 2)
+  // Compensation: every committed name received a forget against the global db.
+  assert.deepEqual(
+    backend.forgets.map((call) => call.name).sort(),
+    [...committedNames].sort(),
+    'each just-committed name must be forgotten',
+  )
+  assert.ok(backend.forgets.every((call) => call.db === state.globalDbPath()))
+  // The index write failed, so nothing landed: the library must not gain entries
+  // and the curation failure stays the job's error.
+  assert.deepEqual(Object.keys(state.loadGlobalIndex().entries), [])
+  // The compensation outcome is visible in the activity log, not swallowed.
+  const event = activity.listEvents({ kind: 'curate' }).find((item) => item.level === 'error' || item.level === 'warn')
+  assert.ok(event, 'the compensation must be recorded')
+  assert.equal(event.ok, true, 'both names were compensated, so the record says so')
+  assert.deepEqual(event.detail.compensated.sort(), [...committedNames].sort())
+  assert.deepEqual(event.detail.failed, [])
+  assert.match(event.message, /回滚|补偿/)
+})
+
+test('a compensation failure is reported per name and never hides the original error', async () => {
+  seedGlobalIndex({})
+  await activateVectorGeneration()
+  // Make forget fail for the second name only: partial compensation must be
+  // recorded name by name.
+  const originalForget = globalThis.__curatorCommitTest.forget
+  const forgetBaseline = backend.forgets.length
+  globalThis.__curatorCommitTest.forget = async (args) => {
+    if (backend.forgets.length > forgetBaseline) throw new Error('engine db is locked')
+    return originalForget(args)
+  }
+  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: '乙条内容的原话记录' }] },
+    ],
+  }
+  indexHook.failNext = 1
+  await assert.rejects(
+    curator.commitCuratorOutput(structuredClone(output), { job: { step: 'committing' } }),
+    /disk full/,
+  )
+  globalThis.__curatorCommitTest.forget = originalForget
+  const event = activity.listEvents({ kind: 'curate' }).filter((item) => item.level === 'error').at(-1)
+  assert.ok(event, 'a partial compensation must be recorded at error level')
+  assert.equal(event.ok, false)
+  assert.equal(event.detail.compensated.length, 1, 'the name whose forget succeeded is recorded as compensated')
+  assert.equal(event.detail.failed.length, 1, 'the name whose forget failed is recorded with its reason')
+  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)
+})