dsh-memu-memory 1.2.1 → 1.2.2

package/tests/fixtures/lexicon-stub.mjs

@@ -0,0 +1,284 @@
+// 集成回归时移除：lib/lexicon.js 真身落地后，删除本文件、lexicon-stub-hooks.mjs 以及
+// tests/lexicon-ui.test.mjs 顶部的 register 调用。
+//
+// 轻量替身：只覆盖 P3 消费的冻结签名与四条语义——非用户来源的普通词条直接 active、
+// sensitive trigger 的模型/curator 提案 typed rejection、非用户改敏感字段 typed
+// rejection、active/archived 生命周期（archive/restore）。不承诺与真核心一致的锁、
+// CAS、原子写或容量上限；真实文件落在 dataDir()/lexicon/ 下，因此备份清单与 restore
+// allowlist 测试仍然走真实磁盘。
+import path from 'node:path'
+import { dataDir, ensureDir, readJson, writeJson } from '../../lib/paths.js'
+
+const KINDS = ['slang', 'meme', 'trigger', 'term']
+// 公开生命周期（§2.1）：pending/rejected 只作为 legacy/墓碑数据存在，新写不产出。
+const PUBLIC_STATUSES = ['active', 'archived']
+const SENSITIVE_FIELDS = ['term', 'kind', 'sensitivity', 'context', 'meaning']
+// 与设计 §1.2 同向的近似规范化：NFKC、大小写折叠、空白折叠、去标点/符号。
+const normalizeLexeme = (value) => String(value ?? '')
+  .normalize('NFKC')
+  .toLowerCase()
+  .replace(/\s+/g, ' ')
+  .replace(/[\p{P}\p{S}]+/gu, '')
+  .trim()
+
+const fileFor = (libraryId) => path.join(dataDir(), 'lexicon', `${libraryId}.json`)
+const emptyStore = (libraryId) => ({ version: 1, revision: 0, libraryId, terms: {}, rejected: {} })
+
+export function loadLexicon(libraryId) {
+  const raw = readJson(fileFor(libraryId), null)
+  if (!raw || typeof raw !== 'object' || raw.terms == null) return emptyStore(libraryId)
+  return {
+    version: 1,
+    revision: Number(raw.revision) || 0,
+    libraryId,
+    terms: raw.terms && typeof raw.terms === 'object' ? raw.terms : {},
+    rejected: raw.rejected && typeof raw.rejected === 'object' ? raw.rejected : {},
+  }
+}
+
+function saveLexicon(store) {
+  ensureDir(path.dirname(fileFor(store.libraryId)))
+  writeJson(fileFor(store.libraryId), {
+    version: store.version,
+    revision: store.revision,
+    libraryId: store.libraryId,
+    terms: store.terms,
+    rejected: store.rejected || {},
+  })
+}
+
+function fail(code, message) {
+  const error = new Error(message)
+  error.code = code
+  return error
+}
+
+// 与 lib/context.js 的 contextVisible 同语义的精简版：P3 只依赖"越界条目搜不到"。
+function contextVisible(context, current) {
+  if (!context) return true
+  for (const key of ['channelId', 'characterId', 'worldId', 'branchId']) {
+    if (context[key] && context[key] !== current?.[key]) return false
+  }
+  if (Array.isArray(context.knownBy) && context.knownBy.length && !context.knownBy.includes(current?.characterId)) return false
+  return true
+}
+
+let seq = 0
+const nextId = () => {
+  seq += 1
+  return `lex-stub-${String(seq).padStart(4, '0')}`
+}
+
+function sensitiveDelta(existing, next) {
+  return SENSITIVE_FIELDS.filter((field) => {
+    const before = field === 'context' ? JSON.stringify(existing.context || {}) : String(existing[field] ?? '')
+    const after = field === 'context' ? JSON.stringify(next.context || {}) : String(next[field] ?? '')
+    return before !== after
+  })
+}
+
+/**
+ * 写入/更新：与真核心同一套公开语义（§2.1）。created:false + notOwned:true 表示
+ * 撞上了一条非用户来源不能动的词条（archived/rejected/legacy 修订草稿）。
+ */
+export function upsertLexiconTerm(options = {}) {
+  const libraryId = String(options.libraryId || '')
+  if (!libraryId) throw fail('LEXICON_LIBRARY_REQUIRED', 'libraryId is required')
+  const term = String(options.term || '').trim()
+  const kind = String(options.kind || 'term')
+  const meaning = String(options.meaning || '').trim()
+  if (!term) throw fail('LEXICON_TERM_REQUIRED', 'term is required')
+  if (!meaning) throw fail('LEXICON_MEANING_REQUIRED', 'meaning is required')
+  if (!KINDS.includes(kind)) throw fail('LEXICON_KIND_INVALID', `unknown lexicon kind: ${kind}`)
+  const source = String(options.source || 'user')
+  const isUser = source === 'user'
+  // trigger 默认 sensitive（§1.2）。
+  const sensitivity = kind === 'trigger' && options.sensitivity == null ? 'sensitive' : String(options.sensitivity || 'normal')
+  // §2.1：非用户来源不能建 sensitive trigger —— typed rejection。
+  if (!isUser && kind === 'trigger' && sensitivity === 'sensitive') {
+    throw fail('LEXICON_SENSITIVE_FORBIDDEN', 'sensitive triggers are user-managed; model/curator proposals are rejected')
+  }
+  // pending/rejected 不可由新调用方设置：统一收口成 active（非用户来源也不可设 archived）。
+  const requested = PUBLIC_STATUSES.includes(String(options.status)) ? String(options.status) : 'active'
+  const wantedStatus = isUser ? requested : 'active'
+
+  const store = loadLexicon(libraryId)
+  const normalizedTerm = normalizeLexeme(term)
+  const aliases = Array.isArray(options.aliases) ? options.aliases.map((a) => String(a)) : []
+  const normalizedAliases = aliases.map(normalizeLexeme).filter(Boolean)
+  const context = options.context && typeof options.context === 'object' ? { ...options.context } : {}
+  const now = new Date().toISOString()
+  // 冲突：同一规范词（term 或 alias）已存在时更新既有词条，不新建（§1.2 唯一性）。
+  // 归档条目按 term 等值参与（includeArchived 口径）。
+  let targetId = null
+  for (const [id, e] of Object.entries(store.terms)) {
+    const status = e?.status || 'active'
+    const normalizedEntryTerm = normalizeLexeme(e?.term)
+    if (status === 'archived') {
+      if (normalizedEntryTerm === normalizedTerm) { targetId = id; break }
+      continue
+    }
+    const keys = new Set([normalizedEntryTerm, ...(Array.isArray(e?.normalizedAliases) ? e.normalizedAliases : []).map((a) => String(a).toLowerCase())])
+    if (keys.has(normalizedTerm) || normalizedAliases.some((a) => keys.has(a))) { targetId = id; break }
+  }
+  const created = targetId === null
+  let revived = false
+  if (!created) {
+    const e = store.terms[targetId]
+    const status = e.status || 'active'
+    // archived / rejected / legacy 修订草稿：非用户来源不复活、不改写。
+    const immutable = status === 'archived' || status === 'rejected' || (status === 'pending' && Boolean(e.revisionOf))
+    if (immutable && !isUser) return { term: e, termId: targetId, created: false, notOwned: true }
+    if (!isUser) {
+      if (e.kind === 'trigger' && e.sensitivity === 'sensitive') {
+        throw fail('LEXICON_SENSITIVE_FIELDS_FORBIDDEN', 'only the user manages sensitive triggers')
+      }
+      const changed = sensitiveDelta(e, { ...e, term, kind, sensitivity, context, meaning })
+      if (changed.length) throw fail('LEXICON_SENSITIVE_FIELDS_FORBIDDEN', `non-user writes cannot change ${changed.join(', ')}`)
+    }
+    const revivedEntry = status !== 'active'
+    e.term = term
+    e.normalizedTerm = normalizedTerm
+    e.kind = kind
+    e.meaning = meaning
+    if (options.usage != null) e.usage = String(options.usage)
+    e.aliases = aliases
+    e.normalizedAliases = normalizedAliases
+    if (options.context !== undefined) e.context = context
+    if (options.knownBy !== undefined) e.knownBy = Array.isArray(options.knownBy) ? options.knownBy.map(String) : []
+    if (options.visibility != null) e.visibility = String(options.visibility)
+    e.sensitivity = sensitivity
+    if (typeof options.strength === 'number') e.strength = options.strength
+    if (typeof options.confidence === 'number') e.confidence = options.confidence
+    e.status = isUser ? wantedStatus : 'active'
+    e.source = source
+    if (options.evidence !== undefined) e.evidence = Array.isArray(options.evidence) ? options.evidence : []
+    e.updatedAt = now
+    revived = revivedEntry
+    if (revivedEntry) {
+      delete e.revisionOf
+      delete e.previousRevision
+      e.reviewedAt = now
+      e.reviewedBy = source
+      e.reviewReason = null
+      if (status === 'rejected' && e.fingerprint) delete store.rejected[e.fingerprint]
+    }
+  } else {
+    targetId = nextId()
+    store.terms[targetId] = {
+      term,
+      normalizedTerm,
+      kind,
+      meaning,
+      usage: options.usage == null ? '' : String(options.usage),
+      examples: Array.isArray(options.examples) ? options.examples.map(String) : [],
+      aliases,
+      normalizedAliases,
+      context,
+      knownBy: Array.isArray(options.knownBy) ? options.knownBy.map(String) : [],
+      visibility: String(options.visibility || 'shared'),
+      sensitivity,
+      strength: typeof options.strength === 'number' ? options.strength : 0.5,
+      confidence: typeof options.confidence === 'number' ? options.confidence : null,
+      status: wantedStatus,
+      source,
+      evidence: Array.isArray(options.evidence) ? options.evidence : [],
+      sourceMemoryId: options.sourceMemoryId || null,
+      createdAt: now,
+      updatedAt: now,
+      reviewedAt: null,
+      reviewedBy: null,
+      reviewReason: null,
+      hitCounts: { candidate: 0, injection: 0, query: 0 },
+      lastInjectedAt: null,
+    }
+  }
+  store.revision += 1
+  saveLexicon(store)
+  return { term: store.terms[targetId], termId: targetId, created, ...(revived ? { revived: true } : {}) }
+}
+
+/** 归档（§2.1）：只有 active → archived；不写 rejected 墓碑。 */
+export function archiveLexiconTerm({ libraryId, termId } = {}) {
+  const store = loadLexicon(libraryId)
+  const e = store.terms[termId]
+  if (!e) throw fail('LEXICON_NOT_FOUND', 'unknown lexicon term')
+  const status = e.status || 'active'
+  if (status !== 'active') throw fail('LEXICON_INVALID_STATUS', `only active terms can be archived; ${termId} is ${status}`)
+  e.status = 'archived'
+  e.updatedAt = new Date().toISOString()
+  store.revision += 1
+  saveLexicon(store)
+  return { term: e, termId, action: 'archive' }
+}
+
+/** 恢复（§2.1）：只有 archived → active；legacy 修订草稿拒绝独立恢复。 */
+export function restoreLexiconTerm({ libraryId, termId } = {}) {
+  const store = loadLexicon(libraryId)
+  const e = store.terms[termId]
+  if (!e) throw fail('LEXICON_NOT_FOUND', 'unknown lexicon term')
+  const status = e.status || 'active'
+  if (status !== 'archived') throw fail('LEXICON_INVALID_STATUS', `only archived terms can be restored; ${termId} is ${status}`)
+  if (e.revisionOf && (store.terms[e.revisionOf]?.status || 'active') === 'active') {
+    throw fail('LEXICON_REVISION_IMMUTABLE', 'a legacy revision draft cannot be restored on its own')
+  }
+  const normalizedTerm = normalizeLexeme(e.term)
+  const aliases = Array.isArray(e.normalizedAliases) ? e.normalizedAliases : []
+  for (const [id, other] of Object.entries(store.terms)) {
+    if (id === termId) continue
+    const otherStatus = other.status || 'active'
+    if (otherStatus !== 'active' && otherStatus !== 'pending') continue
+    const otherAliases = Array.isArray(other.normalizedAliases) ? other.normalizedAliases : []
+    if (other.normalizedTerm === normalizedTerm || otherAliases.includes(normalizedTerm)
+      || aliases.includes(other.normalizedTerm) || otherAliases.some((alias) => aliases.includes(alias))) {
+      throw fail('LEXICON_ALIAS_CONFLICT', `restoring ${termId} would collide with ${id}`)
+    }
+  }
+  e.status = 'active'
+  e.updatedAt = new Date().toISOString()
+  store.revision += 1
+  saveLexicon(store)
+  return { term: e, termId, action: 'restore' }
+}
+
+export function deleteLexiconTerm({ libraryId, termId } = {}) {
+  const store = loadLexicon(libraryId)
+  if (!store.terms[termId]) throw fail('LEXICON_TERM_NOT_FOUND', 'unknown lexicon term')
+  delete store.terms[termId]
+  store.revision += 1
+  saveLexicon(store)
+  return { termId, deleted: true }
+}
+
+export function searchLexicon(options = {}, opts = {}) {
+  const libraryId = String(options.libraryId || '')
+  const includeArchived = opts?.includeArchived === true || options.includeArchived === true
+  const store = loadLexicon(libraryId)
+  const query = normalizeLexeme(options.query)
+  if (!query) return []
+  const memoryContext = options.memoryContext || {}
+  const hits = []
+  for (const [termId, e] of Object.entries(store.terms)) {
+    const status = e.status || 'active'
+    if (status !== 'active' && !(includeArchived && status === 'archived')) continue
+    if (!contextVisible(e.context, memoryContext)) continue
+    const haystack = [normalizeLexeme(e.term), ...(Array.isArray(e.normalizedAliases) ? e.normalizedAliases : []).map(normalizeLexeme), normalizeLexeme(e.meaning)].filter(Boolean)
+    if (!haystack.some((value) => value.includes(query) || query.includes(value))) continue
+    hits.push({ id: termId, ...e, matchedBy: 'exact' })
+    if (hits.length >= 8) break
+  }
+  return hits
+}
+
+/** 可见词条：active 默认；includeArchived 追加 archived（§2.1）。pending/rejected 永不返回。 */
+export function visibleLexiconTerms(libraryId, memoryContext = {}, opts = {}) {
+  const includeArchived = opts?.includeArchived === true
+  const store = loadLexicon(libraryId)
+  return Object.entries(store.terms)
+    .filter(([, e]) => {
+      const status = e.status || 'active'
+      return status === 'active' || (includeArchived && status === 'archived')
+    })
+    .filter(([, e]) => contextVisible(e.context, memoryContext))
+    .map(([id, e]) => ({ termId: id, id, ...e }))
+}

package/tests/graph-cascade.test.mjs

@@ -165,8 +165,7 @@ test('getGraph hides orphan entities by default and reveals them on includeOrpha
   graph.deleteEntity({ libraryId, entityId: lonely.id })
 })
 
-test('apply() schedules the sweep late, and a corrupt store only warns instead of blocking load', async () => {
-  const badLib = state.ensureSession('sweep-bad', { cwd: path.join(home, 'ws-bad'), agentPreset: 'coding' }).libraryId
+test('apply() schedules the sweep late, and a corrupt store only warns instead of blocking load', async () => {  const badLib = state.ensureSession('sweep-bad', { cwd: path.join(home, 'ws-bad'), agentPreset: 'coding' }).libraryId
   fs.writeFileSync(path.join(indexDir(), `${badLib}.entities.json`), '{ still not json')
   const info = []
   const warn = []
@@ -188,3 +187,37 @@ test('apply() schedules the sweep late, and a corrupt store only warns instead o
   assert.ok(warn.some(message => message.includes(`orphan entity sweep skipped ${badLib}`)), 'the sweep reports the corrupt library')
   assert.equal(warn.some(message => message.includes('orphan entity sweep failed')), false, 'per-library failures stay contained')
 })
+
+// ---- §6.4 包 D：linked 派生字段与删除路径的一致性 ----
+// 只有 relationship、没有 memory link 的实体是历史，不是孤儿——linked 必须为
+// true，启动 prune 也必须放行它；判定口径与 pruneOrphanEntities 完全一致。
+
+test('a relationship-only entity is linked, not an orphan, and prune agrees', () => {
+  const soloA = graph.createEntity({ libraryId, name: 'RelOnlyA' })
+  const soloB = graph.createEntity({ libraryId, name: 'RelOnlyB' })
+  graph.updateRelationship({ libraryId, fromId: soloA.id, toId: soloB.id, state: { familiarity: 0.4 }, evidenceIds: ['mem-free'], reason: 'The free scene is explicit evidence.' })
+  const rows = graph.listEntities({ libraryId }).items
+  const rowA = rows.find(entity => entity.id === soloA.id)
+  const rowB = rows.find(entity => entity.id === soloB.id)
+  assert.ok(rowA && rowB, 'no session means the pair comes back with everyone else')
+  assert.equal(rowA.linked, true, 'a snapshot endpoint is a reference even without any memory link')
+  assert.equal(rowB.linked, true)
+  const pruned = graph.pruneOrphanEntities(libraryId)
+  assert.ok(!pruned.removed.includes(soloA.id) && !pruned.removed.includes(soloB.id),
+    'the prune must share the linked judgement, never collect snapshot-referenced entities')
+})
+
+test('the linked flag tracks a refused delete through force, and cleanup drops the row', () => {
+  const kept = graph.createEntity({ libraryId, name: 'FlagKept' })
+  graph.linkEntries({ libraryId, fromId: 'mem-free', toId: kept.id, kind: 'person', note: 'FlagKept is the person this scene is about.' })
+  let row = graph.listEntities({ libraryId }).items.find(entity => entity.id === kept.id)
+  assert.equal(row.linked, true, 'an inbound link shows up as linked before any delete')
+  assert.throws(() => graph.deleteEntity({ libraryId, entityId: kept.id }), /still referenced/, 'the refusal keeps both the row and its link')
+  assert.ok(graph.listEntities({ libraryId }).items.some(entity => entity.id === kept.id))
+  const forced = graph.deleteEntity({ libraryId, entityId: kept.id, force: true })
+  assert.equal(forced.deleted, true)
+  assert.equal(forced.removedLinks, 1, 'force sweeps the inbound link')
+  assert.ok(state.loadPrivateIndex(libraryId).entries['mem-free'].links.every(link => link.to !== kept.id), 'the forced delete sweeps the inbound link of this entity')
+  row = graph.listEntities({ libraryId }).items.find(entity => entity.id === kept.id)
+  assert.equal(row, undefined, 'after the force delete the entity is gone from the listing too')
+})

package/tests/graph.test.mjs

@@ -49,6 +49,44 @@ test('invalid kinds, empty reasons and out-of-scope private links are rejected',
   assert.ok(!JSON.stringify(graph.getGraph({ exec })).includes('private title'))
 })
 
+test('an explicit link source persists on the record and surfaces on graph edges', () => {
+  state.updatePrivateIndex(libraryId, index => {
+    index.entries['mem-src-a'] = { title: 'alpha note', content: 'alpha body', status: 'active', visibility: 'shared' }
+    index.entries['mem-src-b'] = { title: 'beta note', content: 'beta body', status: 'active', visibility: 'shared' }
+    index.entries['mem-src-c'] = { title: 'gamma note', content: 'gamma body', status: 'active', visibility: 'shared' }
+  })
+  const linked = graph.linkEntries({
+    libraryId, fromId: 'mem-src-a', toId: 'mem-src-b', kind: 'relation',
+    note: 'Auto-linked because both memories share the stable name Alpha.', source: 'auto',
+  })
+  assert.equal(linked.source, 'auto')
+  const stored = () => state.loadPrivateIndex(libraryId).entries['mem-src-a'].links
+  assert.equal(stored().find(link => link.to === 'mem-src-b').source, 'auto', 'auto is persisted, not only returned')
+
+  // Replacement stays idempotent and the source survives the rewrite.
+  graph.linkEntries({
+    libraryId, fromId: 'mem-src-a', toId: 'mem-src-b', kind: 'relation',
+    note: 'Re-linked after a rerun with the same evidence.', source: 'auto',
+  })
+  const replaced = stored().filter(link => link.to === 'mem-src-b')
+  assert.equal(replaced.length, 1, 'the same (to, kind) pair is replaced in place')
+  assert.equal(replaced[0].source, 'auto')
+
+  // Only auto/user are meaningful; anything else is omitted rather than stored.
+  graph.linkEntries({
+    libraryId, fromId: 'mem-src-b', toId: 'mem-src-c', kind: 'event',
+    note: 'The same event seen from another side.', source: 'robot',
+  })
+  assert.equal(state.loadPrivateIndex(libraryId).entries['mem-src-b'].links[0].source, undefined)
+
+  const view = graph.getGraph({ libraryId, focusId: 'mem-src-b', depth: 1 })
+  const autoEdge = view.edges.find(edge => edge.from === 'mem-src-a' && edge.to === 'mem-src-b')
+  assert.equal(autoEdge.source, 'auto', 'the UI can tag an auto link')
+  assert.equal(autoEdge.kind, 'relation', 'link semantics are unchanged')
+  const plainEdge = view.edges.find(edge => edge.from === 'mem-src-b')
+  assert.equal(plainEdge.source, null, 'a link without a source reports null, not undefined')
+})
+
 test('graphs cap nodes at 200 and the recall carries at most two pointers', async () => {
   state.updatePrivateIndex(libraryId, index => {
     for (let i = 10; i < 400; i++) index.entries[`mem-${i}`] = { title: `node ${i}`, status: 'active', content: 'node' }
@@ -92,3 +130,61 @@ test('a dangling edge is reported as missing, matching the graph view placeholde
   const healthy = graph.recallRelations(libraryId, state.loadPrivateIndex(libraryId), 'mem-2', null)
   assert.equal(healthy.find(item => item.id === zhou.id).missing, false)
 })
+
+// ---- §6.4 包 D：listEntities 的 linked 派生字段与孤立判定 ----
+// 前提（合并稿 0.2 纠正）：无 session 本来就返回全部实体——不"放开过滤"，
+// 只加 linked 标记；有 session 才按可见引用收窄。
+
+test('listEntities: without a session every entity returns, with a correct derived linked flag', () => {
+  const binding = state.ensureSession('vis-all', { cwd: path.join(home, 'ws-vis-all'), agentPreset: 'rp' })
+  const lib = binding.libraryId
+  const anchored = graph.createEntity({ libraryId: lib, name: 'Anchored' })
+  const drifting = graph.createEntity({ libraryId: lib, name: 'Drifting' })
+  state.savePrivateIndex(lib, { entries: {
+    'mem-anchored': { title: 'anchored', content: 'scene', layer: 'long_term', status: 'active', visibility: 'shared',
+      links: [{ to: anchored.id, kind: 'person', note: 'Anchored is the person this scene is about.', confidence: 0.9 }] },
+  } })
+  const all = graph.listEntities({ libraryId: lib })
+  assert.equal(all.items.length, 2, 'without a session the full entity list comes back')
+  assert.equal(all.total, 2)
+  const anchoredRow = all.items.find(entity => entity.id === anchored.id)
+  const driftingRow = all.items.find(entity => entity.id === drifting.id)
+  assert.equal(anchoredRow.linked, true, 'a link target is linked')
+  assert.equal(driftingRow.linked, false, 'an entity nothing points at is unlinked')
+  // linked 是运行时派生字段：实体文件里绝不出现它，启动 prune 的判定不受污染。
+  assert.equal(graph.graphExport(lib).entities[drifting.id].linked, undefined, 'the derived flag is never written back')
+})
+
+test('listEntities: with a session only visible references count, and relationship evidence is session-filtered too', () => {
+  const binding = state.ensureSession('vis-scoped', { cwd: path.join(home, 'ws-vis-scoped'), agentPreset: 'rp' })
+  const lib = binding.libraryId
+  const exec = { agent: { session: { header: { id: 'vis-scoped' } } } }
+  const linked = graph.createEntity({ libraryId: lib, name: 'Linked' })
+  const secretTarget = graph.createEntity({ libraryId: lib, name: 'SecretTarget' })
+  const relVisible = graph.createEntity({ libraryId: lib, name: 'RelVisible' })
+  const relHidden = graph.createEntity({ libraryId: lib, name: 'RelHidden' })
+  const lonely = graph.createEntity({ libraryId: lib, name: 'Lonely' })
+  state.savePrivateIndex(lib, { entries: {
+    'mem-open': { title: 'open', content: 'open scene', layer: 'long_term', status: 'active', visibility: 'shared',
+      links: [{ to: linked.id, kind: 'person', note: 'Linked is the person this scene is about.', confidence: 0.9 }] },
+    'mem-hidden': { title: 'hidden', content: 'secret scene', layer: 'long_term', status: 'active', visibility: 'secret', context: { characterId: 'other' },
+      links: [{ to: secretTarget.id, kind: 'person', note: 'Secret is the person this scene is about.', confidence: 0.9 }] },
+  } })
+  // 关系快照也算引用：evidence 指向本会话可见记忆的算，指不可见记忆的不算。
+  graph.updateRelationship({ libraryId: lib, fromId: linked.id, toId: relVisible.id, state: { trust: 0.5 }, evidenceIds: ['mem-open'], reason: 'The open scene is explicit evidence.' })
+  graph.updateRelationship({ libraryId: lib, fromId: secretTarget.id, toId: relHidden.id, state: { trust: 0.5 }, evidenceIds: ['mem-hidden'], reason: 'The hidden scene is the only evidence here.' })
+  const scoped = graph.listEntities({ exec, libraryId: lib })
+  const ids = scoped.items.map(entity => entity.id).sort()
+  assert.deepEqual(ids, [linked.id, relVisible.id].sort(),
+    'a visible entry link and a relationship with visible evidence both count; secret-referenced and orphan entities do not')
+  assert.ok(scoped.items.every(entity => entity.linked === true), 'every session-visible row is linked by construction')
+  // 无 session：全量计入（两条快照都算引用），Linked/RelVisible/SecretTarget/RelHidden
+  // 都是 linked=true，只有 Lonely 是孤立。
+  const all = graph.listEntities({ libraryId: lib })
+  assert.equal(all.items.length, 5, 'no session means every entity, referenced or not')
+  const linkedMap = Object.fromEntries(all.items.map(entity => [entity.id, entity.linked]))
+  for (const entity of [linked, relVisible, secretTarget, relHidden]) {
+    assert.equal(linkedMap[entity.id], true, `${entity.name} is referenced and must not be misjudged as an orphan`)
+  }
+  assert.equal(linkedMap[lonely.id], false, 'the untouched entity stays unlinked')
+})