dsh-memu-memory 1.2.0 → 1.2.2

package/tests/graph-cascade.test.mjs

@@ -0,0 +1,223 @@
+// Deletion cascade and entity lifecycle. The invariant under test: only the
+// *permanent* delete path may lose graph structure. Archiving is reversible, so
+// its links and entities must survive byte-for-byte (the boundary tests here
+// exist to pin that against a well-meant "clean up while we are at it").
+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-graph-cascade-'))
+process.env.DSH_MEMU_HOME = home
+const state = await import('../lib/state.js')
+const graph = await import('../lib/graph.js')
+const memory = await import('../lib/memory.js')
+const { indexDir } = await import('../lib/paths.js')
+
+test.after(() => { state.flushState(); fs.rmSync(home, { recursive: true, force: true }) })
+
+const binding = state.ensureSession('cascade', { cwd: path.join(home, 'rp'), agentPreset: 'rp' })
+const libraryId = binding.libraryId
+const exec = { agent: { session: { header: { id: 'cascade' } } } }
+const entitiesFile = path.join(indexDir(), `${libraryId}.entities.json`)
+const readStore = () => JSON.parse(fs.readFileSync(entitiesFile, 'utf8'))
+
+state.savePrivateIndex(libraryId, { entries: {
+  'mem-root': { title: 'root', content: 'root scene', layer: 'long_term', status: 'archived', visibility: 'shared' },
+  'mem-peer': { title: 'peer', content: 'peer scene', layer: 'long_term', status: 'active', visibility: 'shared' },
+  'mem-side': { title: 'side', content: 'side scene', layer: 'long_term', status: 'active', visibility: 'shared' },
+  'mem-free': { title: 'free', content: 'free scene', layer: 'long_term', status: 'active', visibility: 'shared' },
+} })
+
+test('permanent delete sweeps inbound links and collects the entity only that row kept alive', async () => {
+  const lin = graph.createEntity({ libraryId, name: 'Lin' })
+  state.updatePrivateIndex(libraryId, index => {
+    index.entries['mem-root'].links = [
+      { to: 'mem-peer', kind: 'event', note: 'The same event seen from another side.', confidence: 0.9 },
+      { to: lin.id, kind: 'person', note: 'Lin is the person this scene is about.', confidence: 0.9 },
+    ]
+    index.entries['mem-peer'].links = [{ to: 'mem-root', kind: 'event', note: 'Back-reference to the very same event.', confidence: 0.8 }]
+  })
+  const result = await memory.privateDelete({ exec, id: 'mem-root' })
+  assert.equal(result.deleted, true)
+  const fresh = state.loadPrivateIndex(libraryId)
+  assert.equal(fresh.entries['mem-root'], undefined, 'the row itself goes')
+  assert.deepEqual(fresh.entries['mem-peer'].links, [], 'an inbound link from a surviving entry is swept')
+  assert.equal(readStore().entities[lin.id], undefined, 'an entity nothing else points at is collected')
+  const view = graph.getGraph({ libraryId })
+  assert.ok(!view.nodes.some(node => node.id === 'mem-root'))
+  assert.ok(!view.nodes.some(node => node.id === lin.id), 'no orphan placeholder node survives')
+})
+
+test('archiving keeps links and entities so the memory stays restorable', async () => {
+  const yun = graph.createEntity({ libraryId, name: 'Yun' })
+  graph.linkEntries({ libraryId, fromId: 'mem-side', toId: yun.id, kind: 'person', note: 'Yun is the person this scene is about.' })
+  await memory.privateArchive({ exec, libraryId, id: 'mem-side' })
+  assert.equal(state.loadPrivateIndex(libraryId).entries['mem-side'].links.length, 1, 'archiving must not sweep links')
+  assert.ok(readStore().entities[yun.id], 'the referenced entity must survive an archive')
+  // Restore brings the memory back with its graph intact — the reason the
+  // archive path is forbidden from ever cascading.
+  await memory.privateUpdate({ exec, libraryId, id: 'mem-side', status: 'active' })
+  assert.equal(state.loadPrivateIndex(libraryId).entries['mem-side'].links.length, 1)
+  assert.ok(graph.getGraph({ libraryId, focusId: yun.id, depth: 1 }).nodes.some(node => node.id === yun.id))
+})
+
+test('deleteEntity deletes an unreferenced entity and refuses a referenced one until force', () => {
+  const solo = graph.createEntity({ libraryId, name: 'Solo' })
+  const gone = graph.deleteEntity({ libraryId, entityId: solo.id })
+  assert.equal(gone.deleted, true)
+  assert.equal(readStore().entities[solo.id], undefined)
+  assert.throws(() => graph.deleteEntity({ libraryId, entityId: solo.id }), /unknown entity/)
+
+  const kept = graph.createEntity({ libraryId, name: 'Kept' })
+  graph.linkEntries({ libraryId, fromId: 'mem-free', toId: kept.id, kind: 'person', note: 'Kept is the person this scene is about.' })
+  assert.throws(() => graph.deleteEntity({ libraryId, entityId: kept.id }), /still referenced/)
+  assert.ok(readStore().entities[kept.id], 'a refused delete leaves the entity in place')
+  assert.equal(state.loadPrivateIndex(libraryId).entries['mem-free'].links.length, 1, 'and its links too')
+  const forced = graph.deleteEntity({ libraryId, entityId: kept.id, force: true })
+  assert.equal(forced.removedLinks, 1)
+  assert.deepEqual(state.loadPrivateIndex(libraryId).entries['mem-free'].links, [])
+  assert.equal(readStore().entities[kept.id], undefined)
+})
+
+test('force-delete drops relationship snapshots with the entity, and the freed endpoint is collectable', () => {
+  const p = graph.createEntity({ libraryId, name: 'P' })
+  const q = graph.createEntity({ libraryId, name: 'Q' })
+  graph.updateRelationship({ libraryId, fromId: p.id, toId: q.id, state: { trust: .5 }, evidenceIds: ['mem-free'], reason: 'The scene itself is explicit evidence.' })
+  assert.throws(() => graph.deleteEntity({ libraryId, entityId: p.id }), /relationship snapshot/)
+  const forced = graph.deleteEntity({ libraryId, entityId: p.id, force: true })
+  assert.equal(forced.removedRelationships, 1)
+  assert.equal(graph.getRelationship({ libraryId, fromId: p.id, toId: q.id }).relationship, null)
+  // q has no links and no snapshot left: a prune collects it, while Yun stays.
+  const pruned = graph.pruneOrphanEntities(libraryId)
+  assert.ok(pruned.removed.includes(q.id), 'the freed endpoint becomes an orphan')
+  const yun = Object.values(readStore().entities).find(entity => entity.name === 'Yun')
+  assert.ok(!pruned.removed.includes(yun.id), 'a still-linked entity is never collected')
+})
+
+test('restoreGraphData collects entities the restored memories do not refer to', () => {
+  const before = Object.keys(readStore().entities)
+  const data = {
+    entities: {
+      'ent-ghost': { id: 'ent-ghost', name: 'Ghost', kind: 'person', aliases: [] },
+      'ent-real': { id: 'ent-real', name: 'Real', kind: 'person', aliases: [] },
+    },
+    relationships: {},
+  }
+  // mem-free's link to the backup's entity id gets remapped to the restored id,
+  // which is what keeps 'Real' alive while 'Ghost' (nothing refers to it) goes.
+  state.updatePrivateIndex(libraryId, index => {
+    index.entries['mem-free'].links = [{ to: 'ent-real', kind: 'person', note: 'Real is the person this scene is about.', confidence: 0.9 }]
+  })
+  graph.restoreGraphData(libraryId, data, { 'mem-old': 'mem-free' })
+  const after = readStore().entities
+  assert.ok(before.every(id => after[id]), 'the restore must not touch pre-existing entities')
+  assert.ok(!Object.values(after).some(entity => entity.name === 'Ghost'), 'an entity nothing restored refers to is collected')
+  const real = Object.values(after).find(entity => entity.name === 'Real')
+  assert.ok(real, 'an entity the restored link points at survives')
+  assert.equal(state.loadPrivateIndex(libraryId).entries['mem-free'].links[0].to, real.id, 'the link is remapped to the new id')
+})
+
+test('the startup sweep collects old-format orphans and is a no-op on healthy data', () => {
+  const sweepBinding = state.ensureSession('sweep', { cwd: path.join(home, 'ws-sweep'), agentPreset: 'coding' })
+  const sweepLib = sweepBinding.libraryId
+  state.savePrivateIndex(sweepLib, { entries: {
+    'mem-s': { title: 's', content: 's scene', layer: 'long_term', status: 'active', visibility: 'shared',
+      links: [{ to: 'ent-kept', kind: 'person', note: 'Kept is the person this scene is about.', confidence: 0.9 }] },
+  } })
+  const sweepFile = path.join(indexDir(), `${sweepLib}.entities.json`)
+  fs.writeFileSync(sweepFile, JSON.stringify({ version: 1, entities: {
+    'ent-kept': { id: 'ent-kept', name: 'Kept', kind: 'person', aliases: [], createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-01-01T00:00:00.000Z' },
+    'ent-lorn': { id: 'ent-lorn', name: 'Lorn', kind: 'thing', aliases: [], createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-01-01T00:00:00.000Z' },
+  }, relationships: {} }))
+  const result = graph.pruneOrphanEntitiesAll()
+  assert.equal(result.failed.length, 0)
+  const store = JSON.parse(fs.readFileSync(sweepFile, 'utf8'))
+  assert.ok(store.entities['ent-kept'], 'a referenced entity survives the sweep')
+  assert.equal(store.entities['ent-lorn'], undefined, 'old-format orphans are collected')
+  const healthy = fs.readFileSync(sweepFile, 'utf8')
+  const again = graph.pruneOrphanEntitiesAll()
+  assert.equal(again.removed, 0, 'healthy data is a no-op')
+  assert.equal(fs.readFileSync(sweepFile, 'utf8'), healthy, 'the no-op never rewrites the file')
+})
+
+test('one corrupt entity store fails alone and never blocks the sweep', () => {
+  const badBinding = state.ensureSession('sweep-bad', { cwd: path.join(home, 'ws-bad'), agentPreset: 'coding' })
+  fs.writeFileSync(path.join(indexDir(), `${badBinding.libraryId}.entities.json`), '{ not json')
+  const result = graph.pruneOrphanEntitiesAll()
+  assert.ok(result.failed.some(failure => failure.libraryId === badBinding.libraryId), 'the corrupt library is reported')
+  assert.equal(result.failed.length, 1, 'other libraries are unaffected')
+  assert.throws(() => graph.pruneOrphanEntities(badBinding.libraryId), /entity store/)
+})
+
+test('getGraph hides orphan entities by default and reveals them on includeOrphans', () => {
+  const lonely = graph.createEntity({ libraryId, name: 'Lonely' })
+  const yun = Object.values(readStore().entities).find(entity => entity.name === 'Yun')
+  const bare = graph.getGraph({ libraryId })
+  assert.ok(!bare.nodes.some(node => node.id === lonely.id), 'an entity no edge points at is hidden by default')
+  assert.ok(bare.nodes.some(node => node.id === yun.id), 'a linked entity stays visible')
+  assert.ok(bare.edges.some(edge => edge.from === 'mem-side' && edge.to === yun.id))
+  const wide = graph.getGraph({ libraryId, includeOrphans: true })
+  const orphanNode = wide.nodes.find(node => node.id === lonely.id)
+  assert.ok(orphanNode, 'includeOrphans reveals what old data left behind')
+  assert.equal(orphanNode.degree, 0)
+  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
+  fs.writeFileSync(path.join(indexDir(), `${badLib}.entities.json`), '{ still not json')
+  const info = []
+  const warn = []
+  const tools = []
+  const scope = {
+    effect(fn) { fn() },
+    tools: { register(tool) { tools.push(tool); return () => {} } },
+    webServer: { register() { return () => {} } },
+    connection: { requestRejection: () => undefined },
+    interval() { return 1 },
+    on() { return () => {} },
+  }
+  const ctx = { ...scope, logger: { info: (m) => info.push(m), warn: (m) => warn.push(m) }, inject(_deps, callback) { callback(scope) } }
+  const plugin = await import('../lib/index.js')
+  plugin.apply(ctx)
+  assert.ok(info.some(message => message.startsWith('dsh-memu-memory: loaded')), 'activation itself is unaffected')
+  assert.equal(warn.some(message => message.includes('orphan entity sweep')), false, 'scheduling must not run the sweep synchronously')
+  await new Promise(resolve => setTimeout(resolve, 4600))
+  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' }
@@ -75,3 +113,78 @@ test('relationship snapshots preserve unknowns, evidence, boundaries and previou
   assert.ok(next.history[0].validTo)
   assert.throws(() => graph.updateRelationship({ libraryId, fromId: a.id, toId: b.id, state: {}, evidenceIds: [], reason: 'no evidence' }), /evidence/)
 })
+
+test('a dangling edge is reported as missing, matching the graph view placeholder', () => {
+  // mem-1 was deleted from the index in an earlier test; its inbound edge from
+  // mem-0 remains. getGraph renders a [deleted] placeholder for it, so recall
+  // must report the same edge with the same missing mark instead of dropping it.
+  const view = graph.getGraph({ libraryId, focusId: 'mem-0', depth: 1 })
+  assert.equal(view.nodes.find(node => node.id === 'mem-1').missing, true)
+  const related = graph.recallRelations(libraryId, state.loadPrivateIndex(libraryId), 'mem-0', null)
+  const dangling = related.find(item => item.id === 'mem-1')
+  assert.ok(dangling, 'the edge must be reported, not silently dropped')
+  assert.equal(dangling.missing, true)
+  assert.equal(dangling.title, '[deleted]')
+  // mem-2 still links at the Zhou entity: a resolvable relation is marked false.
+  const zhou = Object.values(graph.graphExport(libraryId).entities).find(entity => entity.name === 'Zhou')
+  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')
+})