dsh-memu-memory 1.2.1 → 1.2.2

package/tests/inject.test.mjs

@@ -15,7 +15,7 @@ test.after(() => {
   try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
 })
 
-test('anchor includes pinned private memory', () => {
+test('anchor shows a pinned memory as a title card, without its body', () => {
   const cwd = path.join(home, 'project-anchor')
   const binding = state.ensureSession('inject-anchor', { cwd, agentPreset: 'rp' })
   const index = state.loadPrivateIndex(binding.libraryId)
@@ -32,11 +32,131 @@ test('anchor includes pinned private memory', () => {
   }
   state.savePrivateIndex(binding.libraryId, index)
   const anchor = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens: 700 })
+  assert.ok(anchor.text.includes('[mem-test]'), 'the id is the handle the model quotes back')
   assert.ok(anchor.text.includes('凉茶'))
-  assert.ok(anchor.text.includes('今天他走的时候没看我'))
+  assert.equal(anchor.text.includes('今天他走的时候没看我'), false, 'the anchor is a directory; the body stays out')
   assert.ok(anchor.ids.includes('mem-test'))
 })
 
+test('the rule is a preface: before the private header, and it names the recall path', () => {
+  const cwd = path.join(home, 'project-rule')
+  const binding = state.ensureSession('inject-rule', { cwd, agentPreset: 'rp' })
+  const index = state.loadPrivateIndex(binding.libraryId)
+  index.entries['mem-rule'] = {
+    track: 'memory',
+    layer: 'must_remember',
+    title: '规则之下的记忆',
+    content: '这段正文不该出现在锚点里。',
+    status: 'active',
+    pinSource: 'user_explicit',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  }
+  state.savePrivateIndex(binding.libraryId, index)
+  const anchor = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens: 700 })
+  const headerAt = anchor.text.indexOf('===== memory anchor =====')
+  const ruleAt = anchor.text.indexOf('[rule]')
+  const privateAt = anchor.text.indexOf('[private ·')
+  assert.ok(headerAt >= 0, 'the anchor starts with its header')
+  assert.ok(anchor.text.startsWith('===== memory anchor =====\n\n[rule]'), 'the header and rule are separated by a blank line')
+  assert.ok(ruleAt > headerAt && privateAt > ruleAt, 'the rule is read before the memories it governs')
+  assert.match(anchor.text, /\[rule\][^\n]*\n\n\[private ·/, 'the rule and the private section are separated by a blank line')
+  assert.ok(anchor.text.indexOf('[mem-rule]') > privateAt)
+  assert.ok(anchor.text.includes('标题即目录'), 'the rule says the anchor is a table of contents')
+  assert.ok(anchor.text.includes('memu_private_recall 按标题关键词查'), 'and how to get the original text back')
+})
+
+test('an empty title falls back to the first 40 characters of the content', () => {
+  const cwd = path.join(home, 'project-fallback')
+  const binding = state.ensureSession('inject-fallback', { cwd, agentPreset: 'rp' })
+  const content = '他答应过要在雨停之前回来，可是到了第二天早上门口还是空的，只有那把伞靠在墙边。'
+  const now = new Date().toISOString()
+  const index = state.loadPrivateIndex(binding.libraryId)
+  index.entries['mem-fallback'] = {
+    track: 'memory',
+    layer: 'long_term',
+    content,
+    status: 'active',
+    createdAt: now,
+    updatedAt: now,
+  }
+  state.savePrivateIndex(binding.libraryId, index)
+  const anchor = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens: 700 })
+  assert.ok(anchor.text.includes('[mem-fallback]'), 'the core segment is a title card too')
+  assert.ok(anchor.text.includes(content.slice(0, 40)), 'a card with no title is still searchable by its opening words')
+  assert.equal(anchor.text.includes('(untitled)'), false, 'content exists, so the row is never anonymous')
+})
+
+test('title-card lines keep source, disclosure, accuracy and the attachment count', () => {
+  const cwd = path.join(home, 'project-labels')
+  const binding = state.ensureSession('inject-labels', { cwd, agentPreset: 'rp' })
+  const now = new Date().toISOString()
+  const index = state.loadPrivateIndex(binding.libraryId)
+  index.entries['mem-labels'] = {
+    track: 'memory',
+    layer: 'must_remember',
+    title: '他编的那个故事',
+    content: '他说那是真的，但那只是他想出来的。',
+    source: 'imagined',
+    disclosure: 'never_say',
+    accuracy: 0.3,
+    confidence: 0.9,
+    attachments: [
+      { sha256: 'a'.repeat(64) },
+      { sha256: 'b'.repeat(64), caption: 'CAPTION-MUST-NOT-EXPAND' },
+    ],
+    status: 'active',
+    pinSource: 'self',
+    createdAt: now,
+    updatedAt: now,
+  }
+  state.savePrivateIndex(binding.libraryId, index)
+  const anchor = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens: 700 })
+  const line = anchor.text.split('\n').find((row) => row.includes('[mem-labels]'))
+  assert.ok(line, 'the title card exists')
+  assert.ok(line.includes('source=imagined'), 'an imagined memory must not read as a fact')
+  assert.ok(line.includes('记得，但别直接说出口'), 'never_say survives on a title card')
+  assert.ok(line.includes('细节未必准'), 'accuracy still rides on the line')
+  assert.ok(line.includes('附件2'), 'attachments are counted')
+  assert.equal(anchor.text.includes('CAPTION-MUST-NOT-EXPAND'), false, 'captions are expanded only by the full renderer')
+})
+
+test('with the same anchorTokens, title cards expose at least as many ids as full text', () => {
+  const cwd = path.join(home, 'project-compare')
+  const binding = state.ensureSession('inject-compare', { cwd, agentPreset: 'rp' })
+  const now = new Date().toISOString()
+  const index = state.loadPrivateIndex(binding.libraryId)
+  const items = []
+  const body = '这是一段用来占满预算的中文记忆正文，重复几遍让长度足够触发截断。'.repeat(3)
+  for (let i = 0; i < 16; i++) {
+    const id = `mem-cmp-${i}`
+    index.entries[id] = {
+      track: 'memory',
+      layer: 'must_remember',
+      title: `对比记忆 ${i}`,
+      content: `${body} BODY-${i}`,
+      status: 'active',
+      pinSource: 'self',
+      strength: 1 - i / 20,
+      createdAt: now,
+      updatedAt: new Date(Date.now() - i * 60000).toISOString(),
+    }
+    items.push([id, index.entries[id]])
+  }
+  state.savePrivateIndex(binding.libraryId, index)
+  const anchorTokens = 600
+  const anchor = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens })
+  // The old shape was the same head plus the body the card now omits. Pack it into the
+  // *whole* anchor budget (no section headers charged), which is more room than the
+  // full-text anchor ever actually got — so this comparison is deliberately unfair to
+  // the title cards.
+  const legacy = budget.packToBudget(items, anchorTokens, (entry, id) =>
+    `- [${id}] source=${entry.source || 'inferred'} · ${entry.title} · ${entry.layer || 'long_term'}`
+    + (entry.content ? `\n  ${entry.content}` : ''))
+  assert.ok(anchor.ids.length >= legacy.ids.length,
+    `title cards exposed ${anchor.ids.length} ids, full text ${legacy.ids.length}`)
+})
+
 test('pre-step inserts a plugin message before the user message', async () => {
   const cwd = path.join(home, 'project-step')
   const binding = state.ensureSession('inject-step', { cwd, agentPreset: 'coding' })
@@ -84,8 +204,10 @@ test('pre-step inserts a plugin message before the user message', async () => {
   assert.equal(out.messages[1].source.kind, 'user')
 
   const injected = out.messages[0].content[0].text
-  assert.ok(injected.includes('mem-recall'), 'per-turn recall must surface the matching entry')
-  assert.ok(injected.includes('tools/deploy.ps1'))
+  assert.ok(injected.includes('[mem-recall]'), 'per-turn recall must surface the matching entry by id')
+  assert.ok(injected.includes('Deploy convention'), 'the title is what reaches the prompt')
+  assert.equal(injected.includes('The deploy script lives in tools/deploy.ps1'), false,
+    'the turn block is a title card; the body stays behind memu_private_recall')
   assert.ok(state.getSessionBinding('inject-step').injectedIds.includes('mem-recall'))
   assert.equal(state.getSessionBinding('inject-step').lastRecallError, undefined)
 
@@ -93,6 +215,35 @@ test('pre-step inserts a plugin message before the user message', async () => {
   assert.equal(skipped, decision)
 })
 
+test('buildRecall injects the title card, not the body', async () => {
+  const cwd = path.join(home, 'project-recall-title')
+  const binding = state.ensureSession('inject-recall-title', { cwd, agentPreset: 'coding' })
+  const now = new Date().toISOString()
+  const index = state.loadPrivateIndex(binding.libraryId)
+  index.entries['mem-recall-title'] = {
+    track: 'memory',
+    layer: 'long_term',
+    title: '部署脚本的位置',
+    content: 'RECALL-BODY-ONLY 部署脚本放在 tools/deploy.ps1，需要 staging token。',
+    status: 'active',
+    confidence: 0.9,
+    createdAt: now,
+    updatedAt: now,
+  }
+  state.savePrivateIndex(binding.libraryId, index)
+  const exec = { agent: { session: { header: { id: 'inject-recall-title', cwd, agentPreset: 'coding' } } } }
+  const recall = await inject.buildRecall(binding, '部署脚本的位置', 1,
+    { ...state.getSettings(), relevanceThreshold: 0 }, exec, 'inject-recall-title')
+  assert.deepEqual(recall.errors, [])
+  assert.ok(recall.ids.includes('mem-recall-title'))
+  assert.ok(recall.text.includes('部署脚本的位置'), 'the title is the card')
+  assert.ok(recall.text.includes('[mem-recall-title]'), 'the id stays quotable')
+  assert.match(recall.text, /条目是标题卡/, 'the block tells the model how to use a title card')
+  assert.ok(recall.text.includes('memu_private_recall'), 'and which tool returns the body')
+  assert.equal(recall.text.includes('RECALL-BODY-ONLY'), false,
+    'memu_private_recall still returns full text; the turn block does not')
+})
+
 test('a failing recall is recorded instead of disappearing', async () => {
   const cwd = path.join(home, 'project-recall-error')
   const binding = state.ensureSession('inject-recall-error', { cwd, agentPreset: 'coding' })
@@ -215,7 +366,8 @@ test('per-turn mode reads the global layer every turn instead of on the cadence'
 
   const perTurn2 = await inject.buildRecall(binding, query, 2, { ...base, autoInject: 'per-turn' }, exec)
   assert.ok(perTurn2.ids.includes('mem-global-deploy'), 'per-turn recalls the global layer on a plain turn')
-  assert.ok(perTurn2.text.includes('staging deploy token is rotated'))
+  assert.ok(perTurn2.text.includes('Staging token rotation'), 'the global title card arrives')
+  assert.equal(perTurn2.text.includes('rotated every Monday'), false, 'but not its body')
 
   const perTurn5 = await inject.buildRecall(binding, query, 5, { ...base, autoInject: 'per-turn' }, exec)
   assert.ok(perTurn5.ids.includes('mem-global-deploy'), 'and again on the next turn, not only every Nth turn')

package/tests/lexicon-calibrate.test.mjs

@@ -0,0 +1,48 @@
+// Dice 阈值标定脚手架（scripts/lexicon-calibrate.mjs）的轻量 smoke 测试：
+// 只保证脚本独立运行不抛错、产出指标行；标定样本本身是给人看的报告，
+// 不进 npm test 门禁断言（脚本不在此处做阈值回归）。
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const scriptPath = path.join(here, '..', 'scripts', 'lexicon-calibrate.mjs')
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-lexicon-calibrate-smoke-'))
+process.env.DSH_MEMU_HOME = home
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function runCalibrate(args) {
+  return spawnSync(process.execPath, [scriptPath, ...args], {
+    encoding: 'utf8',
+    timeout: 120_000,
+    env: { ...process.env, DSH_MEMU_HOME: fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-lexicon-calibrate-run-')) },
+  })
+}
+
+test('lexicon-calibrate.mjs runs standalone, never touches the caller data dir, and prints the 0.60 metrics', () => {
+  const run = runCalibrate([])
+  assert.equal(run.status, 0, `calibrate exits 0. stderr: ${run.stderr}`)
+  assert.match(run.stdout, /只出报告，不自动改 LEXICON_DICE_THRESHOLD/)
+  assert.match(run.stdout, /正例 16 对，负例 16 对/)
+  assert.match(run.stdout, /当前 0\.60 下的指标：precision=/)
+  // 汇总表覆盖默认阈值扫描 0.55..0.75。
+  for (const threshold of ['0.55', '0.60', '0.65', '0.70', '0.75']) {
+    assert.ok(run.stdout.includes(threshold), `sweep table contains ${threshold}`)
+  }
+})
+
+test('lexicon-calibrate.mjs accepts a --threshold list and still exits cleanly', () => {
+  const run = runCalibrate(['--threshold=0.5,0.62,0.9'])
+  assert.equal(run.status, 0, `stderr: ${run.stderr}`)
+  assert.match(run.stdout, /当前 0\.50 下的指标/, 'the primary threshold is the first given value')
+  for (const threshold of ['0.50', '0.62', '0.90']) {
+    assert.ok(run.stdout.includes(threshold), `sweep table contains ${threshold}`)
+  }
+})

package/tests/lexicon-dedupe.test.mjs

@@ -0,0 +1,171 @@
+// 历史重复词条迁移工具（scripts/lexicon-dedupe.mjs）的端到端测试：
+// 通过子进程跑真实 CLI（dry-run / --apply 两条路径），fixture 直接写
+// data/lexicon/<id>.json，覆盖：可合并重复组、active+sensitive 跳过、
+// 跨作用域同词不合并、pending revision 草稿不当作重复。
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const scriptPath = path.join(here, '..', 'scripts', 'lexicon-dedupe.mjs')
+
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-lexicon-dedupe-'))
+process.env.DSH_MEMU_HOME = home
+
+const state = await import('../lib/state.js')
+const paths = await import('../lib/paths.js')
+const lexicon = await import('../lib/lexicon.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function runCli(args) {
+  return spawnSync(process.execPath, [scriptPath, ...args], {
+    encoding: 'utf8',
+    env: { ...process.env, DSH_MEMU_HOME: home },
+    timeout: 60_000,
+  })
+}
+
+function entryOf(overrides, termId, extra = {}) {
+  return {
+    term: overrides.term,
+    normalizedTerm: lexicon.normalizeLexeme(overrides.term),
+    normalizedAliases: (overrides.aliases || []).map(a => lexicon.normalizeLexeme(a)),
+    kind: 'term',
+    meaning: overrides.meaning || '',
+    usage: overrides.usage || '',
+    aliases: overrides.aliases || [],
+    examples: overrides.examples || [],
+    context: overrides.context || {},
+    knownBy: overrides.knownBy,
+    visibility: 'shared',
+    sensitivity: overrides.sensitivity || 'normal',
+    strength: overrides.strength ?? 0.5,
+    confidence: overrides.confidence ?? 0.7,
+    status: overrides.status || 'active',
+    source: 'user',
+    evidence: overrides.evidence || [],
+    fingerprint: `fp-${termId}`,
+    createdAt: overrides.createdAt || '2026-01-01T00:00:00.000Z',
+    updatedAt: overrides.updatedAt || '2026-01-01T00:00:00.000Z',
+    hitCounts: overrides.hitCounts || { candidate: 0, injection: 0, query: 0 },
+    lastInjectedAt: null,
+    ...extra,
+  }
+}
+
+// ---- fixture：一本含四种形态的词典 ----
+const library = state.createLibrary({ name: 'dedupe-fixture', cwd: path.join(home, 'dedupe') })
+const lexFile = path.join(home, 'lexicon', `${library.id}.json`)
+
+const A1 = 'lex-dup-a1', A2 = 'lex-dup-a2', A3 = 'lex-dup-a3', DRAFT = 'lex-dup-draft'
+const S1 = 'lex-dup-s1', S2 = 'lex-dup-s2'
+const C1 = 'lex-dup-c1', C2 = 'lex-dup-c2'
+
+const fixture = {
+  version: 1,
+  revision: 7,
+  libraryId: library.id,
+  rejected: {
+    'fp-lex-dup-a3': { termId: A3, reason: '历史驳回记录', at: '2026-03-01T00:00:00.000Z' },
+  },
+  terms: {
+    // 组 A：同词同作用域三条（active 旧 / active 新 / rejected）+ 一条 active 的待审修订草稿。
+    [A1]: entryOf({ term: '糖刀', meaning: '短义', aliases: ['糖里藏刀'], strength: 0.3, status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' }, A1),
+    [A2]: entryOf({ term: '糖刀', meaning: '较长的保留条目含义', aliases: [], examples: ['保留条目的例句'], strength: 0.9, status: 'active', updatedAt: '2026-02-01T00:00:00.000Z' }, A2),
+    [A3]: entryOf({
+      term: '糖刀',
+      meaning: '被驳回条目里最长的含义文本，合并时应当胜出成为保留条目的含义',
+      aliases: ['刀里藏糖'],
+      examples: ['驳回条目的例句'],
+      strength: 0.5,
+      status: 'rejected',
+      evidence: [{ kind: 'message', id: 'm-1', quote: '这条留言是证据' }],
+      hitCounts: { candidate: 4, injection: 1, query: 2 },
+      updatedAt: '2026-03-01T00:00:00.000Z',
+    }, A3),
+    // 待审修订草稿（revisionOf 指向 A2）：不是重复，必须原样保留。
+    [DRAFT]: entryOf({ term: '糖刀', meaning: '草稿含义', status: 'pending', updatedAt: '2026-04-01T00:00:00.000Z' }, DRAFT, { revisionOf: A2, previousRevision: 6 }),
+    // 组 S：active+sensitive 与其 pending 重复 → 整组跳过。
+    [S1]: entryOf({ term: '红牌', meaning: '敏感触发词', kind: 'trigger', sensitivity: 'sensitive', status: 'active' }, S1),
+    [S2]: entryOf({ term: '红牌', meaning: '重复的敏感触发词', kind: 'trigger', sensitivity: 'sensitive', status: 'pending' }, S2),
+    // 组 C：同词跨作用域 → 不是重复。
+    [C1]: entryOf({ term: '月引', meaning: 'w1 的月引', context: { worldId: 'w1' } }, C1),
+    [C2]: entryOf({ term: '月引', meaning: 'w2 的月引', context: { worldId: 'w2' } }, C2),
+  },
+}
+paths.writeJson(lexFile, fixture)
+
+const readStore = () => JSON.parse(fs.readFileSync(lexFile, 'utf8'))
+
+test('dry-run reports duplicate groups without touching a single byte', () => {
+  const before = fs.readFileSync(lexFile)
+  const run = runCli([])
+  assert.equal(run.status, 0, `dry-run exits 0: ${run.stderr}`)
+  const out = run.stdout
+  assert.match(out, /dry-run/)
+  assert.match(out, /重复组 2 组/, '组 A 与组 S 是重复组；组 C 跨作用域不算')
+  assert.match(out, new RegExp(`保留 ${A2}`), '组 A 保留 active 且 updatedAt 新的 A2')
+  assert.match(out, new RegExp(`并入并删除: ${A1}, ${A3}`))
+  assert.match(out, /active\+sensitive/, '组 S 因 active+sensitive 被跳过')
+  assert.match(out, /mergedFrom 记入: \[lex-dup-a1, lex-dup-a3\]/)
+  assert.deepEqual(fs.readFileSync(lexFile), before, 'dry-run must not modify the file')
+})
+
+test('--apply merges duplicate groups, keeps sensitive/cross-scope entries and the revision draft', () => {
+  const run = runCli(['--apply'])
+  assert.equal(run.status, 0, `apply exits 0: ${run.stderr}`)
+  const store = readStore()
+
+  // 组 A：只剩保留条目 + 待审草稿。
+  assert.equal(store.terms[A1], undefined, 'A1 merged away')
+  assert.equal(store.terms[A3], undefined, 'A3 merged away')
+  const kept = store.terms[A2]
+  assert.ok(kept, 'A2 kept')
+  assert.deepEqual(kept.mergedFrom, [A1, A3], 'mergedFrom records the removed ids for audit')
+  assert.equal(kept.meaning, fixture.terms[A3].meaning, 'meaning takes the longest across the group')
+  assert.deepEqual([...kept.aliases].sort(), ['刀里藏糖', '糖里藏刀'], 'aliases are the deduplicated union')
+  assert.deepEqual(kept.examples.sort(), ['保留条目的例句', '驳回条目的例句'].sort())
+  assert.equal(kept.strength, 0.9, 'strength takes the max')
+  assert.equal(kept.status, 'active')
+  assert.equal(kept.evidence.length, 1, 'evidence merged from the rejected member')
+  assert.deepEqual(kept.hitCounts, { candidate: 4, injection: 1, query: 2 }, 'hit counts sum across the group')
+  // 拒绝指纹改指保留条目。
+  assert.equal(store.rejected['fp-lex-dup-a3'].termId, A2, 'the rejected fingerprint now points at the kept entry')
+  // 草稿、敏感组、跨作用域都原样。
+  assert.equal(store.terms[DRAFT].status, 'pending', 'the active term\'s revision draft is not a duplicate')
+  assert.equal(store.terms[DRAFT].revisionOf, A2)
+  assert.ok(store.terms[S1] && store.terms[S2], 'the active+sensitive group is untouched')
+  assert.equal(store.terms[S1].meaning, '敏感触发词')
+  assert.ok(store.terms[C1] && store.terms[C2], 'cross-scope same word is not a duplicate')
+  assert.ok(store.revision > 7, 'the revision advanced')
+  // 结果仍然是一本可严格读取的词典：8 条 − 2 条被并 = 6 条。
+  const loaded = lexicon.loadLexicon(library.id)
+  assert.ok(loaded.terms[A2])
+  assert.equal(Object.keys(loaded.terms).length, 6)
+})
+
+test('the merged library still enforces write-side uniqueness (no re-creation of duplicates)', () => {
+  // 非敏感字段（usage）原地更新：撞上的是保留条目 A2，绝不会新建重复词条。
+  const keptMeaning = readStore().terms[A2].meaning
+  const upsert = lexicon.upsertLexiconTerm({ libraryId: library.id, term: '糖刀', kind: 'term', meaning: keptMeaning, usage: '再次直接写入' })
+  assert.equal(upsert.created, false)
+  assert.equal(upsert.term.termId, A2, 'the kept entry is the collision target, exactly like a never-duplicated term')
+})
+
+test('--library narrows the scan; unsafe ids are a typed usage error', () => {
+  const run = runCli(['--library', library.id])
+  assert.equal(run.status, 0)
+  assert.match(run.stdout, /重复组 1 组/, 'only the skipped active+sensitive group remains')
+  assert.match(run.stdout, /active\+sensitive/, 'reported as skipped, never touched')
+  assert.match(run.stdout, /dry-run 未写入/)
+  const bad = runCli(['--library', '../escape'])
+  assert.equal(bad.status, 2, 'bad --library is a usage error, not a crash')
+  assert.match(bad.stderr, /invalid library id/)
+})

package/tests/lexicon-frequency.test.mjs

@@ -0,0 +1,179 @@
+// 词典频率先验（施工稿 §6.3 包 C）：Wilson 下界、effective 因子进入 stableRank、
+// hitCounts 写入 clamp、以及生命周期（active/archived）对频率证据的影响。所有断言
+// 只依赖落盘数据，不依赖当前时间——排序的确定性在这里与 lexicon-inject 各钉一遍。
+// 面板/卡片流（§2.4）的 UI 断言在 tests/lexicon-ui.test.mjs（G2b 重写），本文件只管
+// 数据面：当前版本没有待审队列，所以这里也不再钉 pending 文案。
+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-lexicon-frequency-'))
+process.env.DSH_MEMU_HOME = home
+
+const paths = await import('../lib/paths.js')
+const state = await import('../lib/state.js')
+const lexicon = await import('../lib/lexicon.js')
+
+test.after(() => {
+  try { state.flushState() } catch {}
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+let serial = 0
+function setupLibrary(name, { terms = [] } = {}) {
+  serial += 1
+  const binding = state.ensureSession(`freq-${name}-${serial}`, { cwd: path.join(home, `project-${name}-${serial}`), agentPreset: 'rp' })
+  for (const args of terms) lexicon.upsertLexiconTerm({ libraryId: binding.libraryId, ...args })
+  return binding
+}
+
+function lexFile(libraryId) {
+  return path.join(home, 'lexicon', `${libraryId}.json`)
+}
+
+/** 直改磁盘上的词条字段（hitCounts/strength/updatedAt），靠 mtime 失效重建索引。 */
+function patchTerm(libraryId, term, patch) {
+  const lex = lexicon.loadLexicon(libraryId)
+  const normalized = lexicon.normalizeLexeme(term)
+  const entry = Object.values(lex.terms).find(item => item.normalizedTerm === normalized)
+  assert.ok(entry, `term ${term} must exist`)
+  Object.assign(entry, patch)
+  paths.writeJson(lexFile(libraryId), lex)
+}
+
+function termIdOf(libraryId, term) {
+  const normalized = lexicon.normalizeLexeme(term)
+  const lex = lexicon.loadLexicon(libraryId)
+  return Object.entries(lex.terms).find(([, entry]) => entry.normalizedTerm === normalized)?.[0] || null
+}
+
+// ---- 1-2. Wilson 下界公式 ----
+
+test('usageLowerBound: n=0 is 0, success is clamped to n, output stays in [0,1]', () => {
+  assert.equal(lexicon.usageLowerBound({ candidate: 0, injection: 0, query: 0 }), 0, 'never-candidated terms carry no frequency evidence')
+  assert.equal(lexicon.usageLowerBound(undefined), 0)
+  assert.equal(lexicon.usageLowerBound(null), 0)
+  assert.equal(lexicon.usageLowerBound({}), 0)
+  assert.equal(lexicon.usageLowerBound({ candidate: -5, injection: 3 }), 0, 'negative denominator is treated as zero')
+  // success 被 min(n, ...) 钳住：脏数据 injection > candidate 也不会把 p 抬过 1。
+  const bounded = lexicon.usageLowerBound({ candidate: 10, injection: 50, query: 0 })
+  const maxed = lexicon.usageLowerBound({ candidate: 10, injection: 10, query: 0 })
+  assert.equal(bounded, maxed, 'success above n is clamped to n')
+  for (const value of [bounded, maxed]) assert.ok(value >= 0 && value <= 1, 'the bound stays in [0,1]')
+  // 1/1 的 Wilson 下界 ≈ 0.207：一次偶发命中拿不到多少先验。
+  const single = lexicon.usageLowerBound({ candidate: 1, injection: 1, query: 0 })
+  assert.ok(Math.abs(single - 0.207) < 0.01, `1/1 lower bound should be ~0.207, got ${single}`)
+})
+
+test('usageLowerBound: 10/9 ranks above 10/1 — a high miss rate is punished', () => {
+  const good = lexicon.usageLowerBound({ candidate: 10, injection: 9, query: 0 })
+  const bad = lexicon.usageLowerBound({ candidate: 10, injection: 1, query: 0 })
+  assert.ok(good > bad, `9/10 (${good}) must beat 1/10 (${bad})`)
+  // 大样本的稳定命中率高于小样本的同比率（Wilson 下界的意义所在）。
+  const big = lexicon.usageLowerBound({ candidate: 120, injection: 100, query: 0 })
+  const small = lexicon.usageLowerBound({ candidate: 10, injection: 8, query: 0 })
+  assert.ok(big > small, '100/120 must exceed 8/10 despite the same ratio')
+})
+
+// ---- 3. 高 strength 零计数仍压过低 strength 高计数 ----
+
+test('effective factor: high strength with zero hits still outranks low strength with heavy usage', () => {
+  const binding = setupLibrary('strength-first', { terms: [
+    { term: '强词先', kind: 'term', meaning: '强权重零计数' },
+    { term: '弱词后', kind: 'term', meaning: '弱权重高计数' },
+  ] })
+  const lib = binding.libraryId
+  patchTerm(lib, '强词先', { strength: 0.9, confidence: 0.8, updatedAt: '2026-01-01T00:00:00.000Z' })
+  patchTerm(lib, '弱词后', { strength: 0.2, confidence: 0.8, updatedAt: '2026-01-01T00:00:00.000Z',
+    hitCounts: { candidate: 1000, injection: 1000, query: 0 } })
+  const hits = lexicon.matchLexiconHits(lib, '强词先和弱词后都出现在这句话里', binding.memoryContext)
+  assert.equal(hits.length, 2)
+  assert.equal(hits[0].term, '强词先', 'a bounded [0.85,1.00] prior must never overturn strength')
+  assert.equal(hits[0].hitCounts.candidate, 0, 'the winner indeed has zero usage')
+})
+
+// ---- 4. 同 strength/confidence，注入率高的排前面 ----
+
+test('effective factor: same strength and confidence, the heavily injected term ranks first', () => {
+  const binding = setupLibrary('usage-first', { terms: [
+    { term: '高频入', kind: 'term', meaning: '十次候选十次注入' },
+    { term: '低频入', kind: 'term', meaning: '十次候选一次注入' },
+  ] })
+  const lib = binding.libraryId
+  patchTerm(lib, '高频入', { strength: 0.5, confidence: 0.5, updatedAt: '2026-01-01T00:00:00.000Z',
+    hitCounts: { candidate: 10, injection: 10, query: 0 } })
+  patchTerm(lib, '低频入', { strength: 0.5, confidence: 0.5, updatedAt: '2026-01-01T00:00:00.000Z',
+    hitCounts: { candidate: 10, injection: 1, query: 0 } })
+  const hits = lexicon.matchLexiconHits(lib, '高频入和低频入都出现在这句话里', binding.memoryContext)
+  assert.equal(hits.length, 2)
+  assert.equal(hits[0].term, '高频入', 'Wilson lower bound lifts the term that really gets injected')
+  assert.equal(hits[1].term, '低频入')
+})
+
+// ---- 5. 排序稳定：纯函数，与当前时间/调用次数无关 ----
+
+test('ranking is a pure function of the stored data, stable across repeated calls', () => {
+  const binding = setupLibrary('stable', { terms: [
+    { term: '稳定甲', kind: 'term', meaning: '一' },
+    { term: '稳定乙', kind: 'term', meaning: '二' },
+    { term: '稳定丙', kind: 'term', meaning: '三' },
+  ] })
+  const lib = binding.libraryId
+  patchTerm(lib, '稳定甲', { strength: 0.6, confidence: 0.6, updatedAt: '2026-01-02T00:00:00.000Z',
+    hitCounts: { candidate: 4, injection: 1, query: 0 } })
+  patchTerm(lib, '稳定乙', { strength: 0.6, confidence: 0.6, updatedAt: '2026-01-01T00:00:00.000Z',
+    hitCounts: { candidate: 4, injection: 4, query: 0 } })
+  patchTerm(lib, '稳定丙', { strength: 0.6, confidence: 0.6, updatedAt: '2026-01-01T00:00:00.000Z',
+    hitCounts: { candidate: 4, injection: 4, query: 0 } })
+  const text = '稳定甲稳定乙稳定丙同时出现'
+  const first = lexicon.matchLexiconHits(lib, text, binding.memoryContext).map(hit => hit.term)
+  assert.equal(first.length, 3)
+  const second = lexicon.matchLexiconHits(lib, text, binding.memoryContext).map(hit => hit.term)
+  assert.deepEqual(second, first, 'the order never depends on the clock or iteration order')
+  // 稳定乙/丙同分同 updatedAt：并列对按 termId 字典序，稳定甲（低注入率）垫底。
+  const idA = termIdOf(lib, '稳定乙')
+  const idB = termIdOf(lib, '稳定丙')
+  const tiePair = idA.localeCompare(idB) < 0 ? ['稳定乙', '稳定丙'] : ['稳定丙', '稳定乙']
+  assert.deepEqual(first.slice(0, 2), tiePair, 'the tied pair falls back to the lexicographic termId')
+  assert.equal(first[2], '稳定甲', 'the weak injection rate stays behind on the same strength')
+})
+
+// ---- 6. hitCounts 写入 clamp 到 1,000,000 ----
+
+test('lexiconRecordHits clamps hitCounts at HIT_COUNT_CAP and keeps the prior bounded', () => {
+  const binding = setupLibrary('clamp', { terms: [{ term: '爆表词', kind: 'term', meaning: '计数封顶' }] })
+  const lib = binding.libraryId
+  const id = termIdOf(lib, '爆表词')
+  assert.ok(id)
+  patchTerm(lib, '爆表词', { hitCounts: { candidate: 5_000_000, injection: 2_000_000, query: 3_000_000 } })
+  const { counts } = lexicon.lexiconRecordHits(lib, [id], 'candidate')
+  assert.equal(counts[id].candidate, lexicon.HIT_COUNT_CAP, 'candidate is clamped to 1,000,000 even after increment')
+  assert.equal(counts[id].injection, lexicon.HIT_COUNT_CAP, 'pre-existing out-of-range values are pulled back in')
+  assert.equal(counts[id].query, lexicon.HIT_COUNT_CAP)
+  const lb = lexicon.usageLowerBound(counts[id])
+  assert.ok(lb >= 0 && lb <= 1, `the factor input stays finite and bounded, got ${lb}`)
+  assert.ok(lexicon.usageLowerBound({ candidate: lexicon.HIT_COUNT_CAP, injection: lexicon.HIT_COUNT_CAP }) > 0.9999, 'a perfect huge sample bounds just under 1 (Wilson never quite reaches it)')
+  // 落盘值同样被封顶：下一次读取不会看到越界计数。
+  const stored = Object.values(lexicon.loadLexicon(lib).terms).find(entry => entry.termId === id || entry.term === '爆表词')
+  assert.equal(stored.hitCounts.candidate, lexicon.HIT_COUNT_CAP)
+})
+
+// ---- 7. 生命周期 × 频率先验（§2.1）：归档词条不再参与匹配/注入 ----
+
+test('archived terms stop accruing frequency evidence and keep their stored counts', () => {
+  const binding = setupLibrary('archived', { terms: [{ term: '归档频率词', kind: 'term', meaning: '归档后不再候选' }] })
+  const lib = binding.libraryId
+  const id = termIdOf(lib, '归档频率词')
+  lexicon.lexiconRecordHit(lib, id, 'candidate')
+  lexicon.lexiconRecordHit(lib, id, 'injection')
+  lexicon.archiveLexiconTerm({ libraryId: lib, termId: id })
+  // 归档后不再进匹配：没有 candidate/injection 可累积。
+  assert.deepEqual(lexicon.matchLexiconHits(lib, '归档频率词出现在这句话里', binding.memoryContext), [])
+  const stored = lexicon.loadLexicon(lib).terms[id]
+  assert.deepEqual(stored.hitCounts, { candidate: 1, injection: 1, query: 0 }, 'the audit counts survive archiving unchanged')
+  // 恢复后重新参与匹配（计数是历史，不是可见性开关）。
+  lexicon.restoreLexiconTerm({ libraryId: lib, termId: id })
+  assert.equal(lexicon.matchLexiconHits(lib, '归档频率词出现在这句话里', binding.memoryContext).length, 1)
+})