dsh-memu-memory 1.1.3 → 1.2.1

package/tests/hook-order.test.mjs

@@ -0,0 +1,72 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+
+// 2026-10-30 现场：日志页的 7 个 useState + useEffect 被写在
+// `if (!state) return ...` 之后。首屏少调 10 个 hook、数据到达后多调 10 个，
+// React 抛 #310，整个设置弹窗和 WebUI 白屏，控制台只有一行 minified 报错。
+//
+// 这类 bug 很难被假 React 的渲染用例覆盖（它不校验 hook 顺序），所以用一条静态守卫：
+// 组件函数体内、与组件同级的 React.use* 必须全部出现在提前 return 之前。
+
+const source = fs.readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
+
+// 从 `function Name(` 后的 `{` 开始做括号配对，跳过字符串与注释，拿到精确的函数体。
+function bodyOf(name) {
+  const start = source.indexOf('function ' + name + '(')
+  assert.ok(start > 0, name + ' not found in lib/client.js')
+  let index = source.indexOf('{', source.indexOf(')', start))
+  assert.ok(index > start, name + ' has no function body')
+  const begin = index
+  let depth = 0
+  let quote = null
+  for (; index < source.length; index++) {
+    const ch = source[index]
+    if (quote) {
+      if (ch === '\\') { index++; continue }
+      if (ch === quote) quote = null
+      continue
+    }
+    if (ch === "'" || ch === '"' || ch === '\u0060') { quote = ch; continue }
+    if (ch === '/' && source[index + 1] === '/') {
+      const newline = source.indexOf('\n', index)
+      index = newline < 0 ? source.length : newline
+      continue
+    }
+    if (ch === '/' && source[index + 1] === '*') {
+      const close = source.indexOf('*/', index + 2)
+      index = close < 0 ? source.length : close + 1
+      continue
+    }
+    if (ch === '{') depth += 1
+    else if (ch === '}') {
+      depth -= 1
+      if (depth === 0) return source.slice(begin, index + 1)
+    }
+  }
+  assert.fail(name + ' body was never closed')
+}
+
+for (const [name, earlyReturn] of [
+  ['SettingsPage', 'if (!state) return'],
+  ['MemoryTab', 'if (!sessionId) return'],
+]) {
+  test(`${name}: every component-level hook is declared before "${earlyReturn}"`, () => {
+    const body = bodyOf(name)
+    const lines = body.split('\n')
+    // 只认与组件同级（6 空格缩进）的提前 return：注释里也会出现这段文字，
+    // 嵌套回调里的 return 则不影响组件自身的 hook 顺序。
+    const literal = earlyReturn.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const atComponentLevel = new RegExp('^ {6}' + literal + '\\b')
+    const retLine = lines.findIndex(line => atComponentLevel.test(line))
+    assert.ok(retLine > 0, `${name} no longer contains "${earlyReturn}" — update this guard instead of deleting it`)
+    const later = []
+    for (let line = retLine + 1; line < lines.length; line++) {
+      // 同级 hook 缩进固定为 6 个空格（模块工厂内 4 + 函数体 2）；嵌套组件的 hook 更深，
+      // 它们的顺序不受这个提前 return 影响。
+      if (!/^ {6}\S/.test(lines[line])) continue
+      if (/React\.use[A-Z]/.test(lines[line])) later.push(`${line + 1}: ${lines[line].trim().slice(0, 80)}`)
+    }
+    assert.deepEqual(later, [], `${name}: hook after the early return — React #310 blanks the panel. Move it above.\n` + later.join('\n'))
+  })
+}

package/tests/humanlike.test.mjs

@@ -0,0 +1,232 @@
+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-human-'))
+process.env.DSH_MEMU_HOME = home
+
+const state = await import('../lib/state.js')
+const memory = await import('../lib/memory.js')
+const inject = await import('../lib/inject.js')
+const rpc = await import('../lib/rpc.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function execFor(sessionId, cwd) {
+  return { agent: { session: { header: { id: sessionId, cwd, agentPreset: 'coding' } } } }
+}
+
+function ageEntry(libraryId, id, days) {
+  const index = state.loadPrivateIndex(libraryId)
+  const at = new Date(Date.now() - days * 86_400_000).toISOString()
+  index.entries[id].updatedAt = at
+  index.entries[id].createdAt = at
+  state.savePrivateIndex(libraryId, index)
+}
+
+test('relative time reads like a person, not like a timestamp', () => {
+  const now = Date.parse('2026-10-27T12:00:00.000Z')
+  const ago = (ms) => new Date(now - ms).toISOString()
+  assert.equal(memory.relativeTime(ago(30_000), now), '刚刚')
+  assert.equal(memory.relativeTime(ago(5 * 60_000), now), '5 分钟前')
+  assert.equal(memory.relativeTime(ago(3 * 3_600_000), now), '3 小时前')
+  assert.equal(memory.relativeTime(ago(2 * 86_400_000), now), '2 天前')
+  assert.equal(memory.relativeTime(ago(40 * 86_400_000), now), '1 个月前')
+  // An unparseable stamp must not paint "NaN 天前" into the prompt.
+  assert.equal(memory.relativeTime('not a date', now), '')
+})
+
+test('the injected line carries how old the memory is', async () => {
+  const cwd = path.join(home, 'proj-age')
+  const sessionId = 'age-1'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+  const { id } = await memory.privateRemember({
+    exec, content: 'The rollback drill runs every Friday afternoon.', title: 'rollback drill',
+  })
+  ageEntry(binding.libraryId, id, 4)
+  const anchor = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens: 700 })
+  assert.ok(anchor.text.includes('4 天前'), anchor.text)
+})
+
+test('near-duplicate memories stop eating the recall budget', async () => {
+  const cwd = path.join(home, 'proj-mmr')
+  const sessionId = 'mmr-1'
+  const exec = execFor(sessionId, cwd)
+  const written = []
+  for (const [title, content] of [
+    ['hero plan', 'pricing page rewrite plan for the landing hero'],
+    ['hero plan b', 'pricing page rewrite plan for the landing hero section'],
+    ['hero plan c', 'pricing page rewrite plan for the landing hero area'],
+    ['pricing doc', 'pricing page rewrite plan is written down in docs/pricing.md'],
+  ]) {
+    const { id } = await memory.privateRemember({ exec, content, title })
+    written.push(id)
+  }
+  const result = await memory.privateRecall({
+    exec, query: 'pricing page rewrite plan', topK: 2, relevanceThreshold: 0,
+  })
+  const names = result.files.map((file) => file.name)
+  assert.equal(names.length, 2)
+  assert.ok(names.includes(written[3]), `the distinct memory must survive the near-duplicates, got ${names.join(',')}`)
+})
+
+test('a memory that keeps being pushed fades, and editing it brings it back', async () => {
+  const cwd = path.join(home, 'proj-habit')
+  const sessionId = 'habit-1'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+  const { id } = await memory.privateRemember({
+    exec, content: 'Deploy window notes: staging turns over at noon.', title: 'deploy window',
+  })
+  const scoreOf = async () => {
+    const res = await memory.privateRecall({ exec, query: 'deploy window notes', topK: 3, relevanceThreshold: 0 })
+    const hit = res.files.find((file) => file.name === id)
+    return hit ? hit.score : 0
+  }
+  const fresh = await scoreOf()
+  memory.noteInjected({ libraryId: binding.libraryId, ids: [id] })
+  memory.noteInjected({ libraryId: binding.libraryId, ids: [id] })
+  const dulled = await scoreOf()
+  assert.ok(dulled < fresh, `repeated injection should lower the score (${fresh} -> ${dulled})`)
+
+  // Rewriting the body is the signal that this memory is worth keeping current.
+  await memory.privateUpdate({ exec, id, content: 'Deploy window notes: staging turns over at noon, prod at six.' })
+  const refreshed = await scoreOf()
+  assert.ok(refreshed > dulled, `an edit must clear the habituation (${dulled} -> ${refreshed})`)
+})
+
+test('a context-scoped memory stays inside its character until the user widens it', async () => {
+  const cwd = path.join(home, 'proj-scope')
+  const mine = 'scope-a'
+  const other = 'scope-b'
+  const binding = state.ensureSession(mine, { cwd, agentPreset: 'coding' })
+  const execMine = execFor(mine, cwd)
+  const execOther = execFor(other, cwd)
+  state.ensureSession(other, { cwd, agentPreset: 'coding' })
+  // Both conversations live in one folder. The only thing that may separate them is the
+  // scope: `session` used to, and it did so by making the memory disappear for everyone.
+  state.setSessionBinding(mine, { memoryContext: { characterId: 'hero' } })
+  state.setSessionBinding(other, { memoryContext: { characterId: 'villain' } })
+
+  const { id } = await memory.privateRemember({
+    exec: execMine,
+    content: 'The seal number for this thread is 4471.',
+    title: 'seal number',
+  })
+  const seenByMine = await memory.privateRecall({ exec: execMine, query: 'seal number', topK: 3, relevanceThreshold: 0 })
+  assert.ok(seenByMine.files.some((file) => file.name === id), 'the writing conversation must still see it')
+
+  const seenByOther = await memory.privateRecall({ exec: execOther, query: 'seal number', topK: 3, relevanceThreshold: 0 })
+  assert.equal(seenByOther.files.some((file) => file.name === id), false, 'another character must not see it')
+  const anchorForOther = inject.buildAnchor(state.getSessionBinding(other), { ...state.getSettings(), anchorTokens: 700 }, other)
+  assert.equal(anchorForOther.text.includes(id), false)
+
+  // Only the user can widen a stored boundary; the memory wall has no conversation and
+  // therefore no scope to defend. Widening drops the pointer, it does not copy the entry.
+  await rpc.dispatch({}, 'updateMemory', { libraryId: binding.libraryId, id, patch: { context: {} } })
+  assert.deepEqual(state.loadPrivateIndex(binding.libraryId).entries[id].context, {})
+  const seenAgain = await memory.privateRecall({ exec: execOther, query: 'seal number', topK: 3, relevanceThreshold: 0 })
+  assert.ok(seenAgain.files.some((file) => file.name === id), 'once the user widens it, the folder can read it')
+})
+
+test('an old open loop is raised once, then left alone', async () => {
+  const cwd = path.join(home, 'proj-loop')
+  const sessionId = 'loop-1'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+  const { id } = await memory.privateRemember({
+    exec,
+    content: 'He asked whether the salary review letter ever went out; I never answered.',
+    title: 'salary review letter',
+    openLoop: true,
+  })
+  ageEntry(binding.libraryId, id, 6)
+
+  const first = inject.buildOpenLoopNudge(state.getSessionBinding(sessionId))
+  assert.ok(first.text.includes('[open loop]'), first.text)
+  assert.ok(first.text.includes(id))
+  assert.ok(first.text.includes('没下文了'))
+
+  state.markInjected(sessionId, [id], 3)
+  const second = inject.buildOpenLoopNudge(state.getSessionBinding(sessionId))
+  assert.equal(second.text, '', 'once it has been said, it stops being a nudge')
+})
+
+test('compaction replay replays gists, never whole bodies, and skips secrets', async () => {
+  const cwd = path.join(home, 'proj-replay')
+  const sessionId = 'replay-1'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+  const long = 'X'.repeat(400)
+  const { id: plain } = await memory.privateRemember({
+    exec, content: `BODY-START ${long}`, title: 'long one',
+  })
+  const { id: secret } = await memory.privateRemember({
+    exec, content: 'SECRET-BODY that must stay out of the prompt', title: 'secret one', visibility: 'secret',
+  })
+  state.setSessionBinding(sessionId, { replayIds: [plain, secret] })
+  const replay = inject.buildReplay(state.getSessionBinding(sessionId), state.getSettings(), sessionId)
+  assert.ok(replay.text.includes('[replay'), replay.text)
+  assert.ok(replay.text.includes(plain))
+  assert.equal(replay.text.includes('X'.repeat(120)), false, 'a replay is a gist, not the body')
+  assert.equal(replay.text.includes(secret), false)
+  assert.equal(replay.text.includes('SECRET-BODY'), false)
+  assert.ok(binding.libraryId)
+})
+
+test('import restores what can travel and reports what cannot', async () => {
+  const cwd = path.join(home, 'proj-import')
+  const sessionId = 'import-1'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+  // Already here: the duplicate check has to look at the target library, not just the file.
+  await memory.privateRemember({ exec, content: 'pricing thread body about the hero', title: 'pricing thread' })
+
+  const result = await memory.importMemories({
+    libraryId: binding.libraryId,
+    memories: [
+      { id: 'old-1', title: 'pricing thread', content: 'pricing thread body about the hero', layer: 'long_term' },
+      { id: 'old-2', title: 'pricing thread copy', content: 'pricing thread body about the hero' },
+      { id: 'old-3', title: 'archived one', content: 'dead content', status: 'archived' },
+      { id: 'old-4', title: 'session note', content: 'session bound body', visibility: 'session' },
+      { id: 'old-5', content: '   ' },
+      { id: 'old-6', title: 'draft', content: 'draft body that expires', layer: 'short_term', expiresAt: new Date(Date.now() + 3_600_000).toISOString() },
+      { id: 'old-7', title: 'unique', content: 'a body nobody here has ever written' },
+    ],
+  })
+
+  assert.equal(result.imported, 3, JSON.stringify(result.counts))
+  assert.equal(result.counts.duplicate, 2)
+  assert.equal(result.counts.dead, 1)
+  assert.equal(result.counts.invalid, 1)
+  // A `session` entry from an older export lands as `shared` with the same marker a stored
+  // entry gets: dropping it silently would be the very data loss this upgrade prevents,
+  // and the report still has to say that its reader went from one conversation to a folder.
+  assert.equal(result.counts.downgraded, 1)
+
+  const index = state.loadPrivateIndex(binding.libraryId)
+  const entries = Object.entries(index.entries)
+  const restored = entries.filter(([, entry]) => entry.importedFrom)
+  assert.equal(restored.length, 3)
+  const kept = state.loadPrivateIndex(binding.libraryId).entries
+  const fromSession = Object.values(kept).find((entry) => entry.importedFrom === 'old-4')
+  assert.equal(fromSession.visibility, 'shared', 'the removed level has to come back as shared')
+  assert.equal(fromSession.migratedFromVisibility, 'session')
+  assert.equal('sessionId' in fromSession, false)
+  assert.ok(result.examples.downgraded.some((line) => line.includes('session note')), 'the report has to name what changed level')
+  assert.ok(result.examples.downgraded.some((line) => line.includes('session -> shared')))
+  const draft = restored.find(([, entry]) => entry.importedFrom === 'old-6')
+  assert.equal(draft[1].layer, 'short_term')
+  const hours = (Date.parse(draft[1].expiresAt) - Date.now()) / 3_600_000
+  assert.ok(hours > 0 && hours <= 1, `the earlier deadline wins, got ${hours}h`)
+  const unique = restored.find(([, entry]) => entry.importedFrom === 'old-7')
+  assert.ok(unique[1].content.includes('a body nobody here has ever written'), 'the body has to survive the restore')
+
+  const recall = await memory.privateRecall({ exec, query: 'body nobody ever written', topK: 3, relevanceThreshold: 0 })
+  assert.ok(recall.files.some((file) => file.name === unique[0]), 'a restored memory must be retrievable')
+})

package/tests/hybrid-recall.test.mjs

@@ -0,0 +1,122 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+const memory = await import('../lib/memory.js')
+
+function entry(overrides = {}) {
+  return { status: 'active', title: 'memory', content: 'memory body', createdAt: '2026-10-01T00:00:00.000Z', updatedAt: '2026-10-01T00:00:00.000Z', ...overrides }
+}
+
+function indexOf(entries) {
+  return { entries }
+}
+
+test('RRF keeps one canonical id when both routes find it and preserves the best order', () => {
+  const index = indexOf({
+    'mem-a': entry({ title: 'alpha' }),
+    'mem-b': entry({ title: 'beta' }),
+    'mem-c': entry({ title: 'gamma' }),
+  })
+  const fused = memory.fuseRecallCandidates({
+    local: [{ name: 'mem-a' }, { name: 'mem-b' }],
+    semantic: [{ name: 'mem-b.md' }, { name: 'mem-c' }],
+    index,
+    limit: 12,
+  })
+  assert.deepEqual(fused.files.map((file) => file.name), ['mem-b', 'mem-a', 'mem-c'])
+  assert.equal(fused.files[0].retrievalScore, 1)
+  assert.deepEqual(fused.files[0].fusion.routes, ['local', 'semantic'])
+  assert.equal(fused.debug.shared, 1)
+  assert.equal(fused.debug.localOnly, 1)
+  assert.equal(fused.debug.semanticOnly, 1)
+  assert.equal(fused.debug.fused, 3)
+})
+
+test('duplicate names within one route cannot double-score or consume a candidate slot', () => {
+  const index = indexOf({ 'mem-a': entry({ title: 'alpha' }), 'mem-b': entry({ title: 'beta' }) })
+  const fused = memory.fuseRecallCandidates({
+    local: [{ name: 'mem-a' }, { name: 'mem-a.md' }, { name: 'mem-b' }],
+    semantic: [],
+    index,
+    limit: 2,
+  })
+  assert.deepEqual(fused.files.map((file) => file.name), ['mem-a', 'mem-b'])
+  assert.equal(fused.debug.localCandidates, 2)
+  const first = fused.files.find((file) => file.name === 'mem-a')
+  assert.equal(first.fusion.rrf, 1 / 61)
+  assert.equal(first.fusion.bestRank, 1)
+  assert.equal(first.fusion.localRank, 1)
+})
+
+test('eligibility and context are applied before the candidate cap', () => {
+  const index = indexOf({
+    'mem-pending': entry({ status: 'pending_review' }),
+    'mem-secret': entry({ visibility: 'secret' }),
+    'mem-ok': entry({ title: 'ok' }),
+  })
+  const fused = memory.fuseRecallCandidates({
+    local: [{ name: 'mem-pending' }, { name: 'mem-secret' }, { name: 'mem-ok' }],
+    semantic: [{ name: 'mem-secret' }],
+    index,
+    limit: 12,
+    automatic: true,
+  })
+  assert.deepEqual(fused.files.map((file) => file.name), ['mem-ok'])
+  assert.equal(fused.debug.localCandidates, 1)
+  assert.equal(fused.debug.semanticCandidates, 0)
+})
+
+test('the per-route candidate cap is bounded and deterministic', () => {
+  const entries = {}
+  const local = []
+  // Distinct bodies: near-identical candidates would fold into one cluster slot
+  // (fact-level dedup), and this test is about the cap, not the folding.
+  const alphabet = 'abcdefghijklmnopqrstuvwxyz'
+  const token = (n) => alphabet[n % 26] + alphabet[Math.floor(n / 26) % 26]
+  for (let i = 0; i < 60; i += 1) {
+    const id = 'mem-' + String(i).padStart(2, '0')
+    entries[id] = entry({
+      title: 'topic ' + token(180 + i),
+      content: [token(3 * i), token(3 * i + 1), token(3 * i + 2)].join('of'),
+    })
+    local.push({ name: id })
+  }
+  assert.equal(memory.hybridCandidateLimit(1), 12)
+  assert.equal(memory.hybridCandidateLimit(3), 12)
+  assert.equal(memory.hybridCandidateLimit(8), 32)
+  assert.equal(memory.hybridCandidateLimit(50), 40)
+  const fused = memory.fuseRecallCandidates({ local, semantic: [], index: indexOf(entries), limit: memory.hybridCandidateLimit(3) })
+  assert.equal(fused.files.length, 12)
+  assert.deepEqual(fused.files.map((file) => file.name), local.slice(0, 12).map((file) => file.name).sort((a, b) => a.localeCompare(b)))
+})
+
+test('near-duplicate candidates fold into one candidate slot before the cap', () => {
+  const entries = {}
+  const local = []
+  for (let i = 0; i < 12; i += 1) {
+    const id = 'mem-dup-' + String(i).padStart(2, '0')
+    entries[id] = entry({ title: 'deploy window ' + (i ? 'variant ' + i : ''), content: 'the deploy window is thursday two to four am, grey releases only' })
+    local.push({ name: id })
+  }
+  entries['mem-real'] = entry({ title: 'reimbursement deadline', content: 'expense reports are due before the last working day of each month' })
+  const fused = memory.fuseRecallCandidates({ local: [...local, { name: 'mem-real' }], semantic: [], index: indexOf(entries), limit: 12 })
+  // The cluster spends one slot instead of twelve, so the real memory enters
+  // even though 13 candidates competed for 12 places.
+  assert.equal(fused.debug.localCandidates, 2)
+  assert.deepEqual(fused.files.map((file) => file.name), ['mem-dup-00', 'mem-real'])
+  assert.deepEqual(fused.debug.collapsed, [{ kept: 'mem-dup-00', dropped: local.slice(1).map((file) => file.name) }])
+  assert.equal(fused.debug.clusterCount, 1)
+})
+
+test('equal fused scores fall back to the best rank and then the canonical id', () => {
+  // Distinct texts: two byte-identical memories would fold as one fact before
+  // the tie-break this test is about ever gets a chance to run.
+  const index = indexOf({
+    'mem-a': entry({ title: 'alpha topic', content: 'alpha body' }),
+    'mem-b': entry({ title: 'beta topic', content: 'beta body' }),
+  })
+  const first = memory.fuseRecallCandidates({ local: [{ name: 'mem-a' }], semantic: [{ name: 'mem-b' }], index })
+  const second = memory.fuseRecallCandidates({ local: [{ name: 'mem-a' }], semantic: [{ name: 'mem-b' }], index })
+  assert.deepEqual(first.files.map((file) => file.name), ['mem-a', 'mem-b'])
+  assert.deepEqual(first.files.map((file) => file.name), second.files.map((file) => file.name))
+})