dsh-memu-memory 1.1.3 → 1.2.1

package/tests/sidebar-refresh.test.mjs

@@ -0,0 +1,123 @@
+// The sidebar painted one snapshot and never heard about a write again: a memory
+// added in the browser, or by the model mid-turn, stayed invisible until the tab
+// was remounted. The first fix was a monotonic revision the reader polls — but that
+// counter only moves in the process that wrote, so a tool call served elsewhere left
+// the panel stale anyway. These cases pin all three halves: the counter moves on
+// every write this process makes, the on-disk stamp moves for writes it did not
+// make, and the heartbeat stays a bare marker with no entry bodies in 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-sidebar-refresh-'))
+process.env.DSH_MEMU_HOME = home
+
+const {
+  createLibrary, ensureSession, loadPrivateIndex, savePrivateIndex, saveGlobalIndex, saveState, memoryRevision,
+  memoryStamp, clearCaches, syncActivity,
+} = await import('../lib/state.js')
+const { privateRemember } = await import('../lib/memory.js')
+const { dispatch } = await import('../lib/rpc.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function fixture(name) {
+  const cwd = path.join(home, name)
+  const lib = createLibrary({ name, cwd })
+  const sessionId = name + '-session'
+  ensureSession(sessionId, { cwd, libraryId: lib.id })
+  return { cwd, lib, sessionId }
+}
+
+test('the heartbeat is a bare marker and needs no session', async () => {
+  fixture('refresh-a')
+  // Every pane polls this marker — the sidebar, the settings page, and the
+  // standalone WebUI. Only the settings page and the WebUI have no conversation,
+  // so the marker itself must not demand one; the full first screen still does.
+  const beat = await dispatch({}, 'getSidebarState', { revisionOnly: true })
+  // Two fields, both tiny: the in-process counter and the on-disk fingerprint that
+  // a second window or a curator job can move.
+  assert.deepEqual(Object.keys(beat), ['revision', 'stamp'], 'the heartbeat must not carry entries')
+  assert.equal(typeof beat.revision, 'number')
+  assert.equal(typeof beat.stamp, 'string')
+  assert.equal(typeof syncActivity().lastBeatAt, 'number', 'a beat is recorded for memu_status')
+  await assert.rejects(
+    async () => { await dispatch({}, 'getSidebarState', {}) },
+    /requires a sessionId/,
+    'the full first screen still belongs to one conversation',
+  )
+})
+
+test('a write records an event memu_status can show', async () => {
+  const { lib, sessionId, cwd } = fixture('refresh-write')
+  const exec = { agent: { session: { header: { id: sessionId, cwd, agentPreset: 'coding' } } } }
+  await privateRemember({ exec, content: '用户偏好周五下午整理下周计划，不要安排会议', title: '周五整理' })
+  const activity = syncActivity()
+  assert.equal(activity.lastWrite?.kind, 'private', 'the write event names what was written')
+  assert.equal(activity.lastWrite?.libraryId, lib.id, 'and which library it belongs to')
+  assert.equal(typeof activity.lastWrite?.at, 'number')
+})
+
+test('a private write moves the revision and lands in the next full read', async () => {
+  const { lib, sessionId, cwd } = fixture('refresh-b')
+  const before = (await dispatch({}, 'getSidebarState', { sessionId })).revision
+  const exec = { agent: { session: { header: { id: sessionId, cwd, agentPreset: 'coding' } } } }
+  await privateRemember({ exec, content: '用户偏好周五下午整理下周计划，不要安排会议', title: '周五整理' })
+  assert.equal(loadPrivateIndex(lib.id).entries ? Object.keys(loadPrivateIndex(lib.id).entries).length : 0, 1)
+  const beat = await dispatch({}, 'getSidebarState', { sessionId, revisionOnly: true })
+  assert.ok(beat.revision > before, 'writing a memory must move the revision')
+  const full = await dispatch({}, 'getSidebarState', { sessionId })
+  assert.equal(full.revision, beat.revision, 'the full read must report the revision it painted')
+  assert.equal(full.private.items.length, 1, 'the new memory must be on the first screen')
+  assert.match(full.private.items[0].preview, /周五下午/)
+})
+
+test('archiving through the browser also moves it', async () => {
+  const { lib, sessionId } = fixture('refresh-c')
+  const index = loadPrivateIndex(lib.id)
+  index.entries['mem-refresh-1'] = { layer: 'long_term', title: 'old', content: 'body', status: 'active', createdAt: '2026-10-01T00:00:00.000Z' }
+  savePrivateIndex(lib.id, index)
+  const before = (await dispatch({}, 'getSidebarState', { sessionId })).revision
+  await dispatch({}, 'archiveMemory', { libraryId: lib.id, id: 'mem-refresh-1' })
+  assert.ok((await dispatch({}, 'getSidebarState', { sessionId, revisionOnly: true })).revision > before)
+  const full = await dispatch({}, 'getSidebarState', { sessionId })
+  assert.equal(full.private.items.length, 0, 'an archived entry must leave the list')
+})
+
+test('the global index and state.json writes move it too', async () => {
+  fixture('refresh-d')
+  const a = memoryRevision()
+  saveGlobalIndex({ version: 1, entries: {} })
+  assert.ok(memoryRevision() > a, 'a global write must move the revision')
+  const b = memoryRevision()
+  saveState(Object.assign({}, JSON.parse(JSON.stringify({})), { sessions: {}, libraries: {}, settings: {} }))
+  assert.ok(memoryRevision() > b, 'a state write (folder policy, binding) must move the revision')
+})
+
+test('the stamp hears a write this process never made', async () => {
+  const { lib, sessionId } = fixture('refresh-e')
+  const beat = await dispatch({}, 'getSidebarState', { sessionId, revisionOnly: true })
+  assert.equal(beat.stamp, memoryStamp(), 'the beat and a direct read agree on the stamp')
+  assert.equal(beat.stamp, memoryStamp(), 'reading the stamp changes nothing')
+
+  // Write the index straight to disk, the way another process or module instance
+  // would: no savePrivateIndex, so this process's counter never moves.
+  const index = loadPrivateIndex(lib.id)
+  index.entries['mem-outside-1'] = {
+    layer: 'long_term', title: 'outside', content: 'written elsewhere', status: 'active', createdAt: '2026-10-02T00:00:00.000Z',
+  }
+  fs.writeFileSync(path.join(home, 'index', lib.id + '.json'), JSON.stringify(index, null, 2))
+
+  const after = await dispatch({}, 'getSidebarState', { sessionId, revisionOnly: true })
+  assert.equal(after.revision, beat.revision, 'the per-process counter deliberately stands still')
+  assert.notEqual(after.stamp, beat.stamp, 'the stamp is the half another process can move')
+
+  clearCaches()
+  const full = await dispatch({}, 'getSidebarState', { sessionId })
+  assert.equal(full.stamp, after.stamp, 'the refetch reports the stamp it painted')
+  assert.equal(full.private.items.length, 1, 'the outside write shows up on the next full read')
+})

package/tests/sidebar.test.mjs

@@ -0,0 +1,70 @@
+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-sidebar-'))
+process.env.DSH_MEMU_HOME = home
+
+const state = await import('../lib/state.js')
+const { dispatch } = await import('../lib/rpc.js')
+
+test.after(() => {
+  try { state.flushState() } catch {}
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+test('the sidebar first screen never lists conversations', async () => {
+  const cwd = path.join(home, 'proj')
+  const binding = state.ensureSession('sidebar-1', { cwd, agentPreset: 'coding' })
+  state.updatePrivateIndex(binding.libraryId, (index) => {
+    for (let i = 0; i < 40; i++) {
+      index.entries[`mem-${i}`] = {
+        id: `mem-${i}`, title: `记忆 ${i}`, content: 'x'.repeat(400),
+        layer: 'long_term', status: 'active', updatedAt: '2026-10-02T00:00:00.000Z',
+      }
+    }
+  })
+
+  // Listing sessions reads every session and its title snapshots — the thing that
+  // made opening the sidebar take seconds. It must not be called here at all.
+  let called = false
+  const ctx = {
+    get: (name) => (name === 'sessionQuery'
+      ? { listSessions: async () => { called = true; throw new Error('must not be called') } }
+      : undefined),
+  }
+
+  const started = Date.now()
+  const view = await dispatch(ctx, 'getSidebarState', { sessionId: 'sidebar-1' })
+  const elapsed = Date.now() - started
+
+  assert.equal(called, false, 'getSidebarState must not list conversations')
+  assert.ok(elapsed < 500, `first screen took ${elapsed}ms`)
+  assert.equal(view.private.active, 40)
+  assert.equal(view.private.items.length, 40)
+  // Previews are truncated: shipping full bodies is what made the panel heavy.
+  assert.ok(view.private.items[0].preview.length <= 160)
+  assert.equal(view.sessions, undefined)
+  assert.equal(view.libraries, undefined)
+})
+
+test('a large library still returns a bounded first screen', async () => {
+  const cwd = path.join(home, 'proj-big')
+  const binding = state.ensureSession('sidebar-2', { cwd })
+  state.updatePrivateIndex(binding.libraryId, (index) => {
+    for (let i = 0; i < 500; i++) {
+      index.entries[`big-${i}`] = {
+        id: `big-${i}`, title: `big ${i}`, content: 'y'.repeat(300),
+        layer: 'long_term', status: 'active', updatedAt: '2026-10-02T00:00:00.000Z',
+      }
+    }
+  })
+  const started = Date.now()
+  const view = await dispatch({}, 'getSidebarState', { sessionId: 'sidebar-2', limit: 100 })
+  const elapsed = Date.now() - started
+  assert.ok(elapsed < 500, `500-entry library took ${elapsed}ms`)
+  assert.equal(view.private.active, 500)
+  assert.equal(view.private.items.length, 100, 'the payload is capped, the count is not')
+})

package/tests/snippet.test.mjs

@@ -0,0 +1,47 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+const { queryTerms, firstHit, centeredSnippet } = await import('../lib/snippet.js')
+
+test('query terms drop noise and keep the long phrase as a fallback', () => {
+  const terms = queryTerms('where a is the deploy key?')
+  assert.ok(terms.includes('deploy'))
+  // Single characters are noise; two-character words stay because they are real
+  // words in Chinese queries (需求, 计划).
+  assert.ok(!terms.includes('a'))
+  assert.ok(queryTerms('改 需求').includes('需求'))
+  assert.equal(terms[0], 'where a is the deploy key?', 'the whole query survives as the longest fallback term')
+  assert.deepEqual(queryTerms('   '), [])
+})
+
+test('a hit is shown with room on both sides', () => {
+  const text = 'A'.repeat(200) + '不想再改需求' + 'B'.repeat(200)
+  const out = centeredSnippet(text, '不想再改需求')
+  assert.ok(out.includes('不想再改需求'), 'the hit itself is always inside the snippet')
+  assert.ok(out.length < 200, 'the two hundred As are not the interesting part')
+  assert.ok(out.startsWith('…') && out.endsWith('…'), 'both ends were cut')
+  // 40 before plus the hit plus 120 after, plus the two ellipses.
+  assert.ok(out.length >= 160 && out.length <= 165)
+})
+
+test('a query with no hit falls back to the head instead of an empty string', () => {
+  const text = 'A'.repeat(300)
+  const out = centeredSnippet(text, 'mysql replication lag')
+  assert.equal(out, 'A'.repeat(160) + '…')
+})
+
+test('a hit near the start does not open with an ellipsis', () => {
+  const out = centeredSnippet('deploy key is in the vault ' + 'B'.repeat(300), 'deploy')
+  assert.ok(out.startsWith('deploy key'), 'nothing was cut from the left, so nothing is claimed to be')
+})
+
+test('short text is returned whole', () => {
+  assert.equal(centeredSnippet('the kettle boils slowly', 'kettle'), 'the kettle boils slowly')
+  assert.equal(centeredSnippet('', 'kettle'), '')
+})
+
+test('firstHit is case-insensitive and picks the earliest term', () => {
+  const terms = queryTerms('Vault Ops')
+  assert.equal(firstHit('the vault was rotated', terms), 4)
+  assert.equal(firstHit('nothing here', terms), -1)
+})

package/tests/source-kind.test.mjs

@@ -0,0 +1,52 @@
+// Guards the message-source format that v4 of the host accepts. A v3 source
+// (`{ kind: 'plugin', plugin: 'dsh-memu-memory' }`) is rejected at runtime with
+// "format v4 message requires a producer-owned source kind" and the visible
+// symptom is a conversation that will not open, so this must never reach a build.
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'lib')
+const files = fs.readdirSync(root).filter((name) => name.endsWith('.js'))
+
+// Mirrors the host's KNOWN_FORMS.
+const KNOWN_FORMS = new Set(['instructions', 'catalog', 'snapshot', 'notice', 'relay', 'recall'])
+
+test('no v3 plugin source kind survives anywhere in lib/', () => {
+  for (const name of files) {
+    const text = fs.readFileSync(path.join(root, name), 'utf8')
+    assert.doesNotMatch(text, /kind\s*:\s*['"]plugin['"]/, `${name} still builds a v3 source kind`)
+    assert.doesNotMatch(text, /kind\s*:\s*['"]plugin['"]\s*,\s*plugin\s*:/, `${name} still passes a bare plugin name`)
+  }
+})
+
+test('every emitted source kind is producer-owned', () => {
+  for (const name of files) {
+    const text = fs.readFileSync(path.join(root, name), 'utf8').replaceAll('plugin:${PLUGIN}', 'plugin:dsh-memu-memory')
+    for (const match of text.matchAll(/kind\s*:\s*[`'"]([^`'"]+)[`'"]/g)) {
+      const kind = match[1]
+      // Only source kinds are producer-owned; other `kind` fields (decisions,
+      // tool results) are unrelated and never contain a colon.
+      if (!kind.includes(':') && kind !== 'plugin') continue
+      assert.match(kind, /^plugin:[a-z0-9-]+$/, `${name} emits a source kind that is not producer-owned: ${kind}`)
+    }
+  }
+})
+
+test('every injected message uses a form the host knows', () => {
+  for (const name of files) {
+    const text = fs.readFileSync(path.join(root, name), 'utf8')
+    for (const match of text.matchAll(/form\s*:\s*['"]([^'"]+)['"]/g)) {
+      assert.ok(KNOWN_FORMS.has(match[1]), `${name} uses unknown message form: ${match[1]}`)
+    }
+  }
+})
+
+test('the plugin name is the one the source kind advertises', () => {
+  const inject = fs.readFileSync(path.join(root, 'inject.js'), 'utf8')
+  const privateHalf = fs.readFileSync(path.join(root, 'private.js'), 'utf8')
+  assert.match(inject, /const PLUGIN = 'dsh-memu-memory'/)
+  assert.match(privateHalf, /kind: 'plugin:dsh-memu-memory'/)
+})

package/tests/state.test.mjs

@@ -0,0 +1,150 @@
+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-state-'))
+process.env.DSH_MEMU_HOME = home
+
+const state = await import('../lib/state.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+test('same cwd auto-binds to the same library', () => {
+  const cwd = path.join(home, 'project-a')
+  const a = state.ensureSession('state-a', { cwd, agentPreset: 'coding' })
+  const b = state.ensureSession('state-b', { cwd, agentPreset: 'coding' })
+  assert.equal(a.libraryId, b.libraryId)
+  assert.equal(a.domain, 'coding')
+})
+
+test('different cwd gets a different library', () => {
+  const a = state.ensureSession('state-c', { cwd: path.join(home, 'project-b') })
+  const b = state.ensureSession('state-d', { cwd: path.join(home, 'project-c') })
+  assert.notEqual(a.libraryId, b.libraryId)
+})
+
+test('a new memory binding defaults its domain selection to RP, and an explicit choice sticks', () => {
+  const cwd = path.join(home, 'project-domain-default')
+  const binding = state.ensureSession('state-domain-default', { cwd, agentPreset: 'coding' })
+  assert.equal(binding.domain, 'coding', 'the detected domain stays as metadata')
+  assert.equal(binding.domainOverride, 'rp', 'the selector starts on RP')
+  state.setSessionBinding('state-domain-default', { domainOverride: 'general' })
+  const rebound = state.ensureSession('state-domain-default', { cwd, agentPreset: 'coding' })
+  assert.equal(rebound.domainOverride, 'general', 'general is a real explicit choice')
+})
+
+test('deleting a session binding keeps the library', () => {
+  const cwd = path.join(home, 'project-keep')
+  const binding = state.ensureSession('state-keep', { cwd })
+  assert.ok(state.getLibrary(binding.libraryId))
+  state.deleteSessionBinding('state-keep')
+  assert.equal(state.getSessionBinding('state-keep'), null)
+  assert.ok(state.getLibrary(binding.libraryId))
+})
+
+test('the unpin marker is gone from session bindings', () => {
+  const cwd = path.join(home, 'project-trauma')
+  const binding = state.ensureSession('state-trauma', { cwd })
+  // Unpin is the model's own call now; nothing user-side arms it any more.
+  assert.equal(binding.traumaArmed, undefined)
+  assert.equal(binding.traumaArmedAt, undefined)
+  assert.equal(typeof state.armTrauma, 'undefined')
+  assert.equal(typeof state.consumeTrauma, 'undefined')
+})
+
+test('backup creates a timestamped directory', () => {
+  const dest = state.backupDatabases()
+  assert.ok(fs.existsSync(dest))
+  assert.ok(fs.existsSync(path.join(dest, 'index')))
+})
+
+test('memory ids are path-safe', () => {
+  const id = state.newMemoryId('mem')
+  assert.match(id, /^mem-[a-z0-9]+-[a-f0-9]+$/)
+})
+
+test('the no-workspace placeholder stays a key, never a resolved path', () => {
+  assert.equal(state.normalizeCwd('__default__'), '__default__')
+  const lib = state.ensureLibraryForCwd('__default__')
+  assert.equal(lib.scopeKey, '__default__')
+  // Re-asking with nothing at all must land on the same library, not a second one.
+  assert.equal(state.ensureLibraryForCwd(undefined).id, lib.id)
+  assert.equal(state.createLibrary({ scopeKey: '__default__' }).id, lib.id)
+})
+
+test('createLibrary:false binds the session without creating a library', () => {
+  const cwd = path.join(home, 'project-opt-out')
+  const before = state.listLibraries().length
+  const binding = state.ensureSession('state-opt-out', { cwd, createLibrary: false })
+  assert.equal(binding.libraryId, null)
+  assert.equal(binding.useLibrary, true)
+  assert.equal(state.listLibraries().length, before)
+})
+
+test('a folder switch off suppresses auto-creation and is inherited by later sessions', () => {
+  const cwd = path.join(home, 'project-policy')
+  state.setWorkspacePolicy(cwd, { useLibrary: false, useGlobal: false })
+  const binding = state.ensureSession('state-policy', { cwd })
+  assert.equal(binding.libraryId, null)
+  assert.equal(state.effectiveScope(binding).useLibrary, false)
+  assert.equal(state.effectiveScope(binding).useGlobal, false)
+  const policy = state.listWorkspacePolicies().find((item) => item.scopeKey === binding.scopeKey)
+  assert.deepEqual({ useLibrary: policy.useLibrary, useGlobal: policy.useGlobal }, { useLibrary: false, useGlobal: false })
+})
+
+test('a folder switch clamps conversations without rewriting their own choice', () => {
+  const cwd = path.join(home, 'project-policy-existing')
+  const binding = state.ensureSession('state-policy-existing', { cwd })
+  assert.ok(binding.libraryId)
+  assert.equal(binding.useLibrary, true)
+
+  state.setWorkspacePolicy(cwd, { useLibrary: false, useGlobal: false })
+  const after = state.getSessionBinding('state-policy-existing')
+  // The stored wish is untouched — the folder is a ceiling, not an edit.
+  assert.equal(after.useLibrary, true)
+  assert.equal(state.effectiveScope(after).useLibrary, false)
+  assert.equal(state.effectiveScope(after).useGlobal, false)
+
+  // Re-enabling the folder restores each conversation's own choice, not a default.
+  state.setSessionBinding('state-policy-existing', { useLibrary: false })
+  state.setWorkspacePolicy(cwd, { useLibrary: true, useGlobal: true })
+  const restored = state.getSessionBinding('state-policy-existing')
+  assert.equal(state.effectiveScope(restored).useLibrary, false, 'the conversation that opted out stays out')
+})
+
+test('re-binding a session does not reset its switches', () => {
+  const cwd = path.join(home, 'project-sticky-switch')
+  state.ensureSession('state-sticky', { cwd })
+  state.setSessionBinding('state-sticky', { useGlobal: false })
+  // ensureSession runs on every step of every turn.
+  const rebound = state.ensureSession('state-sticky', { cwd, createLibrary: false })
+  assert.equal(rebound.useGlobal, false)
+  assert.equal(rebound.useLibrary, true)
+})
+
+test('an old Default/__default__ binding is renamed to the conversation folder', () => {
+  const cwd = path.join(home, 'project-adopted')
+  const legacy = state.ensureLibraryForCwd('__default__')
+  state.setSessionBinding('state-adopt', { libraryId: legacy.id, scopeKey: '__default__' })
+  const binding = state.ensureSession('state-adopt', { cwd })
+  assert.equal(binding.libraryId, legacy.id)
+  const library = state.getLibrary(legacy.id)
+  assert.equal(library.scopeKey, state.normalizeCwd(cwd))
+  assert.equal(library.name, 'project-adopted')
+})
+
+test('a fresh install starts with the four conveniences enabled', () => {
+  const settings = state.getSettings()
+  assert.equal(settings.autoInstallEngine, true)
+  assert.equal(settings.newSessionPromptDismissed, false)
+  assert.equal(settings.habitsInjection, true)
+  assert.equal(settings.sleepConsolidation, true)
+})
+
+test('vision descriptions are enabled by default and stay inert until an endpoint is configured', () => {
+  assert.equal(state.getSettings().visionCaptionEnabled, true)
+})

package/tests/stats.test.mjs

@@ -0,0 +1,112 @@
+// Task C: the statistics are a sidecar. These cases pin three things: the counters
+// follow what actually happened (write / recall / inject / archive), the daily
+// series is zero-filled and never renders NaN on an empty library, and a damaged
+// stats file degrades the page without touching the memories.
+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-stats-'))
+process.env.DSH_MEMU_HOME = home
+
+const state = await import('../lib/state.js')
+const stats = await import('../lib/stats.js')
+const memory = await import('../lib/memory.js')
+const { dispatch } = await import('../lib/rpc.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function fixture(name) {
+  const cwd = path.join(home, name)
+  const lib = state.createLibrary({ name, cwd })
+  state.ensureSession(`${name}-session`, { cwd, libraryId: lib.id })
+  const exec = { agent: { session: { header: { id: `${name}-session`, cwd, agentPreset: 'coding' } } } }
+  return { lib, cwd, exec }
+}
+
+test('counters follow writes, recalls, injections and archives', async () => {
+  const { lib, exec } = fixture('stats-counts')
+  const written = await memory.privateRemember({
+    exec,
+    content: '周五下午不要安排会议，留给整理下周计划',
+    title: '周五整理',
+    source: 'user_said',
+  })
+  // A tool-driven recall is attention the user asked for; it counts as recalled.
+  await memory.privateRecall({ exec, query: '周五 会议 计划', relevanceThreshold: 0 })
+  // Being pushed into the prompt is the other half.
+  memory.noteInjected({ libraryId: lib.id, ids: [written.id] })
+  memory.privateArchive({ exec, id: written.id })
+
+  const view = await dispatch({}, 'getStats', { libraryId: lib.id, days: 30 })
+  assert.equal(view.totals.written, 1, 'one write')
+  assert.ok(view.totals.recalled >= 1, 'the recall surfaced the entry, got ' + view.totals.recalled)
+  assert.equal(view.totals.injected, 1, 'one injection of one entry')
+  assert.equal(view.totals.archived, 1, 'the archive button counts')
+  assert.equal(view.health.archived, 1, 'and the health block agrees')
+  assert.equal(view.health.active, 0, 'archived entries are not live')
+})
+
+test('a library with no memories still renders zeros, never NaN', async () => {
+  const { lib } = fixture('stats-empty')
+  const view = await dispatch({}, 'getStats', { libraryId: lib.id, days: 30 })
+  assert.equal(view.available, true, 'no stats file yet is not an error')
+  assert.equal(view.days.length, 30, 'the series is still thirty days long')
+  for (const day of view.days) {
+    for (const key of ['written', 'injected', 'recalled', 'archived']) {
+      assert.equal(day[key], 0, `${day.date} ${key} is zero`)
+    }
+  }
+  assert.equal(view.health.total, 0)
+  assert.equal(view.health.avgStrength, 0)
+  assert.deepEqual(view.distribution, [])
+  assert.deepEqual(view.stale, [])
+  assert.deepEqual(view.ratio, { windowDays: 7, written: 0, injected: 0 })
+  assert.ok(!JSON.stringify(view).includes('NaN'), 'no NaN leaked into the payload')
+  assert.ok(!JSON.stringify(view).includes('Infinity'), 'Math.max(...[]) must not leak -Infinity')
+})
+
+test('the daily series rolls at 90 days and the page only asks for 30', () => {
+  const now = new Date('2026-10-28T12:00:00')
+  for (let i = 0; i < 120; i += 1) {
+    stats.bumpStats('lib-roll', 'written', 1, now.getTime() - i * 86_400_000)
+  }
+  const loaded = stats.loadStats('lib-roll')
+  const keys = Object.keys(loaded.days).sort()
+  assert.equal(keys.length, stats.STATS_KEPT_DAYS, 'older days are trimmed on write')
+  assert.equal(keys[0], '2026-07-31', 'the window starts 89 days before the last write')
+  const view = stats.statsView({ libraryId: 'lib-roll', entries: {}, days: 30, now: now.getTime() })
+  assert.equal(view.days.length, 30, 'the page receives thirty days, not ninety')
+  assert.equal(view.days.at(-1).date, '2026-10-28')
+})
+
+test('a damaged stats file degrades the page, not the memories', async () => {
+  const { lib, exec } = fixture('stats-broken')
+  fs.mkdirSync(path.join(home, 'index'), { recursive: true })
+  fs.writeFileSync(stats.statsPath(lib.id), '{"days": ', 'utf8')
+
+  const view = await dispatch({}, 'getStats', { libraryId: lib.id })
+  assert.equal(view.available, false, 'the page is told the numbers are missing')
+  assert.equal(view.days.length, 30, 'and still gets a drawable zero series')
+
+  // The memory path must not care: writing, listing and recalling still work.
+  const written = await memory.privateRemember({ exec, content: '统计坏了也要能写记忆', title: '仍然可写' })
+  assert.ok(written.id)
+  const list = await memory.privateList({ exec })
+  assert.equal(list.files.length, 1, 'the memory was written despite the broken sidecar')
+  await memory.privateRecall({ exec, query: '写记忆', relevanceThreshold: 0 })
+  assert.equal(fs.readFileSync(stats.statsPath(lib.id), 'utf8'), '{"days": ', 'a broken statistics sidecar is left intact')
+})
+
+test('a local archive through an edit counts once', async () => {
+  const { lib, exec } = fixture('stats-edit-archive')
+  const first = await memory.privateRemember({ exec, content: '一条会被编辑归档的记忆', title: '编辑归档' })
+  await memory.privateUpdate({ exec, id: first.id, status: 'archived' })
+  await memory.privateUpdate({ exec, id: first.id, status: 'archived' })
+  const view = await dispatch({}, 'getStats', { libraryId: lib.id })
+  assert.equal(view.totals.archived, 1, 'the same transition does not count twice')
+})