dsh-memu-memory 1.1.2 → 1.2.0

package/tests/prompts.test.mjs

@@ -0,0 +1,250 @@
+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-prompts-'))
+process.env.DSH_MEMU_HOME = home
+
+const prompts = await import('../lib/prompts.js')
+const state = await import('../lib/state.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+test('default prompt loads and renders variables', () => {
+  const state = prompts.getPromptState('system-guide')
+  assert.equal(state.source, 'default')
+  assert.ok(state.text.includes('MemU memory'))
+  const rendered = prompts.loadPrompt('system-guide', { mustRememberCap: 16 })
+  assert.ok(rendered.text.includes('16'))
+  assert.ok(!rendered.text.includes('{{mustRememberCap}}'))
+})
+
+test('user override wins, reset restores default', () => {
+  prompts.savePromptOverride('system-guide', 'CUSTOM {{mustRememberCap}}')
+  const custom = prompts.getPromptState('system-guide')
+  assert.equal(custom.source, 'user')
+  assert.equal(prompts.loadPrompt('system-guide', { mustRememberCap: 7 }).text, 'CUSTOM 7')
+  const reset = prompts.resetPrompt('system-guide')
+  assert.equal(reset.source, 'default')
+  assert.ok(reset.text.includes('MemU memory'))
+})
+
+test('default version update marks a user override', () => {
+  prompts.savePromptOverride('private-policy', 'CUSTOM POLICY')
+  const manifestPath = path.join(home, 'prompts', 'manifest.json')
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+  manifest.prompts['private-policy'].defaultHash = 'old-default-hash'
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2))
+  prompts.syncPromptDefaults()
+  const state = prompts.getPromptState('private-policy')
+  assert.equal(state.source, 'user')
+  assert.equal(state.defaultUpdated, true)
+  prompts.syncPromptDefaults()
+  assert.equal(prompts.getPromptState('private-policy').defaultUpdated, true, 'a second startup must not hide an unacknowledged default update')
+  assert.equal(prompts.getPromptState('private-policy').text, 'CUSTOM POLICY', 'new defaults must never overwrite custom text')
+  prompts.savePromptOverride('private-policy', 'REVIEWED CUSTOM POLICY')
+  assert.equal(prompts.getPromptState('private-policy').defaultUpdated, false, 'saving acknowledges the new default')
+  prompts.resetPrompt('private-policy')
+  assert.equal(prompts.getPromptState('private-policy').defaultUpdated, false)
+})
+
+test('unknown template variables stay literal', () => {
+  assert.equal(prompts.renderTemplate('a {{known}} b {{unknown}}', { known: 'x' }), 'a x b {{unknown}}')
+})
+
+test('prompts resolve to the conversation domain and fall back to base', () => {
+  const rp = prompts.loadPromptForDomain('system-guide', { mustRememberCap: 16, unpinBudget: 2 }, 'rp')
+  assert.equal(rp.key, 'system-guide.rp')
+  assert.match(rp.text, /角色扮演/)
+  const coding = prompts.loadPromptForDomain('system-guide', {}, 'coding')
+  assert.equal(coding.key, 'system-guide.coding')
+  assert.match(coding.text, /code wins over memory/)
+
+  const general = prompts.loadPromptForDomain('system-guide', {}, 'general')
+  assert.equal(general.key, 'system-guide')
+  assert.equal(general.fellBackToBase, true)
+
+  // Prompts whose job is to reason across domains are never split.
+  assert.equal(prompts.resolveDef('global-curator', 'rp').key, 'global-curator')
+})
+
+test('a deleted variant silently falls back to the base prompt', () => {
+  const dir = prompts.DEFAULT_DIR
+  const variant = path.join(dir, 'private-policy.rp.md')
+  const original = fs.readFileSync(variant, 'utf8')
+  fs.rmSync(variant)
+  try {
+    const resolved = prompts.loadPromptForDomain('private-policy', {}, 'rp')
+    assert.equal(resolved.key, 'private-policy')
+    assert.equal(resolved.fellBackToBase, true)
+  } finally {
+    fs.writeFileSync(variant, original, 'utf8')
+  }
+})
+
+test('prompts carry the scope the settings sub-tabs group by', () => {
+  const states = prompts.getPromptStates()
+  const scopes = Object.fromEntries(states.map((s) => [s.key, s.scope]))
+  assert.equal(scopes['system-guide'], 'private')
+  assert.equal(scopes['system-guide.rp'], 'private', 'variants inherit their base scope')
+  assert.equal(scopes['private-policy.coding'], 'private')
+  assert.equal(scopes['global-curator'], 'global')
+  assert.ok(states.every((s) => s.scope === 'private' || s.scope === 'global'))
+})
+
+test('adding a domain page creates its variants, seeded from the base prompt', () => {
+  state.addPromptDomain('novel')
+  try {
+    const keys = prompts.getPromptStates().map((s) => s.key)
+    assert.ok(keys.includes('system-guide.novel'))
+    assert.ok(keys.includes('private-consolidation.novel'))
+    // global-curator is not domain-layered, so no variant appears for it.
+    assert.ok(!keys.includes('global-curator.novel'))
+
+    // No file yet: it shows the base text so there is something to edit, and the
+    // runtime keeps using the base prompt until a real file exists.
+    const seeded = prompts.getPromptState('system-guide.novel')
+    assert.equal(seeded.inheritedFrom, 'system-guide')
+    assert.ok(seeded.text.includes('MemU memory'))
+    assert.equal(prompts.resolveDef('system-guide', 'novel').key, 'system-guide')
+
+    // Saving it stores the page separately and makes it authoritative.
+    prompts.savePromptOverride('system-guide.novel', 'NOVEL GUIDE')
+    assert.equal(prompts.getPromptState('system-guide.novel').source, 'user')
+    assert.equal(prompts.resolveDef('system-guide', 'novel').key, 'system-guide.novel')
+    assert.equal(prompts.loadPromptForDomain('system-guide', {}, 'novel').text, 'NOVEL GUIDE')
+    assert.ok(prompts.getPromptState('system-guide').text.includes('MemU memory'), 'the base page is untouched')
+  } finally {
+    for (const key of ['system-guide.novel', 'private-policy.novel', 'private-consolidation.novel']) prompts.resetPrompt(key)
+    state.removePromptDomain('novel')
+  }
+  assert.ok(!prompts.getPromptStates().some((s) => s.key === 'system-guide.novel'))
+})
+
+test('an explicit domain list is kept; all shipped pages are enabled by default', () => {
+  const saved = state.getPromptDomains()
+  assert.deepEqual(saved, ['rp', 'coding', 'mixed'])
+  try {
+    state.updateSettings({ promptDomains: ['rp', 'coding'] })
+    assert.deepEqual(state.getPromptDomains(), ['rp', 'coding'], 'disabling a page is a deliberate list')
+    state.updateSettings({ promptDomains: ['rp', 'novel'] })
+    assert.deepEqual(state.getPromptDomains(), ['rp', 'novel'], 'a deliberate list is kept')
+  } finally {
+    state.updateSettings({ promptDomains: saved })
+  }
+})
+
+test('every shipped domain has a prompt page', () => {
+  // The session picker lists general + promptDomains; the prompts page lists
+  // general + the domains that have variants. They must be the same list.
+  const domains = state.getPromptDomains()
+  assert.ok(domains.includes('mixed'), 'mixed is a session domain and needs a page')
+  const pages = new Set(prompts.getPromptStates().filter((s) => s.domain).map((s) => s.domain))
+  for (const domain of domains) assert.ok(pages.has(domain), `domain ${domain} has no prompt page`)
+  assert.equal(prompts.resolveDef('system-guide', 'mixed').key, 'system-guide.mixed')
+})
+
+test('domain ids are validated', () => {
+  assert.throws(() => state.addPromptDomain('../evil'), /domain id/)
+  assert.throws(() => state.addPromptDomain('general'), /built-in/)
+  assert.throws(() => state.addPromptDomain(''), /domain id/)
+})
+
+test('syncPromptDefaults keeps records for keys it does not know about', () => {
+  prompts.savePromptOverride('system-guide.coding', 'MY CODING GUIDE')
+  const manifestPath = path.join(home, 'prompts', 'manifest.json')
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+  manifest.prompts['a-key-from-an-older-version'] = { defaultHash: 'x', userHash: 'y', defaultUpdated: true, updatedAt: '2020-01-01T00:00:00.000Z' }
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2))
+
+  prompts.syncPromptDefaults()
+
+  const after = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+  assert.ok(after.prompts['a-key-from-an-older-version'], 'unknown keys must survive a default sync')
+  assert.equal(after.prompts['system-guide.coding'].userHash, manifest.prompts['system-guide.coding'].userHash)
+  assert.equal(prompts.getPromptState('system-guide.coding').source, 'user')
+  prompts.resetPrompt('system-guide.coding')
+})
+
+test('domain defaults distinguish engineering evidence, character continuity and mixed boundaries', () => {
+  for (const kind of ['system-guide', 'private-policy', 'private-consolidation']) {
+    const coding = prompts.getPromptState(`${kind}.coding`).defaultText
+    assert.match(coding, /代码块/)
+    assert.match(coding, /逻辑/)
+    assert.match(coding, /验证/)
+    assert.match(coding, /符号/)
+    assert.match(coding, /复核|review/)
+    assert.doesNotMatch(coding, /最多三句、约 200 字|runs at most three sentences/)
+    const rp = prompts.getPromptState(`${kind}.rp`).defaultText
+    assert.match(rp, /边界|界限/)
+    assert.match(rp, /承诺|约定/)
+    assert.match(rp, /waiting/)
+    assert.match(rp, /事实不能为了人味而记错/)
+    assert.doesNotMatch(rp, /允许模糊、偏见、自欺、记混|允许模糊、偏见、自欺、记错|可以记成另一个样子/)
+    const mixed = prompts.getPromptState(`${kind}.mixed`).defaultText
+    assert.match(mixed, /技术侧|技术/)
+    assert.match(mixed, /人物|人这一侧/)
+    assert.match(mixed, /OOC|ooc/)
+    assert.match(mixed, /不.*代替.*(权限|边界)|不是权限隔离/)
+    assert.match(mixed, /复核/)
+  }
+  assert.match(prompts.getPromptState('system-guide').defaultText, /不默认进入角色扮演/)
+  assert.match(prompts.getPromptState('private-policy').defaultText, /通用领域不默认角色扮演/)
+  const curator = prompts.getPromptState('global-curator').defaultText
+  assert.match(curator, /角色台词、虚构身份、感情和剧情承诺不是现实用户属性/)
+  assert.match(curator, /前置条件、适用版本与验证边界/)
+})
+
+test('all shipped template variables are declared and fully rendered, with bounded resident guidance', () => {
+  const vars = { mustRememberCap: 16, unpinBudget: 2, shortTermTtlHours: 48, anchorTokens: 700, turnTokens: 500,
+    libraryName: 'test-library', domain: 'coding', input: '{"sessions":[]}' }
+  for (const definition of prompts.allDefs()) {
+    const text = prompts.getPromptState(definition.key).defaultText
+    for (const [, variable] of text.matchAll(/\{\{\s*(\w+)\s*\}\}/g)) {
+      assert.ok(definition.variables.includes(variable), `${definition.key} does not expose ${variable} in the editor`)
+    }
+    assert.doesNotMatch(prompts.loadPrompt(definition.key, vars).text, /\{\{\s*\w+\s*\}\}/)
+  }
+  // A size guard, not a tokenizer or a claim about model behavior. Only the
+  // guide is resident now; private-policy is retained as a template but is not
+  // delivered to the main conversation.
+  for (const domain of ['general', 'coding', 'rp', 'mixed']) {
+    const text = prompts.loadPromptForDomain('system-guide', vars, domain).text
+    assert.ok(text.length < 7200, `${domain} resident instructions grew too large: ${text.length}`)
+  }
+})
+
+test('no system prompt section is registered; the guide still follows the domain', async () => {
+  const { registerInjection } = await import('../lib/inject.js')
+  const injected = []
+  registerInjection({
+    inject: (...args) => injected.push(args),
+    on: () => () => {},
+  })
+  assert.equal(injected.length, 0, 'rules must travel as a plugin message, not a system section')
+  const vars = { mustRememberCap: 16, unpinBudget: 2, shortTermTtlHours: 48, anchorTokens: 700, turnTokens: 500 }
+  const bodies = ['coding', 'rp', 'mixed', 'general'].map(domain => prompts.loadPromptForDomain('system-guide', vars, domain).text)
+  for (const text of bodies) {
+    assert.ok(text.length > 0)
+    assert.doesNotMatch(text, /\{\{\s*\w+\s*\}\}/)
+  }
+  assert.notEqual(bodies[0], bodies[1], 'domain variants are still distinct')
+})
+
+test('local consolidation adds actual tools while the shared domain body stays backend-neutral', async () => {
+  const { buildPrivateConsolidationPrompt } = await import('../lib/private.js')
+  const sessionId = 'consolidation-routing'
+  state.ensureSession(sessionId, { cwd: path.join(home, 'consolidation-routing') })
+  for (const domain of ['coding', 'rp', 'mixed', 'general']) {
+    state.setSessionBinding(sessionId, { domainOverride: domain })
+    const text = buildPrivateConsolidationPrompt(sessionId)
+    assert.ok(text.includes(prompts.CONSOLIDATION_CONTRACTS.local))
+    assert.match(text, /memu_private_update/)
+    assert.doesNotMatch(text, /\{\{\s*\w+\s*\}\}/)
+    assert.equal(text.includes('你没有记忆工具'), false)
+  }
+})

package/tests/react-snapshot.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+let api
+let snapshots = 0
+const React = {
+  createElement: (type, props, ...children) => typeof type === 'function' ? type({ ...props, children }) : { type, props, children },
+  Fragment: Symbol('fragment'),
+  useState: value => [typeof value === 'function' ? value() : value, () => {}],
+  useMemo: fn => fn(), useCallback: fn => fn, useEffect: () => {}, useRef: value => ({ current: value }),
+  useSyncExternalStore: (_subscribe, snapshot) => {
+    const first = snapshot()
+    assert.equal(snapshot(), first, 'a missing host store must return a stable snapshot')
+    snapshots++
+    return first
+  },
+}
+globalThis.window = { __ModuleLoader__: { load: spec => { api = spec.factory(name => name === 'react' ? React : { createRoot: () => ({ render() {}, unmount() {} }) }) } } }
+globalThis.document = { createElement: () => ({ remove() {} }), head: { appendChild() {} } }
+await import('../lib/client.js')
+test('standalone sidebar without a host session store does not trigger an external-store render loop', () => {
+  assert.doesNotThrow(() => api.mountStandalone({}, { sessionId: 'preview' }))
+  assert.equal(snapshots, 1)
+})

package/tests/recall-bench.test.mjs

@@ -0,0 +1,306 @@
+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-recall-bench-'))
+const previousHome = process.env.DSH_MEMU_HOME
+const previousMemoryHome = process.env.DSH_MEMU_MEMORY_HOME
+process.env.DSH_MEMU_HOME = home
+process.env.DSH_MEMU_MEMORY_HOME = home
+
+const bench = await import('../scripts/recall-bench.mjs')
+const roots = [home]
+const sentinel = path.join(home, 'sentinel.txt')
+fs.writeFileSync(sentinel, 'do not touch the user library\n', 'utf8')
+
+test.after(() => {
+  if (previousHome === undefined) delete process.env.DSH_MEMU_HOME
+  else process.env.DSH_MEMU_HOME = previousHome
+  if (previousMemoryHome === undefined) delete process.env.DSH_MEMU_MEMORY_HOME
+  else process.env.DSH_MEMU_MEMORY_HOME = previousMemoryHome
+  for (const root of roots.splice(0)) {
+    try { fs.rmSync(root, { recursive: true, force: true }) } catch {}
+  }
+})
+
+function freshRoot(label) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `dsh-memu-recall-bench-${label}-`))
+  roots.push(root)
+  return root
+}
+
+function stableReport(report) {
+  return {
+    dataset: report.dataset,
+    code: report.code,
+    config: report.config,
+    metrics: {
+      ...report.metrics,
+      latency: null,
+    },
+    budget: report.budget,
+    samples: report.samples.map(({ latencyMs: _latencyMs, ...rest }) => rest),
+  }
+}
+
+test('CLI parses sample limits and rejects removed or unknown flags', () => {
+  assert.equal(bench.parseArgs(['--samples', '1']).sampleLimit, 1)
+  assert.throws(() => bench.parseArgs(['--hybrid-llm']), /unknown argument/)
+  assert.throws(() => bench.parseArgs(['--not-a-flag']), /unknown argument/)
+})
+
+test('synthetic fixtures are explicitly drafts, structurally valid, and cover every requested subclass', () => {
+  const dataset = bench.loadDataset()
+  assert.equal(dataset.status, 'synthetic-draft-not-gold')
+  assert.equal(dataset.draft, true)
+  assert.equal(dataset.notGold, true)
+  assert.equal(dataset.samples.length, 42)
+  assert.equal(dataset.files.length, 8)
+  assert.match(dataset.sha256, /^[a-f0-9]{64}$/)
+
+  const counts = {}
+  for (const sample of dataset.samples) {
+    assert.equal(sample.draft, true, sample.id + ' must be marked draft')
+    assert.equal(sample.notGold, true, sample.id + ' must be marked notGold')
+    assert.ok(bench.SUBCLASSES.includes(sample.subclass))
+    assert.ok(typeof sample.query === 'string' && sample.query.length > 0)
+    assert.ok(sample.context && typeof sample.context === 'object' && !Array.isArray(sample.context))
+    assert.ok(Number.isFinite(Date.parse(sample.time)))
+    assert.ok(Array.isArray(sample.expectedIds))
+    assert.ok(Array.isArray(sample.forbiddenIds))
+    assert.ok(Array.isArray(sample.library) && sample.library.length > 0 && sample.library.length <= 10)
+    assert.equal(typeof sample.noAnswer, 'boolean')
+    if (sample.noAnswer) assert.equal(sample.expectedIds.length, 0)
+    else assert.ok(sample.expectedIds.length > 0)
+    for (const id of [...sample.expectedIds, ...sample.forbiddenIds]) {
+      assert.ok(sample.library.includes(id), sample.id + ' id outside library: ' + id)
+    }
+    for (const id of sample.expectedIds) assert.ok(!sample.forbiddenIds.includes(id))
+    counts[sample.subclass] = (counts[sample.subclass] || 0) + 1
+  }
+  assert.deepEqual(counts, {
+    paraphrase: 6,
+    exact: 5,
+    negation: 4,
+    'no-answer': 6,
+    conflict: 5,
+    boundary: 6,
+    secret: 5,
+    coding: 5,
+  })
+})
+
+test('sample validation fails closed on a false answerable marker and on an out-of-library id', () => {
+  const base = {
+    id: 'rb-invalid',
+    draft: true,
+    notGold: true,
+    subclass: 'paraphrase',
+    query: '一个查询',
+    context: {},
+    time: '2026-01-01T00:00:00Z',
+    expectedIds: [],
+    forbiddenIds: [],
+    noAnswer: false,
+    library: ['mem-rb-invalid'],
+  }
+  assert.throws(() => bench.validateSampleShape(base, 'bad'), /answerable sample requires expectedIds/)
+  assert.throws(() => bench.validateSampleShape({ ...base, expectedIds: ['mem-rb-other'] }, 'bad'), /outside the declared library/)
+  assert.throws(() => bench.validateSampleShape({ ...base, draft: false, expectedIds: ['mem-rb-invalid'] }, 'bad'), /draft must be true/)
+})
+
+test('metric math uses explicit denominators and scores empty top-3 as a no-answer success', () => {
+  const metrics = bench.computeMetrics([
+    { id: 'a', noAnswer: false, expectedIds: ['e1'], forbiddenIds: ['f'], top3: ['x', 'e1'] },
+    { id: 'b', noAnswer: false, expectedIds: ['e2'], forbiddenIds: ['f'], top3: ['e2'] },
+    { id: 'c', noAnswer: true, expectedIds: [], forbiddenIds: ['f'], top3: ['f'] },
+    { id: 'd', noAnswer: true, expectedIds: [], forbiddenIds: [], top3: [] },
+  ])
+  assert.equal(metrics.recallAt3, 1)
+  assert.equal(metrics.mrrAt3, 0.75)
+  assert.equal(metrics.noAnswerFalseRecallRate, 0.5)
+  assert.equal(metrics.isolationViolations, 1)
+  assert.deepEqual(metrics.denominators, { answerable: 2, noAnswer: 2, forbiddenChecked: 3 })
+  assert.equal(metrics.violations[0].sampleId, 'c')
+
+  const empty = bench.computeMetrics([
+    { id: 'only-no-answer', noAnswer: true, expectedIds: [], forbiddenIds: [], top3: [] },
+  ])
+  assert.equal(empty.recallAt3, 0)
+  assert.equal(empty.mrrAt3, 0)
+  assert.equal(empty.noAnswerFalseRecallRate, 0)
+  assert.equal(empty.emptySet.recallAt3, true)
+  assert.equal(empty.emptySet.noAnswerFalseRecallRate, false)
+})
+
+test('benchmark runs in isolated temp roots, scores candidate and final ids, keeps isolation at zero, and is deterministic', async () => {
+  const firstRoot = freshRoot('run1')
+  const secondRoot = freshRoot('run2')
+  const first = await bench.runBenchmark({ workRoot: firstRoot, seed: 4242 })
+  const second = await bench.runBenchmark({ workRoot: secondRoot, seed: 4242 })
+
+  assert.equal(first.ok, true)
+  assert.equal(first.status, 'synthetic-draft-not-gold')
+  assert.equal(first.dataset.sampleCount, 42)
+  assert.equal(first.dataset.sha256, second.dataset.sha256)
+  assert.equal(first.metrics.candidate.denominators.answerable, 33)
+  assert.equal(first.metrics.candidate.denominators.noAnswer, 9)
+  assert.equal(first.metrics.finalInjected.denominators.answerable, 33)
+  assert.equal(first.metrics.finalInjected.denominators.noAnswer, 9)
+  assert.equal(first.metrics.explicitProbe.denominators.answerable, 5)
+  assert.equal(first.metrics.isolation.violations, 0)
+  assert.equal(first.metrics.isolation.mustBeZero, true)
+  assert.equal(first.metrics.isolation.candidate, 0)
+  assert.equal(first.metrics.isolation.finalInjected, 0)
+  assert.equal(first.metrics.isolation.explicitProbe, 0)
+  assert.ok(first.samples.every(sample => sample.candidateTop3.length <= 3 && sample.injectedTop3.length <= 3))
+
+  // No-answer and boundary samples must actually be scored, not skipped.
+  const noAnswer = first.samples.filter(sample => sample.subclass === 'no-answer')
+  assert.equal(noAnswer.length, 6)
+  assert.ok(noAnswer.every(sample => sample.candidateTop3.length === 0 && sample.injectedTop3.length === 0))
+  const boundary = first.samples.filter(sample => sample.subclass === 'boundary')
+  assert.equal(boundary.length, 6)
+  assert.ok(boundary.every(sample => sample.candidateTop3.length <= 3))
+
+  // Secret entries disappear from automatic recall but appear when explicitly requested.
+  const budget = first.samples.find(sample => sample.id === 'rb-sec-budget')
+  assert.deepEqual(budget.candidateTop3, [])
+  assert.ok(budget.explicitTop3.includes('mem-rb-sec-secret-budget'))
+  const diary = first.samples.find(sample => sample.id === 'rb-sec-diary')
+  assert.deepEqual(diary.candidateTop3, [])
+  assert.ok(diary.explicitTop3.includes('mem-rb-sec-secret-diary'))
+
+  // The run used a fresh root, and the test's own home stayed untouched.
+  assert.ok(first.run.root.startsWith(path.resolve(os.tmpdir())))
+  assert.ok(fs.existsSync(path.join(first.run.root, 'dsh-memu-data', 'state.json')))
+  assert.equal(fs.readFileSync(sentinel, 'utf8'), 'do not touch the user library\n')
+  assert.equal(fs.existsSync(path.join(home, 'state.json')), false)
+
+  // Token budget is only an estimate, never an actual usage claim.
+  assert.equal(first.budget.estimateOnly, true)
+  assert.equal(first.budget.field, 'estimate')
+  assert.equal(typeof first.budget.injectedTokenEstimateTotal, 'number')
+  assert.equal(first.budget.estimate.injectedTokenTotal, first.budget.injectedTokenEstimateTotal)
+  assert.equal(first.budget.estimate.turnTokens, 640)
+  assert.match(first.budget.note, /estimate/i)
+
+  assert.deepEqual(stableReport(first), stableReport(second))
+
+  console.log('RECALL_BENCH_SUMMARY ' + JSON.stringify({
+    dataset: { sampleCount: first.dataset.sampleCount, fileCount: first.dataset.fileCount, sha256: first.dataset.sha256 },
+    candidate: first.metrics.candidate,
+    finalInjected: first.metrics.finalInjected,
+    explicitProbe: first.metrics.explicitProbe,
+    isolation: first.metrics.isolation,
+    latency: first.metrics.latency,
+    bySubclass: first.metrics.bySubclass,
+    budget: first.budget,
+    startedAt: first.run.startedAt,
+  }))
+})
+
+test('candidate pack loads 40 pending-review samples with complete metadata and balanced subclasses', () => {
+  const dataset = bench.loadDataset(bench.CANDIDATE_FIXTURE_DIR)
+  assert.equal(dataset.name, 'recall-bench-gold-candidates')
+  assert.equal(dataset.status, bench.CANDIDATE_STATUS)
+  assert.equal(dataset.status, 'gold-candidate-pending-review')
+  assert.equal(dataset.draft, true)
+  assert.equal(dataset.notGold, true)
+  assert.equal(dataset.gold, false)
+  assert.equal(dataset.review, 'pending')
+  assert.equal(dataset.samples.length, 40)
+  assert.equal(dataset.files.length, 8)
+  assert.equal(dataset.entries.size, 64)
+  assert.match(dataset.sha256, /^[a-f0-9]{64}$/)
+
+  const counts = {}
+  for (const sample of dataset.samples) {
+    assert.equal(sample.status, 'gold-candidate-pending-review', sample.id + ' must stay pending review')
+    assert.equal(sample.draft, true, sample.id + ' must be marked draft')
+    assert.equal(sample.notGold, true, sample.id + ' must be marked notGold')
+    assert.equal(sample.gold, false, sample.id + ' must not be marked gold')
+    assert.equal(sample.review, 'pending', sample.id + ' must have a pending review status')
+    assert.ok(bench.SUBCLASSES.includes(sample.subclass))
+    assert.ok(typeof sample.query === 'string' && sample.query.trim().length > 0)
+    assert.ok(sample.context && typeof sample.context === 'object' && !Array.isArray(sample.context))
+    assert.ok(Number.isFinite(Date.parse(sample.time)))
+    assert.ok(Array.isArray(sample.expectedIds))
+    assert.ok(Array.isArray(sample.forbiddenIds))
+    assert.ok(Array.isArray(sample.library) && sample.library.length >= 4 && sample.library.length <= 10)
+    assert.equal(typeof sample.noAnswer, 'boolean')
+    counts[sample.subclass] = (counts[sample.subclass] || 0) + 1
+  }
+  assert.deepEqual(counts, {
+    paraphrase: 5,
+    exact: 5,
+    negation: 5,
+    'no-answer': 5,
+    conflict: 5,
+    boundary: 5,
+    secret: 5,
+    coding: 5,
+  })
+  for (const file of dataset.files) assert.match(file.sha256, /^[a-f0-9]{64}$/)
+})
+
+test('candidate pack keeps ids indexed, libraries self-contained, and queries distinct from the synthetic draft', () => {
+  const dataset = bench.loadDataset(bench.CANDIDATE_FIXTURE_DIR)
+  const defaultDataset = bench.loadDataset()
+  const defaultQueries = new Set(defaultDataset.samples.map(sample => sample.query))
+  const sampleIds = new Set()
+  const queries = new Set()
+  for (const sample of dataset.samples) {
+    assert.equal(sampleIds.has(sample.id), false, 'duplicate sample id ' + sample.id)
+    sampleIds.add(sample.id)
+    assert.equal(queries.has(sample.query), false, 'duplicate sample query ' + sample.id)
+    queries.add(sample.query)
+    assert.equal(defaultQueries.has(sample.query), false, sample.id + ' copies a synthetic-draft query')
+    assert.equal(new Set(sample.library).size, sample.library.length, sample.id + ' library has duplicate ids')
+    assert.ok(sample.library.length >= 4, sample.id + ' library must have at least four entries')
+    assert.equal(sample.noAnswer, sample.expectedIds.length === 0, sample.id + ' expectedIds/noAnswer mismatch')
+    for (const id of sample.expectedIds) assert.ok(sample.library.includes(id), sample.id + ' expected id outside library: ' + id)
+    for (const id of sample.forbiddenIds) {
+      assert.ok(sample.library.includes(id), sample.id + ' forbidden id outside library: ' + id)
+      assert.equal(sample.expectedIds.includes(id), false, sample.id + ' id is both expected and forbidden: ' + id)
+    }
+    for (const id of sample.library) {
+      const entry = dataset.entries.get(id)
+      assert.ok(entry, sample.id + ' references unknown entry ' + id)
+      assert.equal(entry.id, id)
+      assert.ok(typeof entry.title === 'string' && entry.title.trim().length > 0)
+      assert.ok(typeof entry.content === 'string' && entry.content.trim().length > 0)
+      assert.ok(Array.isArray(entry.tags) && entry.tags.length > 0)
+      assert.ok(Number.isFinite(entry.ageDays) && entry.ageDays >= 0)
+    }
+  }
+  assert.equal(sampleIds.size, 40)
+  assert.equal(queries.size, 40)
+})
+
+test('candidate validation fails closed on gold, review, and draft status leaks', () => {
+  const dataset = bench.loadDataset(bench.CANDIDATE_FIXTURE_DIR)
+  const sample = dataset.samples.find(item => item.subclass === 'paraphrase')
+  const options = { status: bench.CANDIDATE_STATUS }
+  assert.throws(() => bench.validateSampleShape({ ...sample, gold: true }, 'candidate', options), /gold must not be marked/)
+  assert.throws(() => bench.validateSampleShape({ ...sample, review: 'approved' }, 'candidate', options), /review must be pending/)
+  assert.throws(() => bench.validateSampleShape({ ...sample, status: bench.DEFAULT_STATUS }, 'candidate', options), /candidate sample status/)
+  assert.throws(() => bench.validateSampleShape({ ...sample, draft: false }, 'candidate', options), /draft must be true/)
+  assert.throws(() => bench.validateSampleShape({ ...sample, notGold: false }, 'candidate', options), /notGold must be true/)
+})
+
+test('candidate no-answer top-3 emptiness and forbidden isolation hold without locking scores', async () => {
+  const report = await bench.runBenchmark({ fixtureDir: bench.CANDIDATE_FIXTURE_DIR, workRoot: freshRoot('candidate'), seed: 4242 })
+  assert.equal(report.status, 'gold-candidate-pending-review')
+  assert.equal(report.gold, false)
+  assert.equal(report.review, 'pending')
+  assert.equal(report.dataset.sampleCount, 40)
+  assert.equal(report.dataset.sha256, bench.loadDataset(bench.CANDIDATE_FIXTURE_DIR).sha256)
+  assert.equal(report.metrics.isolation.violations, 0)
+  const noAnswer = report.samples.filter(sample => sample.noAnswer)
+  assert.equal(noAnswer.length, 8)
+  assert.ok(noAnswer.every(sample => sample.candidateTop3.length === 0 && sample.injectedTop3.length === 0))
+  // Deliberately no recall/MRR assertion: these are pending-review candidates, not gold scores.
+})