dsh-memu-memory 1.2.1 → 1.2.2

package/tests/managed-runtime.test.mjs

@@ -17,6 +17,17 @@ test('managed Python discovery is pinned and all write directories stay inside e
   const binary = path.join(home, 'engine', 'runtime', `uv-${UV_VERSION}`, process.platform === 'win32' ? 'uv.exe' : 'uv')
   fs.mkdirSync(path.dirname(binary), { recursive: true })
   fs.writeFileSync(binary, 'fixture; never executed')
+  const assets = {
+    'win32-x64': ['uv-x86_64-pc-windows-msvc.zip', 'a2a8820d5eea32f08ef467ef3b7f66883a9b076d5737a2fc2fbb5f458d1bb50f'],
+    'win32-arm64': ['uv-aarch64-pc-windows-msvc.zip', 'c2426c0c8e28b53d8c440e47a18d96ad4db51e159866c0e81435b196d7f0081c'],
+    'linux-x64': ['uv-x86_64-unknown-linux-gnu.tar.gz', 'f29c3e94ffabd7e6f3ba521dba169a9b7ec12100bf3257087f0f24f6123f3645'],
+    'linux-arm64': ['uv-aarch64-unknown-linux-gnu.tar.gz', '229e194255c7958d86d56e8790d969a6f74736592133f0dfd0076f754c642c1d'],
+    'darwin-x64': ['uv-x86_64-apple-darwin.tar.gz', '63ba17fdda55ad1a230d4b37fc6017ffa10c23688c83818bd3bfdf914c652a02'],
+    'darwin-arm64': ['uv-aarch64-apple-darwin.tar.gz', '60fbd5c8a1ed681845eea28d9d622fcde03c51e91a43465b64a1e17db1ed3472'],
+  }
+  const asset = assets[process.platform + '-' + process.arch]
+  const fingerprint = crypto.createHash('sha256').update(fs.readFileSync(binary)).digest('hex')
+  fs.writeFileSync(path.join(path.dirname(binary), 'verified.json'), JSON.stringify({ version: UV_VERSION, archive: asset[0], archiveSha256: asset[1], executableBytes: fs.statSync(binary).size, executableSha256: fingerprint }))
   const python = path.join(home, 'engine', 'runtime', 'python', 'python.exe')
   fs.mkdirSync(path.dirname(python), { recursive: true })
   fs.writeFileSync(python, 'fixture')
@@ -33,6 +44,27 @@ test('managed Python discovery is pinned and all write directories stay inside e
   for (const call of calls) for (const key of ['UV_PYTHON_INSTALL_DIR', 'UV_CACHE_DIR', 'UV_PYTHON_BIN_DIR']) assert.ok(call.options.env[key].startsWith(path.join(home, 'engine')))
   assert.ok(calls.some(call => call.options.env.UV_PYTHON_PREFERENCE === 'only-managed' && call.args.includes('--no-python-downloads')))
 })
+test('tampered or legacy uv metadata is never executed', async () => {
+  const previousHome = process.env.DSH_MEMU_HOME
+  const isolated = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-runtime-tamper-'))
+  process.env.DSH_MEMU_HOME = isolated
+  try {
+    const binary = path.join(isolated, 'engine', 'runtime', `uv-${UV_VERSION}`, process.platform === 'win32' ? 'uv.exe' : 'uv')
+    fs.mkdirSync(path.dirname(binary), { recursive: true })
+    fs.writeFileSync(binary, 'trusted fixture')
+    fs.writeFileSync(path.join(path.dirname(binary), 'verified.json'), JSON.stringify({ version: UV_VERSION, archive: 'legacy', sha256: '0'.repeat(64) }))
+    let executed = false
+    await assert.rejects(ensureManagedPython({
+      run: async () => { executed = true; return { code: 0, stdout: `uv ${UV_VERSION}` } },
+      fetcher: async () => { throw new Error('replacement required') },
+    }), /replacement required/)
+    assert.equal(executed, false)
+  } finally {
+    process.env.DSH_MEMU_HOME = previousHome
+    fs.rmSync(isolated, { recursive: true, force: true })
+  }
+})
+
 test('a discovered interpreter outside the plugin directory is refused', async () => {
   await assert.rejects(ensureManagedPython({
     run: async (_cmd, args) => ({ code: 0, stdout: args[0] === '--version' ? `uv ${UV_VERSION}` : 'C:/outside/python.exe' }),

package/tests/private-links.test.mjs

@@ -0,0 +1,445 @@
+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'
+
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-private-links-'))
+process.env.DSH_MEMU_HOME = home
+process.env.DSH_MEMU_MEMORY_HOME = home
+
+const state = await import('../lib/state.js')
+const graph = await import('../lib/graph.js')
+const activity = await import('../lib/activity-log.js')
+const privateLinks = await import('../lib/private-links.js')
+const {
+  suggestPrivateLinks,
+  autoLinkPrivateMemories,
+  normalizeEntityName,
+  inferEntityKind,
+} = privateLinks
+
+test.after(() => {
+  try { state.flushState() } catch {}
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+const ZERO = { linked: 0, entities: 0, suggested: 0, candidates: [], autoLinked: [] }
+
+function entry(title, content, extra = {}) {
+  return { title, content, status: 'active', visibility: 'shared', layer: 'long_term', ...extra }
+}
+
+function snapshot(entries) {
+  return { version: 1, entries }
+}
+
+function bind(sessionId) {
+  return state.ensureSession(sessionId, { cwd: path.join(home, 'ws', sessionId), agentPreset: 'rp' })
+}
+
+function labels(pairs) {
+  return pairs.map(pair => `${pair.from}->${pair.to}`)
+}
+
+// ---- 纯函数：规范化 / 实体类型 ----
+
+test('normalizeEntityName folds case, width, whitespace and punctuation', () => {
+  assert.equal(normalizeEntityName('Yuike'), 'yuike')
+  assert.equal(normalizeEntityName(' Ｙｕｉｋｅ! '), 'yuike')
+  assert.equal(normalizeEntityName('yuike_01'), 'yuike01')
+  assert.equal(normalizeEntityName('Yuike-Chan'), 'yuikechan')
+  assert.equal(normalizeEntityName(''), '')
+})
+
+test('inferEntityKind: person cues win, Latin falls back to thing, CJK without cues stays uncertain', () => {
+  assert.equal(inferEntityKind([
+    { title: '猫娘yuike', content: '' },
+    { title: 'yuike名字的由来', content: '' },
+  ], 'yuike'), 'person')
+  assert.equal(inferEntityKind([
+    { title: 'nebula kickoff', content: 'a nebula survey starts at dawn' },
+  ], 'nebula'), 'thing')
+  assert.equal(inferEntityKind([
+    { title: '星港入口', content: '深夜的星港入口很冷' },
+  ], '星港'), null, 'a CJK token with no person cue must stay unresolved')
+})
+
+// ---- 纯函数：高置信直连 + 实体枢纽 ----
+
+test('yuike: a rare name-like pair is linked and becomes a person hub reused by case-insensitive name', () => {
+  const index = snapshot({
+    'mem-a': entry('猫娘yuike', 'yuike 是一只住在窗台的猫娘，喜欢在午后晒太阳。'),
+    'mem-b': entry('yuike名字的由来', '这个名字来自小时候养过的一只白猫，后来一直被沿用。'),
+  })
+  const result = suggestPrivateLinks({ index, ids: ['mem-a'] })
+  assert.equal(result.autoLinks.length, 1)
+  const link = result.autoLinks[0]
+  assert.equal(link.from, 'mem-a')
+  assert.equal(link.to, 'mem-b')
+  assert.equal(link.token, 'yuike')
+  assert.equal(link.nameLike, true)
+  assert.ok(link.confidence >= 0.6 && link.confidence <= 0.78, 'name-like confidence lives in the 0.6–0.78 band')
+  assert.deepEqual(labels(result.candidates), [], 'a resolved pair never appears in candidates')
+  assert.equal(result.entityHubs.length, 1)
+  const hub = result.entityHubs[0]
+  assert.equal(hub.token, 'yuike')
+  assert.equal(hub.name, 'yuike', 'display name keeps the original casing from the first title')
+  assert.equal(hub.kind, 'person')
+  assert.equal('entityId' in hub, false)
+  assert.deepEqual(new Set(hub.memoryIds), new Set(['mem-a', 'mem-b']))
+
+  const reused = suggestPrivateLinks({
+    index,
+    entities: [{ id: 'ent-yuike', name: 'Yuike', kind: 'person', aliases: [] }],
+    ids: ['mem-a'],
+  })
+  assert.equal(reused.entityHubs.length, 1)
+  assert.equal(reused.entityHubs[0].entityId, 'ent-yuike', 'a pre-existing Yuike entity is reused, not duplicated')
+  assert.equal(reused.autoLinks.length, 1)
+
+  const nfkc = suggestPrivateLinks({
+    index,
+    entities: [{ id: 'ent-yuike', name: 'Ｙｕｉｋｅ', kind: 'person', aliases: ['yuike-chan'] }],
+    ids: ['mem-a'],
+  })
+  assert.equal(nfkc.entityHubs[0].entityId, 'ent-yuike', 'NFKC + punctuation-insensitive name matching')
+})
+
+// ---- 纯函数：资格过滤 ----
+
+test('secret, archived, pending_review, other context, other track and invisible entries are filtered', () => {
+  bind('links-pure-filter')
+  const index = snapshot({
+    'mem-new': entry('yuike main', 'yuike 的第一条日常记录。'),
+    'mem-ok': entry('yuike friend', 'yuike 的第二条日常记录。'),
+    'mem-context': entry('yuike other', '别处的记录。', { context: { characterId: 'other' } }),
+    'mem-secret': entry('yuike secret', '秘密记录。', { visibility: 'secret' }),
+    'mem-archived': entry('yuike archived', '旧记录。', { status: 'archived' }),
+    'mem-pending': entry('yuike pending', '待复核记录。', { status: 'pending_review' }),
+    'mem-known': entry('yuike known', '只有某个角色知道的记录。', { context: { knownBy: ['someone-else'] } }),
+  })
+  const result = suggestPrivateLinks({ index, ids: ['mem-new'], sessionId: 'links-pure-filter' })
+  assert.deepEqual(labels(result.autoLinks), ['mem-new->mem-ok'])
+  assert.equal(result.entityHubs.length, 1)
+  assert.deepEqual(new Set(result.entityHubs[0].memoryIds), new Set(['mem-new', 'mem-ok']))
+  assert.deepEqual(result.candidates, [])
+  const seen = JSON.stringify(result)
+  for (const excluded of ['mem-context', 'mem-secret', 'mem-archived', 'mem-pending', 'mem-known']) {
+    assert.ok(!seen.includes(excluded), `${excluded} must not appear anywhere in the suggestions`)
+  }
+})
+
+test('a shared token is never linked across tracks', () => {
+  const index = snapshot({
+    'mem-track-a': entry('yuike main', 'yuike 的第一条日常记录。'),
+    'mem-track-b': entry('yuike habit', 'yuike 的习惯记录。', { track: 'habit' }),
+  })
+  const result = suggestPrivateLinks({ index, ids: ['mem-track-a'] })
+  assert.deepEqual(result.autoLinks, [])
+  assert.deepEqual(result.candidates, [])
+  assert.deepEqual(result.entityHubs, [], 'groups are also partitioned by track')
+})
+
+// ---- 纯函数：重复 / 冲突 / 已有 link ----
+
+test('pairScore >= 0.82, findConflict hits and existing relation/person links skip the pair', () => {
+  // Duplicate band: identical title + body is a merge problem, not a link.
+  const duplicate = snapshot({
+    'mem-dup-a': entry('yuike profile', 'yuike lives by the window and naps in the afternoon sun every single day.'),
+    'mem-dup-b': entry('yuike profile', 'yuike lives by the window and naps in the afternoon sun every single day.'),
+  })
+  const dupResult = suggestPrivateLinks({ index: duplicate, ids: ['mem-dup-a'] })
+  assert.deepEqual(labels(dupResult.autoLinks), [])
+  assert.deepEqual(labels(dupResult.candidates), [])
+
+  // Conflict: same title but contradictory bodies (findConflict same_title).
+  const conflict = snapshot({
+    'mem-cf-a': entry('yuike setting', 'yuike 喜欢在雨天沿着河堤散步。'),
+    'mem-cf-b': entry('yuike setting', 'yuike 讨厌所有甜食和奶油蛋糕。'),
+  })
+  const cfResult = suggestPrivateLinks({ index: conflict, ids: ['mem-cf-a'] })
+  assert.deepEqual(labels(cfResult.autoLinks), [])
+  assert.deepEqual(labels(cfResult.candidates), [])
+
+  // Existing relation link from the new entry: idempotent.
+  const forward = snapshot({
+    'mem-lk-a': entry('yuike linked', 'yuike 的第一条记录。', {
+      links: [{ to: 'mem-lk-b', kind: 'relation', note: 'already linked by an earlier pass', confidence: 0.7 }],
+    }),
+    'mem-lk-b': entry('yuike partner', 'yuike 的第二条记录。'),
+  })
+  const fwResult = suggestPrivateLinks({ index: forward, ids: ['mem-lk-a'] })
+  assert.deepEqual(labels(fwResult.autoLinks), [])
+  assert.deepEqual(labels(fwResult.candidates), [])
+
+  // Existing link in the OTHER direction must also block the pair.
+  const backward = snapshot({
+    'mem-rv-a': entry('yuike reverse', 'yuike 的第一条记录。'),
+    'mem-rv-b': entry('yuike reverse partner', 'yuike 的第二条记录。', {
+      links: [{ to: 'mem-rv-a', kind: 'relation', note: 'already linked by an earlier pass', confidence: 0.7 }],
+    }),
+  })
+  const rvResult = suggestPrivateLinks({ index: backward, ids: ['mem-rv-a'] })
+  assert.deepEqual(labels(rvResult.autoLinks), [])
+  assert.deepEqual(labels(rvResult.candidates), [])
+})
+
+// ---- 纯函数：停用词 ----
+
+test('stopword-only title overlaps never auto-link and never become candidates', () => {
+  const index = snapshot({
+    'mem-sw-a': entry('记忆的名字', '窗台上的灰尘积了很厚。'),
+    'mem-sw-b': entry('名字的记忆', '码头今天停了三艘货轮。'),
+  })
+  const result = suggestPrivateLinks({ index, ids: ['mem-sw-a'] })
+  assert.deepEqual(result.autoLinks, [])
+  assert.deepEqual(result.candidates, [])
+  assert.deepEqual(result.entityHubs, [])
+})
+
+// ---- 纯函数：上限 ----
+
+test('perEntry, total, maxCandidates and maxEntities caps hold', () => {
+  const index = snapshot({
+    'mem-new-1': entry('alpha bravo', 'alpha survey starts at dawn.'),
+    'mem-new-2': entry('charlie delta', 'charlie survey ends at dusk.'),
+    'mem-old-a': entry('alpha archive', 'archive of the alpha survey.'),
+    'mem-old-b': entry('bravo archive', 'archive of the bravo survey.'),
+    'mem-old-c': entry('charlie archive', 'archive of the charlie survey.'),
+    'mem-old-d': entry('delta archive', 'archive of the delta survey.'),
+  })
+  const ids = ['mem-new-1', 'mem-new-2']
+  const withDefaults = suggestPrivateLinks({ index, ids, maxEntities: 4 })
+  assert.equal(withDefaults.autoLinks.length, 4)
+  assert.equal(withDefaults.autoLinks.filter(link => link.from === 'mem-new-1').length, 2)
+  assert.equal(withDefaults.autoLinks.filter(link => link.from === 'mem-new-2').length, 2)
+  assert.equal(withDefaults.entityHubs.length, 4)
+
+  const perEntry = suggestPrivateLinks({ index, ids, perEntry: 1, maxEntities: 4 })
+  assert.equal(perEntry.autoLinks.length, 2)
+  assert.equal(perEntry.autoLinks.filter(link => link.from === 'mem-new-1').length, 1)
+  assert.equal(perEntry.autoLinks.filter(link => link.from === 'mem-new-2').length, 1)
+
+  const total = suggestPrivateLinks({ index, ids, total: 3, maxEntities: 4 })
+  assert.equal(total.autoLinks.length, 3)
+
+  const entities = suggestPrivateLinks({ index, ids, maxEntities: 2 })
+  assert.equal(entities.entityHubs.length, 2)
+
+  // Candidates are capped too, highest score first. Unresolved CJK hubs are the
+  // uncertain kind, so three pairs yield three candidates.
+  const uncertain = snapshot({
+    'mem-u1': entry('星港入口', '深夜的星港入口很冷，风从闸门缝里灌进来。'),
+    'mem-u2': entry('星港记录', '档案室的旧星港记录已经泛黄，编号从三年前开始。'),
+    'mem-v1': entry('雾谷入口', '清晨的雾谷入口很安静，石阶上还挂着水珠。'),
+    'mem-v2': entry('雾谷记录', '旧册子里的雾谷记录被虫蛀了一角，字迹模糊。'),
+    'mem-w1': entry('白塔入口', '黄昏的白塔入口被藤蔓遮住，门锁已经锈死。'),
+    'mem-w2': entry('白塔记录', '白塔记录停在二十年前，最后一页没有落款。'),
+  })
+  const all = suggestPrivateLinks({ index: uncertain, ids: ['mem-u1', 'mem-v1', 'mem-w1'] })
+  assert.equal(all.candidates.length, 3)
+  assert.equal(all.autoLinks.length, 0)
+  assert.equal(all.entityHubs.length, 0)
+  const capped = suggestPrivateLinks({ index: uncertain, ids: ['mem-u1', 'mem-v1', 'mem-w1'], maxCandidates: 2 })
+  assert.equal(capped.candidates.length, 2)
+  assert.ok(capped.candidates[0].score >= capped.candidates[1].score, 'highest score is preferred')
+})
+
+// ---- 纯函数：不确定实体类型 / thing / kind 冲突 ----
+
+test('CJK name-like token without a person cue is an uncertain candidate, not a hub', () => {
+  const index = snapshot({
+    'mem-a': entry('星港入口', '深夜的星港入口很冷，风从闸门缝里灌进来。'),
+    'mem-b': entry('星港记录', '档案室的旧星港记录已经泛黄，编号从三年前开始。'),
+  })
+  const result = suggestPrivateLinks({ index, ids: ['mem-a'] })
+  assert.deepEqual(result.autoLinks, [], 'an unresolved entity kind does not auto-link')
+  assert.deepEqual(result.entityHubs, [], 'a CJK token without a person cue never auto-creates a hub')
+  assert.equal(result.candidates.length, 1)
+  const candidate = result.candidates[0]
+  assert.deepEqual(Object.keys(candidate).sort(), ['from', 'preview', 'score', 'sharedToken', 'suggestedEntity', 'title', 'to'])
+  assert.equal(candidate.from, 'mem-a')
+  assert.equal(candidate.to, 'mem-b')
+  assert.equal(candidate.sharedToken, '星港')
+  assert.deepEqual(candidate.suggestedEntity, { name: '星港', kind: null })
+  assert.equal(candidate.title, '星港记录', 'title/preview describe the OTHER memory')
+  assert.equal(candidate.preview, '档案室的旧星港记录已经泛黄，编号从三年前开始。')
+  assert.ok(candidate.title.length <= 80)
+  assert.ok(candidate.preview.length <= 120)
+})
+
+test('a Latin name-like token without a person cue becomes a thing hub', () => {
+  const index = snapshot({
+    'mem-c': entry('nebula kickoff', 'the nebula survey starts at dawn near the outer ring.'),
+    'mem-d': entry('nebula notes', 'a nebula chart was folded inside the old folder.'),
+  })
+  const result = suggestPrivateLinks({ index, ids: ['mem-c'] })
+  assert.equal(result.autoLinks.length, 1)
+  assert.equal(result.entityHubs.length, 1)
+  assert.equal(result.entityHubs[0].kind, 'thing')
+  assert.equal(result.entityHubs[0].name, 'nebula')
+  assert.deepEqual(result.candidates, [])
+})
+
+test('an existing entity with a conflicting kind blocks the auto-link and becomes an uncertain candidate', () => {
+  const index = snapshot({
+    'mem-c': entry('nebula kickoff', 'the nebula survey starts at dawn near the outer ring.'),
+    'mem-d': entry('nebula notes', 'a nebula chart was folded inside the old folder.'),
+  })
+  const result = suggestPrivateLinks({
+    index,
+    entities: [{ id: 'ent-nebula', name: 'NEBULA', kind: 'person', aliases: [] }],
+    ids: ['mem-c'],
+  })
+  assert.deepEqual(result.autoLinks, [])
+  assert.deepEqual(result.entityHubs, [])
+  assert.equal(result.candidates.length, 1)
+  assert.equal(result.candidates[0].sharedToken, 'nebula')
+  assert.deepEqual(result.candidates[0].suggestedEntity, { name: 'nebula', kind: 'thing' })
+})
+
+// ---- 应用层 ----
+
+test('autoLinkPrivateMemories applies the link, reuses Yuike and is idempotent', async () => {
+  activity.clearEvents()
+  const binding = bind('links-apply')
+  const libraryId = binding.libraryId
+  const yuike = graph.createEntity({ libraryId, name: 'Yuike', kind: 'person' })
+  state.savePrivateIndex(libraryId, snapshot({
+    'mem-a': entry('猫娘yuike', 'yuike 是一只住在窗台的猫娘，喜欢在午后晒太阳。'),
+    'mem-b': entry('yuike名字的由来', '这个名字来自小时候养过的一只白猫，后来一直被沿用。'),
+  }))
+
+  const result = await autoLinkPrivateMemories({ libraryId, sessionId: 'links-apply', ids: ['mem-a'] })
+  assert.equal(result.linked, 1)
+  assert.equal(result.entities, 2)
+  assert.equal(result.suggested, 0)
+  assert.deepEqual(result.candidates, [])
+  // The compact return the worker tool forwards: edges only, no bodies or notes, and
+  // one entry per write (the memory pair first, then both hub links).
+  assert.deepEqual(result.autoLinked.map(item => `${item.from}->${item.to}:${item.kind}`), [
+    'mem-a->mem-b:relation',
+    `mem-a->${yuike.id}:person`,
+    `mem-b->${yuike.id}:person`,
+  ])
+  for (const item of result.autoLinked) assert.deepEqual(Object.keys(item).sort(), ['from', 'kind', 'to'])
+
+  const index = state.loadPrivateIndex(libraryId)
+  const outbound = index.entries['mem-a'].links || []
+  const memoryLink = outbound.find(link => link.to === 'mem-b')
+  assert.ok(memoryLink, 'the high-confidence memory link is persisted')
+  assert.equal(memoryLink.kind, 'relation')
+  assert.equal(memoryLink.source, 'auto', 'the auto source is persisted on the link record')
+  assert.match(memoryLink.note, /自动关联/)
+  assert.match(memoryLink.note, /yuike/)
+  assert.ok(memoryLink.confidence >= 0.6 && memoryLink.confidence <= 0.78)
+  const entityLink = outbound.find(link => link.to === yuike.id)
+  assert.ok(entityLink, 'the memory links to the reused entity hub')
+  assert.equal(entityLink.kind, 'person')
+  assert.equal(entityLink.source, 'auto')
+  assert.match(entityLink.note, /自动实体枢纽/)
+  assert.equal(entityLink.confidence, 0.65)
+  assert.ok((index.entries['mem-b'].links || []).some(link => link.to === yuike.id),
+    'every memory sharing the stable name is linked to the hub')
+
+  const entities = Object.values(graph.graphExport(libraryId).entities)
+  assert.equal(entities.length, 1, 'Yuike is reused, not duplicated as yuike')
+  assert.equal(entities[0].id, yuike.id)
+
+  const events = activity.listEvents({ kind: 'write', sessionId: 'links-apply' })
+  const linkEvent = events.find(event => event.detail?.op === 'auto-link' && event.ok)
+  const entityEvents = events.filter(event => event.detail?.op === 'auto-entity' && event.ok)
+  assert.ok(linkEvent, 'the applied link is recorded in the activity log')
+  assert.equal(linkEvent.detail.source, 'auto', 'source travels through the apply layer')
+  assert.deepEqual(new Set(linkEvent.refs), new Set(['mem-a', 'mem-b']))
+  assert.equal(entityEvents.length, 2)
+  assert.ok(entityEvents.every(event => event.detail.source === 'auto'))
+  assert.ok(entityEvents.every(event => event.detail.kind === 'person'))
+
+  activity.clearEvents()
+  const again = await autoLinkPrivateMemories({ libraryId, sessionId: 'links-apply', ids: ['mem-a'] })
+  assert.equal(again.linked, 0, 'an existing relation link makes the pair idempotent')
+  assert.equal(again.entities, 0, 'a memory already linked to the entity is skipped')
+  const after = state.loadPrivateIndex(libraryId)
+  assert.equal((after.entries['mem-a'].links || []).filter(link => link.to === 'mem-b').length, 1)
+  assert.equal((after.entries['mem-a'].links || []).filter(link => link.to === yuike.id).length, 1)
+})
+
+test('autoLinkPrivateMemories links a thing hub with kind relation', async () => {
+  activity.clearEvents()
+  const binding = bind('links-thing')
+  const libraryId = binding.libraryId
+  state.savePrivateIndex(libraryId, snapshot({
+    'mem-c': entry('nebula kickoff', 'the nebula survey starts at dawn near the outer ring.'),
+    'mem-d': entry('nebula notes', 'a nebula chart was folded inside the old folder.'),
+  }))
+  const result = await autoLinkPrivateMemories({ libraryId, sessionId: 'links-thing', ids: ['mem-c'] })
+  assert.equal(result.linked, 1)
+  assert.equal(result.entities, 2)
+  const entity = Object.values(graph.graphExport(libraryId).entities)
+    .find(item => normalizeEntityName(item.name) === 'nebula')
+  assert.ok(entity)
+  assert.equal(entity.kind, 'thing')
+  const index = state.loadPrivateIndex(libraryId)
+  const link = (index.entries['mem-c'].links || []).find(item => item.to === entity.id)
+  assert.ok(link)
+  assert.equal(link.kind, 'relation', 'non-person hubs use kind relation')
+})
+
+test('autoLinkPrivateMemories never throws on a missing or broken index and logs a warning path', async () => {
+  activity.clearEvents()
+  // Missing index: an empty library is a no-op, not a failure.
+  const missing = bind('links-missing')
+  assert.deepEqual(
+    await autoLinkPrivateMemories({ libraryId: missing.libraryId, sessionId: 'links-missing', ids: ['mem-none'] }),
+    ZERO,
+  )
+  // Unknown library: the top-level load must be caught.
+  assert.deepEqual(
+    await autoLinkPrivateMemories({ libraryId: 'no-such-library', sessionId: 'links-missing', ids: ['mem-none'] }),
+    ZERO,
+  )
+  // Invalid library id reaches loadPrivateIndex's own guard.
+  assert.deepEqual(
+    await autoLinkPrivateMemories({ libraryId: '../escape', sessionId: 'links-missing', ids: ['mem-a'] }),
+    ZERO,
+  )
+  // Corrupt entity store fails listEntities AFTER the index loaded; nothing is written.
+  const broken = bind('links-broken')
+  state.savePrivateIndex(broken.libraryId, snapshot({
+    'mem-a': entry('yuike one', 'yuike 的第一条日常记录。'),
+    'mem-b': entry('yuike two', 'yuike 的第二条日常记录。'),
+  }))
+  fs.mkdirSync(path.join(home, 'index'), { recursive: true })
+  fs.writeFileSync(path.join(home, 'index', `${broken.libraryId}.entities.json`), '{not json', 'utf8')
+  assert.deepEqual(
+    await autoLinkPrivateMemories({ libraryId: broken.libraryId, sessionId: 'links-broken', ids: ['mem-a'] }),
+    ZERO,
+  )
+  assert.equal(state.loadPrivateIndex(broken.libraryId).entries['mem-a'].links, undefined, 'a failed pass writes nothing')
+  const warnings = activity.listEvents({ kind: 'write', level: 'warn' })
+  assert.ok(warnings.length >= 2, 'each top-level failure leaves a warning row')
+  assert.ok(warnings.some(event => event.detail?.op === 'auto-link'))
+  assert.ok(warnings.some(event => /unknown library|invalid library id|cannot read entity store/.test(event.message)))
+  fs.rmSync(path.join(home, 'index', `${broken.libraryId}.entities.json`), { force: true })
+
+  // No ids: zero without writes or log noise.
+  const before = activity.listEvents({ kind: 'write' }).length
+  assert.deepEqual(
+    await autoLinkPrivateMemories({ libraryId: broken.libraryId, sessionId: 'links-broken' }),
+    ZERO,
+  )
+  assert.deepEqual(
+    await autoLinkPrivateMemories({ libraryId: broken.libraryId, sessionId: 'links-broken', ids: [] }),
+    ZERO,
+  )
+  assert.equal(activity.listEvents({ kind: 'write' }).length, before, 'no ids means no work and no log row')
+})
+
+test('the default export exposes the whole module surface', () => {
+  assert.equal(privateLinks.default.suggestPrivateLinks, suggestPrivateLinks)
+  assert.equal(privateLinks.default.autoLinkPrivateMemories, autoLinkPrivateMemories)
+  assert.equal(privateLinks.default.normalizeEntityName, normalizeEntityName)
+  assert.equal(privateLinks.default.inferEntityKind, inferEntityKind)
+})

package/tests/prompts.test.mjs

@@ -199,6 +199,41 @@ test('domain defaults distinguish engineering evidence, character continuity and
   assert.match(curator, /前置条件、适用版本与验证边界/)
 })
 
+test('title guidance ships in every consolidation page; tool workflow lives in the worker brief and the remote contract stays tool-free', async () => {
+  for (const domain of ['general', 'coding', 'rp', 'mixed']) {
+    const key = domain === 'general' ? 'private-consolidation' : `private-consolidation.${domain}`
+    const text = prompts.getPromptState(key).defaultText
+    assert.match(text, /8–40 字/, `${key}: title length rule`)
+    assert.match(text, /目录项/, `${key}: the title is the directory entry`)
+    assert.match(text, /覆盖来源的关键词/, `${key}: a merged title covers every source`)
+    assert.match(text, /没有正文|不显示正文/, `${key}: the anchor omits bodies`)
+    assert.match(text, /可抽词典词/, `${key}: the shared body still says what vocabulary is worth extracting`)
+    assert.doesNotMatch(text, /召唤/, `${key}: the typo must not return`)
+    // The domain body is shared with the remote JSON path, which has no tools at
+    // all. Tool calls belong in the local worker brief, not here.
+    assert.doesNotMatch(text, /memu_lexicon|memu_private_link|memu_private_remember|memu_private_update/, `${key}: no tool workflow in the shared body`)
+  }
+  const curator = prompts.getPromptState('global-curator').defaultText
+  assert.match(curator, /标题即目录/)
+  assert.match(curator, /8–40 字/)
+  assert.match(curator, /覆盖所有来源的关键词/)
+  // The JSON schema is unchanged: title is still a plain optional string field.
+  assert.match(curator, /"title":"\.\.\."/)
+
+  const { buildWorkerBrief } = await import('../lib/consolidation-worker.js')
+  const brief = buildWorkerBrief({ snapshot: { fromSeq: 1, throughSeq: 2, eventCount: 2, hash: 'prompt-test' }, probe: null, contract: '' })
+  for (const rule of [/memu_lexicon_search/, /memu_lexicon_propose/, /term 是索引键/, /sensitive trigger/, /memu_private_link_suggest/, /noop/, /conflict/, /最多确认 5 条/]) {
+    assert.match(brief, rule, 'the local worker brief owns the tool workflow')
+  }
+  assert.match(prompts.CONSOLIDATION_CONTRACTS.remote, /8-40字/, 'the remote JSON contract uses the same title length')
+  assert.doesNotMatch(prompts.CONSOLIDATION_CONTRACTS.remote, /memu_lexicon|memu_private_link/, 'the remote contract promises no tools')
+  for (const domain of ['general', 'coding', 'rp', 'mixed']) {
+    const assembled = prompts.loadPromptForDomain('private-consolidation', { libraryName: 'x', domain, mustRememberCap: 16 }, domain).text
+      + '\n' + prompts.CONSOLIDATION_CONTRACTS.remote
+    assert.doesNotMatch(assembled, /memu_/, `${domain}: the remote prompt must not mention tools`)
+  }
+})
+
 test('all shipped template variables are declared and fully rendered, with bounded resident guidance', () => {
   const vars = { mustRememberCap: 16, unpinBudget: 2, shortTermTtlHours: 48, anchorTokens: 700, turnTokens: 500,
     libraryName: 'test-library', domain: 'coding', input: '{"sessions":[]}' }

package/tests/recall-dedup.test.mjs

@@ -135,18 +135,21 @@ test('the same fact arriving on both legs is folded once, keeping the highest-rr
   assert.deepEqual(fused.debug.collapsed, [{ kept: 'mem-dup1', dropped: ['mem-dup3'] }])
 })
 
-test('a write with dice ≈ 0.93 is refused as a duplicate and the library does not grow', async () => {
+test('a write with dice ≈ 0.93 is held as a near_duplicate instead of being lost', async () => {
   const f = fixture()
   const first = await memory.privateRemember({ exec: f.exec, title: '部署窗口约定', content: BODY_A })
   const measured = similarity.dice(similarity.bigrams('部署窗口的约定 ' + BODY_A), similarity.bigrams('部署窗口约定 ' + BODY_A))
   assert.ok(measured >= 0.90, 'fixture pair must sit in the reject band, got ' + measured)
   const second = await memory.privateRemember({ exec: f.exec, title: '部署窗口的约定', content: BODY_A })
   assert.equal(second.deduped, true)
+  assert.equal(second.pending, true)
   assert.equal(second.existingId, first.id)
   assert.match(second.hint, /memu_private_update/)
   const index = state.loadPrivateIndex(f.libraryId)
-  assert.equal(Object.keys(index.entries).length, 1, 'the duplicate write must not land in the library')
-  assert.equal(index.entries[first.id].content, BODY_A, 'the original must be untouched')
+  assert.equal(Object.keys(index.entries).length, 2, 'the new text is held, not silently dropped')
+  assert.equal(index.entries[second.id].status, 'pending_review')
+  assert.equal(index.entries[second.id].reviewReason, 'near_duplicate')
+  assert.equal(index.entries[first.id].status, 'active', 'the original must be untouched')
   const written = activity.listEvents({ kind: 'write' })[0]
   assert.match(written.message, /拒绝重复写入/)
   assert.equal(written.detail.existingId, first.id)
@@ -203,10 +206,13 @@ test('a short memory padded into a much longer rewrite is refused, not slipped p
   assert.ok(similarity.lengthGap(unit1, unit2) > similarity.LENGTH_PRUNE_RATIO, 'the pair must sit in the pruned band')
   const second = await memory.privateRemember({ exec: f.exec, content: padded })
   assert.equal(second.deduped, true)
+  assert.equal(second.pending, true)
   assert.equal(second.existingId, first.id)
   assert.ok(second.similarity >= similarity.DUP_REJECT_DICE, 'the probe floor lands in the reject band, got ' + second.similarity)
   const index = state.loadPrivateIndex(f.libraryId)
-  assert.equal(Object.keys(index.entries).length, 1, 'the padded rewrite must not land in the library')
+  assert.equal(Object.keys(index.entries).length, 2, 'the padded rewrite is held for review, not written active')
+  assert.equal(index.entries[second.id].status, 'pending_review')
+  assert.equal(index.entries[second.id].reviewReason, 'near_duplicate')
 })
 
 test('a genuinely different longer fact against a short entry is still written', async () => {
@@ -220,6 +226,29 @@ test('a genuinely different longer fact against a short entry is still written',
   assert.equal(Object.keys(index.entries).length, 2)
 })
 
+test('a knownBy-hidden near-duplicate never leaks its id', async () => {
+  const f = fixture()
+  state.setSessionBinding(f.sessionId, { memoryContext: { characterId: 'hero', knownBy: ['someone-else'] } })
+  const first = await memory.privateRemember({
+    exec: f.exec, title: '隐藏部署甲', content: BODY_A,
+    context: { characterId: 'hero', knownBy: ['someone-else'] },
+  })
+  const second = await memory.privateRemember({
+    exec: f.exec, title: '隐藏部署乙', content: BODY_A.replace('灰度发布', '白名单发布'),
+    context: { characterId: 'hero', knownBy: ['someone-else'] },
+  })
+  assert.equal(second.deduped, true)
+  assert.equal(second.pending, true)
+  assert.equal(second.existingId, undefined, 'a hidden duplicate must not expose its id')
+  assert.equal(second.similarity, undefined, 'a hidden duplicate must not expose its similarity')
+  assert.equal(second.similarityBand, '0.90+')
+  const index = state.loadPrivateIndex(f.libraryId)
+  assert.equal(memory.visibleToSession(index.entries[first.id], f.sessionId), false)
+  assert.equal(index.entries[second.id].status, 'pending_review')
+  assert.equal(index.entries[second.id].reviewReason, 'near_duplicate')
+  assert.equal(index.entries[second.id].conflictingWith, null, 'the hidden id must not be written into the held entry')
+})
+
 test('allowDuplicate: true writes a second independent observation without a tag', async () => {
   const f = fixture()
   const first = await memory.privateRemember({ exec: f.exec, title: '部署窗口约定', content: BODY_A })

package/tests/tool-schema.test.mjs

@@ -68,6 +68,6 @@ test('the shipped tool surface compiles under the host rules', async () => {
     tools: { register: (tool) => { registered.push(tool.name); return () => {} } },
     logger: { warn: (message) => { throw new Error(`unexpected registration warning: ${message}`) } },
   })
-  assert.equal(registered.length, 10, `registered ${registered.join(', ')}`)
+  assert.equal(registered.length, 13, `registered ${registered.join(', ')}`)
   dispose()
 })