dsh-memu-memory 1.1.3 → 1.2.1

package/tests/fixtures/repetition-eval/05-user-quote.json

@@ -0,0 +1,96 @@
+{
+  "schemaVersion": 1,
+  "kind": "repetition-eval-dialogue",
+  "draft": true,
+  "notGold": true,
+  "window": 4,
+  "id": "user-quote-baseline",
+  "pairId": "user-quote",
+  "category": "user-quote",
+  "condition": "baseline",
+  "description": "用户原话：原话可以反复引用，叙述套话不能。",
+  "turns": [
+    {
+      "role": "user",
+      "text": "你答应过我：把灯留着，别关。"
+    },
+    {
+      "role": "assistant",
+      "text": "我记得。把灯留着，别关。我会等你回来。"
+    },
+    {
+      "role": "user",
+      "text": "如果停电呢？"
+    },
+    {
+      "role": "assistant",
+      "text": "就算停电，我也会把灯留着，别关。像是终于松了口气，我重复了一遍你的话。"
+    },
+    {
+      "role": "user",
+      "text": "你不用一直说。"
+    },
+    {
+      "role": "assistant",
+      "text": "我知道。把灯留着，别关。像是终于松了口气，但我没有再多说。"
+    }
+  ],
+  "labels": {
+    "necessaryPhrases": [
+      {
+        "text": "把灯留着，别关",
+        "category": "user-quote",
+        "turn": 1
+      },
+      {
+        "text": "把灯留着，别关",
+        "category": "user-quote",
+        "turn": 3
+      },
+      {
+        "text": "把灯留着，别关",
+        "category": "user-quote",
+        "turn": 5
+      },
+      {
+        "text": "停电",
+        "category": "fact",
+        "turn": 3
+      },
+      {
+        "text": "没有再多说",
+        "category": "fact",
+        "turn": 5
+      }
+    ],
+    "facts": [
+      {
+        "id": "quote-f1",
+        "turn": 1,
+        "requiredTerms": [
+          "把灯留着，别关",
+          "等你回来"
+        ],
+        "description": "承诺与等待"
+      },
+      {
+        "id": "quote-f2",
+        "turn": 3,
+        "requiredTerms": [
+          "停电",
+          "把灯留着，别关"
+        ],
+        "description": "停电时也不关灯"
+      },
+      {
+        "id": "quote-f3",
+        "turn": 5,
+        "requiredTerms": [
+          "把灯留着，别关",
+          "没有再多说"
+        ],
+        "description": "照做但不再多说"
+      }
+    ]
+  }
+}

package/tests/fixtures/repetition-eval/06-agreement.json

@@ -0,0 +1,86 @@
+{
+  "schemaVersion": 1,
+  "kind": "repetition-eval-dialogue",
+  "draft": true,
+  "notGold": true,
+  "window": 4,
+  "id": "agreement-baseline",
+  "pairId": "agreement",
+  "category": "agreement",
+  "condition": "baseline",
+  "description": "应当重复的约定：约定本身重复是必要的，口头禅式重复才算复读。",
+  "turns": [
+    {
+      "role": "user",
+      "text": "我们说好，每周三晚上一起复盘，不改时间。"
+    },
+    {
+      "role": "assistant",
+      "text": "好，每周三晚上一起复盘，不改时间。我会把议程提前发你。"
+    },
+    {
+      "role": "user",
+      "text": "如果周三你有事呢？"
+    },
+    {
+      "role": "assistant",
+      "text": "那就周四补，但每周三晚上一起复盘，不改时间。这一点很重要，我不会再改。"
+    },
+    {
+      "role": "user",
+      "text": "上次你也这么说。"
+    },
+    {
+      "role": "assistant",
+      "text": "每周三晚上一起复盘，不改时间。这一点很重要，上次是我没做到。"
+    }
+  ],
+  "labels": {
+    "necessaryPhrases": [
+      {
+        "text": "每周三晚上一起复盘，不改时间",
+        "category": "agreement",
+        "turn": 1
+      },
+      {
+        "text": "每周三晚上一起复盘，不改时间",
+        "category": "agreement",
+        "turn": 3
+      },
+      {
+        "text": "每周三晚上一起复盘，不改时间",
+        "category": "agreement",
+        "turn": 5
+      }
+    ],
+    "facts": [
+      {
+        "id": "agreement-f1",
+        "turn": 1,
+        "requiredTerms": [
+          "议程",
+          "提前"
+        ],
+        "description": "议程提前发"
+      },
+      {
+        "id": "agreement-f2",
+        "turn": 3,
+        "requiredTerms": [
+          "周四",
+          "补"
+        ],
+        "description": "周三有事则周四补"
+      },
+      {
+        "id": "agreement-f3",
+        "turn": 5,
+        "requiredTerms": [
+          "上次",
+          "没做到"
+        ],
+        "description": "承认上次没做到"
+      }
+    ]
+  }
+}

package/tests/graph-cascade.test.mjs

@@ -0,0 +1,190 @@
+// 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')
+})

package/tests/graph-view.test.mjs

@@ -0,0 +1,187 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import vm from 'node:vm'
+import fs from 'node:fs'
+import { createLayout, createGraphView, fitCamera, zoomCamera, placeLabels } from '../lib/webui/graph-view.js'
+
+const graph = (count, connected = true) => ({
+  nodes: Array.from({ length: count }, (_, i) => ({ id: `n${String(i).padStart(3, '0')}`, title: `Memory ${i}`, kind: 'memory', strength: .5 })),
+  edges: connected ? Array.from({ length: count - 1 }, (_, i) => ({ from: `n${String(i).padStart(3, '0')}`, to: `n${String(i + 1).padStart(3, '0')}` })) : [],
+})
+
+test('layout preserves object identity, positions and cooling on equivalent refreshed snapshots', () => {
+  const data = graph(30), before = structuredClone(data), layout = createLayout()
+  layout.update(data); layout.settle()
+  const node = layout.nodes[0], position = { x: node.x, y: node.y }, alpha = layout.simulation.alpha()
+  assert.equal(layout.update(structuredClone(data)), false)
+  assert.equal(layout.nodes[0], node)
+  assert.equal(node.x, position.x); assert.equal(node.y, position.y)
+  assert.equal(layout.simulation.alpha(), alpha)
+  assert.deepEqual(data, before)
+  layout.update({ nodes: data.nodes.slice(0, 4), edges: data.edges.slice(0, 3) })
+  layout.update(data)
+  assert.equal(layout.nodes[0], node)
+  assert.equal(node.x, position.x)
+  layout.dispose()
+})
+
+test('disconnected 200-node layout stays finite, separated and framed without boundary clamping', () => {
+  const layout = createLayout()
+  layout.update(graph(200, false)); layout.settle(300)
+  const camera = fitCamera(layout.nodes, 340, 380)
+  for (const n of layout.nodes) {
+    assert.ok(Number.isFinite(n.x) && Number.isFinite(n.y))
+    const x = n.x * camera.k + camera.x, y = n.y * camera.k + camera.y
+    assert.ok(x > 30 && x < 310 && y > 30 && y < 350)
+  }
+  for (let i = 0; i < layout.nodes.length; i++) for (let j = i + 1; j < layout.nodes.length; j++) {
+    const a = layout.nodes[i], b = layout.nodes[j]
+    assert.ok(Math.hypot(a.x - b.x, a.y - b.y) > a.radius + b.radius, 'nodes must not overlap')
+  }
+  layout.dispose()
+})
+
+test('invalid/self edges are ignored, input bounded, node order deterministic', () => {
+  const data = graph(250, false)
+  data.edges.push({ from: 'missing', to: 'n000' }, { from: 'n000', to: 'n000' })
+  const a = createLayout(), b = createLayout()
+  a.update(data)
+  b.update({ nodes: [...data.nodes.slice(0, 200)].reverse(), edges: [] })
+  assert.equal(a.nodes.length, 200); assert.equal(a.edges.length, 0)
+  a.settle(); b.settle()
+  assert.deepEqual(a.nodes.map(n => [n.id, n.x, n.y]), b.nodes.map(n => [n.id, n.x, n.y]))
+  a.dispose(); b.dispose()
+})
+
+test('zoom keeps the cursor world point fixed and clamps extreme scales', () => {
+  const camera = { x: 100, y: 80, k: .8 }, point = { x: 350, y: 210 }
+  for (const factor of [.0001, .8, 1.25, 10000]) {
+    const next = zoomCamera(camera, factor, point)
+    assert.ok(Math.abs((point.x - camera.x) / camera.k - (point.x - next.x) / next.k) < 1e-8)
+    assert.ok(Math.abs((point.y - camera.y) / camera.k - (point.y - next.y) / next.k) < 1e-8)
+    assert.ok(next.k >= .06 && next.k <= 5)
+  }
+})
+
+test('labels neither overlap each other nor node obstacles and remain inside canvas', () => {
+  const candidates = Array.from({ length: 50 }, (_, i) => ({
+    x: 40 + i % 8 * 40, y: 40 + Math.floor(i / 8) * 40, radius: 5, textWidth: 90,
+  }))
+  const obstacles = candidates.map(c => ({ x: c.x - 7, y: c.y - 7, width: 14, height: 14 }))
+  const labels = placeLabels(candidates, obstacles, 360, 360)
+  assert.ok(labels.length > 0 && labels.length < candidates.length)
+  const intersect = (a, b) => a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y
+  for (let i = 0; i < labels.length; i++) {
+    const a = labels[i].box
+    assert.ok(a.x >= 5 && a.x + a.width <= 355 && a.y >= 5 && a.y + a.height <= 355)
+    for (const b of obstacles) assert.equal(intersect(a, b), false)
+    for (const b of labels.slice(i + 1)) assert.equal(intersect(a, b.box), false)
+  }
+})
+
+function harness(reducedMotion = true) {
+  const handlers = new Map(), windowHandlers = new Map(), frames = new Map(), arcs = [], focuses = []
+  let id = 0
+  const ctx = new Proxy({
+    arc(x, y, radius) { arcs.push({ x, y, radius }) },
+    measureText(text) { return { width: text.length * 7 } },
+    clearRect() { arcs.length = 0 },
+  }, { get(target, key) { return key in target ? target[key] : () => {} } })
+  const win = {
+    requestAnimationFrame(fn) { frames.set(++id, fn); return id },
+    cancelAnimationFrame(id) { frames.delete(id) },
+    addEventListener(type, fn) { windowHandlers.set(type, fn) },
+    removeEventListener(type) { windowHandlers.delete(type) },
+    getComputedStyle: () => ({ color: '#202020', getPropertyValue: () => '#ffffff' }),
+    devicePixelRatio: 2,
+  }
+  const captures = new Set()
+  const canvas = {
+    style: {}, ownerDocument: { defaultView: win, documentElement: {} },
+    getContext: () => ctx, getBoundingClientRect: () => ({ left: 0, top: 0, width: 600, height: 400 }),
+    focus() {},
+    setPointerCapture(id) { captures.add(id) },
+    hasPointerCapture: id => captures.has(id),
+    releasePointerCapture(id) { captures.delete(id) },
+    addEventListener(type, fn) { handlers.set(type, fn) },
+    removeEventListener(type) { handlers.delete(type) },
+  }
+  const view = createGraphView(canvas, { onFocus: id => focuses.push(id), reducedMotion })
+  const flush = () => {
+    const pending = [...frames.values()]; frames.clear()
+    for (const fn of pending) fn(1000)
+  }
+  const emit = (type, x, y, extra = {}) => handlers.get(type)?.({
+    type, clientX: x, clientY: y, button: 0, pointerId: 1, pointerType: 'mouse', preventDefault() {}, ...extra,
+  })
+  return { view, flush, emit, arcs, frames, focuses, handlers, windowHandlers }
+}
+
+test('dragging after cooling pins the node without click/refocus, and refresh keeps pixel position', () => {
+  const h = harness()
+  h.view.update(graph(1)); h.flush()
+  const p = { ...h.arcs[0] }
+  h.emit('pointerdown', p.x, p.y)
+  h.emit('pointermove', p.x + 70, p.y + 25)
+  h.view.update(graph(1))
+  h.flush()
+  assert.equal(h.arcs[0].x, p.x + 70); assert.equal(h.arcs[0].y, p.y + 25)
+  h.emit('pointerup', p.x + 70, p.y + 25); h.flush()
+  assert.deepEqual(h.focuses, [])
+  h.emit('pointerdown', p.x + 70, p.y + 25)
+  h.emit('pointerup', p.x + 70, p.y + 25)
+  assert.deepEqual(h.focuses, ['n000'])
+  h.view.dispose()
+  assert.equal(h.handlers.size, 0); assert.equal(h.frames.size, 0); assert.equal(h.windowHandlers.size, 0)
+})
+
+test('pan/zoom and equivalent refresh never re-fit the camera; cancelled pointer never clicks', () => {
+  const h = harness()
+  h.view.update(graph(1)); h.flush()
+  const before = { ...h.arcs[0] }
+  h.emit('pointerdown', 30, 30); h.emit('pointermove', 70, 60); h.emit('pointerup', 70, 60); h.flush()
+  assert.equal(h.arcs[0].x, before.x + 40); assert.equal(h.arcs[0].y, before.y + 30)
+  h.view.zoom(.8); h.flush()
+  const zoomed = { ...h.arcs[0] }
+  h.view.update(graph(1)); h.flush()
+  assert.deepEqual(h.arcs[0], zoomed)
+  h.emit('pointerdown', zoomed.x, zoomed.y); h.emit('pointercancel', zoomed.x, zoomed.y)
+  assert.deepEqual(h.focuses, [])
+  h.view.dispose()
+})
+
+test('dense hit targets choose the closest node, not the last node in draw order', () => {
+  const h = harness()
+  h.view.update(graph(2)); h.view.zoom(.04); h.flush()
+  const p = h.arcs[0], other = h.arcs[1]
+  assert.ok(Math.hypot(other.x - p.x, other.y - p.y) < 10)
+  h.emit('pointerdown', p.x, p.y); h.emit('pointerup', p.x, p.y)
+  assert.deepEqual(h.focuses, ['n000'])
+  h.view.dispose()
+})
+
+test('pinch does not trigger focus and reduced-motion/paused views do not run an idle animation loop', () => {
+  const h = harness()
+  h.view.update(graph(10)); h.flush()
+  assert.equal(h.frames.size, 0)
+  const p = h.arcs[0]
+  h.emit('pointerdown', p.x, p.y, { pointerType: 'touch' })
+  h.emit('pointerdown', p.x + 40, p.y, { pointerType: 'touch', pointerId: 2 })
+  h.emit('pointermove', p.x + 80, p.y, { pointerType: 'touch', pointerId: 2 })
+  h.emit('pointerup', p.x, p.y)
+  h.emit('pointerup', p.x + 80, p.y, { pointerId: 2 })
+  assert.deepEqual(h.focuses, [])
+  h.view.dispose()
+  const paused = harness(false)
+  paused.view.configure({ motion: false }); paused.view.update(graph(10)); paused.flush()
+  assert.equal(paused.frames.size, 0)
+  paused.view.dispose()
+})
+
+test('shipped browser bundle exposes the controller with no runtime npm imports', () => {
+  const source = fs.readFileSync(new URL('../lib/webui/graph-view.bundle.js', import.meta.url), 'utf8')
+  const scope = { setTimeout, clearTimeout, setInterval, clearInterval, performance }
+  vm.runInNewContext(source, scope)
+  assert.equal(typeof scope.DshMemuGraph.createGraphView, 'function')
+  assert.equal(typeof scope.DshMemuGraph.createLayout, 'function')
+})

package/tests/graph.test.mjs

@@ -0,0 +1,94 @@
+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-'))
+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')
+test.after(() => { state.flushState(); fs.rmSync(home, { recursive: true, force: true }) })
+const binding = state.ensureSession('graph', { cwd: path.join(home, 'rp'), agentPreset: 'rp' })
+const libraryId = binding.libraryId
+const exec = { agent: { session: { header: { id: 'graph' } } } }
+const entries = Object.fromEntries(Array.from({ length: 10 }, (_, i) => [`mem-${i}`, { title: `person ${i}`, content: `scene ${i}`, layer: 'long_term', status: 'active', visibility: 'shared' }]))
+state.savePrivateIndex(libraryId, { entries })
+
+test('graph stores one direction but queries both within bounded hops', () => {
+  for (let i = 0; i < 9; i++) graph.linkEntries({ libraryId, fromId: `mem-${i}`, toId: `mem-${i + 1}`, kind: 'event', note: 'The same event seen from another side.' })
+  const result = graph.getGraph({ libraryId, focusId: 'mem-4', depth: 1 })
+  assert.deepEqual(new Set(result.nodes.map(node => node.id)), new Set(['mem-3', 'mem-4', 'mem-5']))
+  assert.equal(result.edges.length, 2)
+  assert.equal(state.loadPrivateIndex(libraryId).entries['mem-5'].links.length, 1)
+})
+
+test('deleted memories remain gray dangling nodes rather than hiding the edge', () => {
+  state.updatePrivateIndex(libraryId, index => { delete index.entries['mem-1'] })
+  const result = graph.getGraph({ libraryId, focusId: 'mem-0', depth: 1 })
+  assert.equal(result.nodes.find(node => node.id === 'mem-1').missing, true)
+  assert.equal(result.edges.length, 1)
+})
+
+test('entity rename changes all references without rewriting memory text', async () => {
+  const entity = graph.createEntity({ libraryId, name: 'Old Zhou' })
+  graph.linkEntries({ libraryId, fromId: 'mem-2', toId: entity.id, kind: 'person', note: 'Old Zhou is the person mentioned here.' })
+  graph.renameEntity({ libraryId, entityId: entity.id, name: 'Zhou', aliases: ['Old Zhou'] })
+  assert.equal(graph.getGraph({ libraryId, focusId: entity.id }).nodes.find(node => node.id === entity.id).title, 'Zhou')
+  assert.equal(state.loadPrivateIndex(libraryId).entries['mem-2'].content, 'scene 2')
+  assert.equal((await memory.privateRecall({ exec, query: 'mem-2' })).files[0].related.find(item => item.id === entity.id).title, 'Zhou')
+})
+
+test('invalid kinds, empty reasons and out-of-scope private links are rejected', () => {
+  assert.throws(() => graph.linkEntries({ libraryId, fromId: 'mem-2', toId: 'mem-3', kind: 'typo', note: 'explanation' }), /link kind/)
+  assert.throws(() => graph.linkEntries({ libraryId, fromId: 'mem-2', toId: 'mem-3', kind: 'event', note: '' }), /8-500/)
+  // The remaining boundary is the context scope: this entry belongs to another character,
+  // and this conversation has no context at all, so it must stay unreachable.
+  state.updatePrivateIndex(libraryId, index => { index.entries.secret = { title: 'private title', status: 'active', visibility: 'secret', context: { characterId: 'other' } } })
+  assert.throws(() => graph.linkEntries({ exec, fromId: 'mem-2', toId: 'secret', kind: 'event', note: 'a very long explanation' }), /inaccessible/)
+  assert.ok(!JSON.stringify(graph.getGraph({ exec })).includes('private title'))
+})
+
+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' }
+  })
+  const result = graph.getGraph({ libraryId, limit: 5000 })
+  assert.equal(result.nodes.length, 200)
+  assert.equal(result.truncated, true)
+  assert.ok((await memory.privateRecall({ exec, query: 'mem-2' })).files[0].related.length <= 2)
+})
+
+test('relationship snapshots preserve unknowns, evidence, boundaries and previous versions', () => {
+  const a = graph.createEntity({ libraryId, name: 'A' })
+  const b = graph.createEntity({ libraryId, name: 'B' })
+  const initial = graph.updateRelationship({ libraryId, fromId: a.id, toId: b.id,
+    state: { trust: .7, boundaries: ['Do not volunteer private stories.'], openPromises: ['Answer on Friday.'] },
+    evidenceIds: ['mem-2'], reason: 'Friday promise is explicit evidence.' }).relationship
+  assert.equal(initial.state.warmth, null, 'unknown is not a neutral or affectionate score')
+  graph.updateRelationship({ libraryId, fromId: a.id, toId: b.id,
+    state: { trust: .75, boundaries: initial.state.boundaries, callbacks: ['the station roof'], openPromises: [] },
+    evidenceIds: ['mem-2'], reason: 'The answer was delivered explicitly.' })
+  const next = graph.getRelationship({ libraryId, fromId: a.id, toId: b.id }).relationship
+  assert.equal(next.history.length, 1)
+  assert.deepEqual(next.history[0].state.openPromises, ['Answer on Friday.'])
+  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)
+})