dsh-memu-memory 1.1.2 → 1.2.0

package/tests/remote.test.mjs

@@ -0,0 +1,140 @@
+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-remote-'))
+process.env.DSH_MEMU_HOME = home
+process.env.MEMU_CONFIG = path.join(home, 'config.env')
+
+const state = await import('../lib/state.js')
+const config = await import('../lib/memu-config.js')
+const { requestRemoteConsolidation, requestPrivateConsolidation } = await import('../lib/private.js')
+const { summarizeRemote } = await import('../lib/remote-summary.js')
+const { loadPromptForDomain, CONSOLIDATION_CONTRACTS } = await import('../lib/prompts.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+test('remote consolidation reads the transcript and stores model-written memories', async () => {
+  const cwd = path.join(home, 'project')
+  const binding = state.ensureSession('remote-session', { cwd })
+  assert.ok(binding?.libraryId, 'ensureSession must bind a library')
+  state.updateSettings({ memoryBackend: 'agent' })
+  config.saveMemuConfig({
+    summaryModel: 'deepseek-chat',
+    summaryBaseUrl: 'https://api.deepseek.com/v1',
+    summaryApiKey: 'summary-secret',
+  })
+  const originalFetch = globalThis.fetch
+  let seenBody = null
+  globalThis.fetch = async (_url, init) => {
+    seenBody = JSON.parse(init.body)
+    return {
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify({
+        choices: [{
+          message: {
+            content: JSON.stringify({
+              memories: [{ title: '香菜', content: '他记得我不吃香菜。', tags: ['food'] }],
+            }),
+          },
+        }],
+      }),
+    }
+  }
+  const ctx = {
+    get: (name) => name === 'sessionQuery'
+      ? {
+          readSession: async () => ({
+            session: { id: 'remote-session' },
+            events: [{
+              type: 'user/message',
+              data: { source: { kind: 'user' }, content: [{ type: 'text', text: '我不吃香菜' }] },
+            }],
+          }),
+        }
+      : null,
+  }
+  try {
+    const result = await requestRemoteConsolidation(ctx, 'remote-session')
+    assert.equal(result.ok, true)
+    assert.equal(result.backend, 'api')
+    assert.equal(result.count, 1)
+    assert.ok(String(seenBody.messages[0].content).includes('我不吃香菜'))
+    const index = state.loadPrivateIndex(binding.libraryId)
+    const entries = Object.values(index.entries)
+    assert.equal(entries.length, 1)
+    assert.equal(entries[0].title, '香菜')
+    assert.equal(entries[0].layer, 'long_term')
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})
+
+test('explicit remote consolidation remains available when vector route is local', async () => {
+  state.ensureSession('remote-session', { cwd: path.join(home, 'project') })
+  state.updateSettings({ memoryBackend: 'api', vectorSource: 'local' })
+  config.saveMemuConfig({
+    summaryModel: 'deepseek-chat',
+    summaryBaseUrl: 'https://api.deepseek.com/v1',
+    summaryApiKey: 'summary-secret',
+  })
+  const originalFetch = globalThis.fetch
+  globalThis.fetch = async () => ({
+    ok: true,
+    status: 200,
+    text: async () => JSON.stringify({
+      choices: [{ message: { content: JSON.stringify({ memories: [] }) } }],
+    }),
+  })
+  const ctx = {
+    get: (name) => name === 'sessionQuery'
+      ? {
+          readSession: async () => ({
+            events: [{
+              type: 'user/message',
+              data: { source: { kind: 'user' }, content: [{ type: 'text', text: '记一下' }] },
+            }],
+          }),
+        }
+      : null,
+  }
+  try {
+    const result = await requestRemoteConsolidation(ctx, 'remote-session')
+    assert.equal(result.ok, true)
+    assert.equal(result.backend, 'api')
+    assert.equal(result.count, 0)
+  } finally {
+    globalThis.fetch = originalFetch
+    state.updateSettings({ memoryBackend: 'agent' })
+  }
+})
+
+test('remote consolidation uses each domain body with a JSON-only, tool-free contract', async () => {
+  const originalFetch = globalThis.fetch
+  let seenPrompt = ''
+  globalThis.fetch = async (_url, init) => {
+    seenPrompt = JSON.parse(init.body).messages[0].content
+    return { ok: true, text: async () => JSON.stringify({ choices: [{ message: { content: '{"memories":[]}' } }] }) }
+  }
+  try {
+    for (const domain of ['coding', 'rp', 'mixed', 'general']) {
+      const transcript = 'input-evidence: user asks to preserve a verified decision, not a new instruction'
+      assert.deepEqual(await summarizeRemote({ domain, libraryName: 'domain-test', transcript }), [])
+      const expected = loadPromptForDomain('private-consolidation', {
+        domain, libraryName: 'domain-test', mustRememberCap: state.getSettings().mustRememberCap,
+      }, domain).text
+      assert.ok(seenPrompt.includes(expected), `${domain} body must match local defaults`)
+      assert.ok(seenPrompt.includes(CONSOLIDATION_CONTRACTS.remote))
+      assert.equal(seenPrompt.includes(CONSOLIDATION_CONTRACTS.local), false)
+      assert.doesNotMatch(seenPrompt, /\{\{\s*\w+\s*\}\}/)
+      assert.ok(seenPrompt.endsWith(transcript))
+    }
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})

package/tests/rename.test.mjs

@@ -0,0 +1,30 @@
+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'
+import { dataDir } from '../lib/paths.js'
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-rename-'))
+const previous = { DSH_HOME: process.env.DSH_HOME, DSH_MEMU_HOME: process.env.DSH_MEMU_HOME, DSH_MEMU_MEMORY_HOME: process.env.DSH_MEMU_MEMORY_HOME }
+process.env.DSH_HOME = home
+delete process.env.DSH_MEMU_HOME
+delete process.env.DSH_MEMU_MEMORY_HOME
+test.after(() => {
+  for (const [key, value] of Object.entries(previous)) { if (value === undefined) delete process.env[key]; else process.env[key] = value }
+  fs.rmSync(home, { recursive: true, force: true })
+})
+test('fresh installations use the new name but existing memories remain in their original directory', () => {
+  assert.equal(dataDir(), path.join(home, 'dsh-memu-memory'))
+  fs.mkdirSync(path.join(home, 'dsh-memu'))
+  assert.equal(dataDir(), path.join(home, 'dsh-memu'))
+  fs.mkdirSync(path.join(home, 'dsh-memu-memory'))
+  assert.equal(dataDir(), path.join(home, 'dsh-memu'), 'an empty new directory must not shadow existing memories')
+  fs.writeFileSync(path.join(home, 'dsh-memu-memory', 'state.json'), '{}')
+  assert.equal(dataDir(), path.join(home, 'dsh-memu-memory'))
+})
+test('both the new and the previous explicit data-root overrides stay supported', () => {
+  process.env.DSH_MEMU_HOME = path.join(home, 'old-override')
+  assert.equal(dataDir(), process.env.DSH_MEMU_HOME)
+  process.env.DSH_MEMU_MEMORY_HOME = path.join(home, 'new-override')
+  assert.equal(dataDir(), process.env.DSH_MEMU_MEMORY_HOME)
+})

package/tests/repetition-detector-snapshot.test.mjs

@@ -0,0 +1,231 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  buildRepetitionHint,
+  extractAssistantTexts,
+  renderRepetitionHint,
+  repetitionHintForMessages,
+  cjkRatio,
+  REPETITION_PHRASE_MIN,
+  REPETITION_PHRASE_MAX,
+  REPETITION_MAX_TOKENS,
+} from '../scripts/repetition-detector-snapshot.mjs'
+import { estTokens } from '../lib/budget.js'
+
+const BT = String.fromCharCode(96)
+
+function hintedPhrases(hint) {
+  const line = String(hint || '').split('\n').find((item) => item.startsWith('最近反复出现的措辞：'))
+  if (!line) return []
+  const body = line.slice('最近反复出现的措辞：'.length).split('。请换一种说法')[0]
+  return body ? body.split('、') : []
+}
+
+test('extractAssistantTexts keeps assistant prose only, in order', () => {
+  const messages = [
+    { role: 'user', content: [{ type: 'text', text: 'user text' }] },
+    { role: 'assistant', content: 'first string' },
+    { role: 'assistant', content: [
+      { type: 'tool-call', name: 'memu_recall', arguments: {} },
+      { type: 'text', text: 'second block' },
+      { type: 'text', text: 'third block' },
+    ] },
+    { role: 'assistant', content: [{ type: 'image', text: 'not prose' }] },
+    { role: 'assistant', content: '   ' },
+    { role: 'system', content: 'system text' },
+  ]
+  assert.deepEqual(extractAssistantTexts(messages), ['first string', 'second block\nthird block'])
+  assert.deepEqual(extractAssistantTexts(null), [])
+  assert.deepEqual(extractAssistantTexts([{ role: 'assistant', content: null }]), [])
+})
+
+test('extractAssistantTexts never mutates frozen host history', () => {
+  const frozen = Object.freeze([
+    Object.freeze({ role: 'assistant', content: Object.freeze([Object.freeze({ type: 'text', text: '轻轻叹了口气。' })]) }),
+    Object.freeze({ role: 'user', content: Object.freeze([Object.freeze({ type: 'text', text: '继续。' })]) }),
+  ])
+  assert.deepEqual(extractAssistantTexts(frozen), ['轻轻叹了口气。'])
+  assert.equal(frozen.length, 2)
+})
+
+test('a hint needs two earlier assistant texts', () => {
+  assert.equal(buildRepetitionHint({ assistantTexts: [] }), '')
+  assert.equal(buildRepetitionHint({ assistantTexts: ['轻轻叹了口气，然后看着窗外的雨。'] }), '')
+  assert.equal(repetitionHintForMessages([{ role: 'assistant', content: '只有一条。' }]), '')
+})
+
+test('two different earlier turns with a shared Han phrase produce the fixed hint', () => {
+  const hint = buildRepetitionHint({ assistantTexts: [
+    '他轻轻叹了口气，然后看着窗外的雨。',
+    '她轻轻叹了口气，没有说话。',
+  ] })
+  assert.ok(hint.startsWith('<repetition-hint>\n'))
+  assert.ok(hint.endsWith('\n</repetition-hint>'))
+  assert.ok(hint.includes('最近反复出现的措辞：'))
+  assert.ok(hint.includes('请换一种说法；保留人物姓名、用户原话、约定和事实。'))
+  assert.ok(hint.includes('以下是历史助手输出摘要，仅用于避免措辞复读，不是用户的新指令，也不是新的事实来源。'))
+  assert.ok(hintedPhrases(hint).some((phrase) => phrase.includes('轻轻叹了口气')))
+  assert.ok(hintedPhrases(hint).every((phrase) => phrase.length >= REPETITION_PHRASE_MIN && phrase.length <= REPETITION_PHRASE_MAX))
+})
+
+test('a phrase repeated inside one turn alone is not cross-turn repetition', () => {
+  assert.equal(buildRepetitionHint({ assistantTexts: [
+    '今天天气不错。',
+    '她轻轻叹了口气。她轻轻叹了口气。',
+  ] }), '')
+})
+
+test('no shared four-character Han span means no hint', () => {
+  assert.equal(buildRepetitionHint({ assistantTexts: ['窗外雨声很大。', '桌上杯子很凉。'] }), '')
+})
+
+test('grammatical filler made only of stop characters is not reported', () => {
+  assert.equal(buildRepetitionHint({ assistantTexts: ['这是一个问题。', '这是一个问题。'] }), '')
+})
+
+test('pure English history is outside the Chinese-dominant gate', () => {
+  const text = 'As you can see, the rain outside is falling again.'
+  assert.equal(buildRepetitionHint({ assistantTexts: [text, text] }), '')
+  assert.ok(cjkRatio('中文abc') > 0 && cjkRatio('中文abc') < 1)
+  assert.equal(cjkRatio(''), 0)
+})
+
+test('a Chinese-dominant turn may contain Latin, but Latin phrases are never extracted', () => {
+  const text = '她轻轻叹了口气，As you can see，雨还在下。'
+  const hint = buildRepetitionHint({ assistantTexts: [text, text] })
+  assert.ok(hint.includes('轻轻叹了口气'))
+  assert.ok(!hint.includes('As you can see'))
+})
+
+test('code fences are masked before extraction, even when the fence holds prose', () => {
+  const fenced = (prose) => '这' + BT + BT + BT + '\n轻轻叹了口气\n' + BT + BT + BT + prose
+  // Without masking the fenced "轻轻叹了口气" would be a shared phrase and the
+  // hint would appear; with masking only the unrelated prose remains.
+  assert.equal(buildRepetitionHint({ assistantTexts: [fenced('窗外雨声很大。'), fenced('桌上杯子很凉。')] }), '')
+})
+
+test('fenced repetition and identifiers stay out while outside prose still appears', () => {
+  const fenced = (tail) => '这' + BT + BT + BT + 'js\nconst deploy_now = "轻轻叹了口气";\n' + BT + BT + BT + tail
+  const hint = buildRepetitionHint({ assistantTexts: [
+    fenced('窗外雨声很大，她觉得这一切都像一场梦。远处有人轻轻关上了门，风从窗缝里钻进来。她起身去关窗，手指碰到冰凉的玻璃。'),
+    fenced('窗外雨声很大，她觉得这一切都像一场梦。远处有人轻轻关上了门，风从窗缝里钻进来。她起身去关窗，手指碰到冰凉的玻璃。'),
+  ] })
+  assert.ok(hint.includes('窗外雨声很大'), hint)
+  assert.ok(!hint.includes('轻轻叹了口气'), 'fenced prose leaked into the hint')
+  assert.ok(!hint.includes('deploy_now'), 'fenced identifier leaked into the hint')
+})
+
+test('code-only or code-heavy text suppresses the hint', () => {
+  const fence = '这' + BT + BT + BT + 'js\nconst x = 1\n' + BT + BT + BT + '，雨还在下。'
+  assert.equal(buildRepetitionHint({ assistantTexts: [fence, fence] }), '')
+  const heavy = '这' + BT + BT + BT + 'js\n' + 'const a = 1;\n'.repeat(40) + BT + BT + BT + '，她轻轻叹了口气。'
+  assert.equal(buildRepetitionHint({ assistantTexts: [heavy, heavy] }), '')
+})
+
+test('inline code is masked while the surrounding prose still counts', () => {
+  const a = '他轻轻叹了口气，运行 ' + BT + 'deploy_now()' + BT + ' 之后雨停了。'
+  const b = '她轻轻叹了口气，运行 ' + BT + 'deploy_now()' + BT + ' 之后雨停了。'
+  const hint = buildRepetitionHint({ assistantTexts: [a, b] })
+  assert.ok(hint.includes('轻轻叹了口气'))
+  assert.ok(!hint.includes('deploy_now'))
+})
+
+test('URLs, e-mail addresses, secrets, and long digit runs never enter the hint', () => {
+  const a = '轻轻叹了口气，邮箱 test@example.com 和 https://example.com/x 都别发，订单123456789，密钥 sk-abcdef123456。'
+  const hint = buildRepetitionHint({ assistantTexts: [a, a] })
+  assert.ok(hint.includes('轻轻叹了口气'))
+  for (const bad of ['test@example.com', 'https://example.com', '123456789', 'sk-abcdef123456']) {
+    assert.ok(!hint.includes(bad), 'hint leaked ' + bad)
+  }
+})
+
+test('renderRepetitionHint strips tags, backticks, controls, and newlines', () => {
+  const hint = renderRepetitionHint(['轻<轻>叹' + BT + '了', '控制\u0000字符', '换\n行短语'])
+  assert.ok(hint.includes('轻轻叹了'))
+  assert.ok(!hint.includes('轻<轻'))
+  assert.ok(!hint.includes(BT))
+  assert.ok(!hint.includes('\u0000'))
+  assert.equal(hint.split('\n').length, 4, 'tag, one phrase line, source, close')
+})
+
+test('renderRepetitionHint returns empty string when nothing valid is left', () => {
+  assert.equal(renderRepetitionHint([]), '')
+  assert.equal(renderRepetitionHint(['短', 'As you can see here']), '')
+})
+
+test('necessary dates, numbers, commitments and prohibitions are never offered as repeated wording', () => {
+  const necessary = [
+    '每周三晚上八点一起复盘。',
+    '绝不能对生产库直接执行迁移。',
+    '明天下午三点在北门见。',
+    '我们约好下周一交稿。',
+  ]
+  for (const text of necessary) {
+    assert.equal(buildRepetitionHint({ assistantTexts: [text, text] }), '', text)
+  }
+  assert.equal(renderRepetitionHint(['每周三晚上八点一起复盘']), '')
+  const ordinary = buildRepetitionHint({ assistantTexts: [
+    '他轻轻叹了口气，然后看着窗外的雨。',
+    '她轻轻叹了口气，没有说话。',
+  ] })
+  assert.ok(ordinary.includes('轻轻叹了口气'), 'ordinary wording must still be reported')
+})
+
+test('phrases stay within four and twenty-four characters', () => {
+  const longest = '他心里想着这件事情真的非常重要我们都要记住它并且'
+  assert.equal(longest.length, REPETITION_PHRASE_MAX)
+  const hint = renderRepetitionHint([longest])
+  assert.ok(hint.includes(longest))
+  assert.equal(renderRepetitionHint([longest + '啊']), '', 'a 25-character phrase is rejected')
+  assert.equal(renderRepetitionHint(['短短']), '', 'a 2-character phrase is rejected')
+})
+
+test('at most three phrases are reported and duplicates collapse', () => {
+  const text = '轻轻叹了口气。窗外雨声很大。桌上杯子很凉。远处钟声响起。'
+  const hint = buildRepetitionHint({ assistantTexts: [text, text] })
+  const phrases = hintedPhrases(hint)
+  assert.ok(phrases.length >= 1 && phrases.length <= 3)
+  assert.equal(new Set(phrases).size, phrases.length)
+})
+
+test('maxTokens is hard capped at 168 and tiny budgets omit the whole hint', () => {
+  const a = '他轻轻叹了口气，然后看着窗外的雨。'
+  const b = '她轻轻叹了口气，没有说话。'
+  const wide = buildRepetitionHint({ assistantTexts: [a, b], maxTokens: 5000 })
+  assert.ok(wide.length > 0)
+  assert.ok(estTokens(wide) <= REPETITION_MAX_TOKENS, 'used ' + estTokens(wide))
+  assert.equal(buildRepetitionHint({ assistantTexts: [a, b], maxTokens: 20 }), '')
+})
+
+test('three full-length phrases fit inside the 168-token hint budget', () => {
+  const p1 = '他心里想着这件事情真的非常重要我们都要记住它并且'
+  const p2 = '我们必须把这段话说得更加清楚一些然后再继续往下走'
+  const p3 = '窗外的雨一直下个不停而桌上的那杯茶早就已经凉了啊'
+  assert.equal(p1.length, 24)
+  assert.equal(p2.length, 24)
+  assert.equal(p3.length, 24)
+  const text = [p1, p2, p3].join('。')
+  const hint = buildRepetitionHint({ assistantTexts: [text, text], maxTokens: 5000 })
+  assert.equal(hintedPhrases(hint).length, 3)
+  assert.ok(estTokens(hint) <= REPETITION_MAX_TOKENS, 'used ' + estTokens(hint))
+  const narrow = buildRepetitionHint({ assistantTexts: [text, text], maxTokens: 160 })
+  assert.ok(estTokens(narrow) <= 160, 'used ' + estTokens(narrow))
+  assert.ok(hintedPhrases(narrow).length < 3, 'three full-length phrases need more than 160 tokens')
+})
+
+test('only the recent window is considered', () => {
+  const hint = buildRepetitionHint({
+    assistantTexts: ['轻轻叹了口气。', '轻轻叹了口气，然后。', '完全不同的话。'],
+    window: 2,
+  })
+  assert.equal(hint, '')
+})
+
+test('the output is stable and ordered by first appearance', () => {
+  const a = '轻轻叹了口气。窗外雨声很大。'
+  const b = '轻轻叹了口气。窗外雨声很大。'
+  const one = buildRepetitionHint({ assistantTexts: [a, b] })
+  const two = buildRepetitionHint({ assistantTexts: [a, b] })
+  assert.equal(one, two)
+  assert.ok(hintedPhrases(one).length > 0)
+})

package/tests/repetition-eval-live.test.mjs

@@ -0,0 +1,177 @@
+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 live = await import('../scripts/repetition-eval-live.mjs')
+const base = await import('../scripts/repetition-eval.mjs')
+const snapshot = await import('../scripts/repetition-detector-snapshot.mjs')
+const scenarios = await import('../scripts/repetition-ab-scenarios.mjs')
+const fixtures = base.loadDataset()
+const roots = []
+
+test.after(() => {
+  for (const root of roots.splice(0)) {
+    try { fs.rmSync(root, { recursive: true, force: true }) } catch {}
+  }
+})
+
+function freshRoot() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-repetition-live-'))
+  roots.push(root)
+  return root
+}
+
+function fixture(id) {
+  return fixtures.dialogues.find(dialogue => dialogue.id === id)
+}
+
+test('buildRepetitionHint uses the frozen evaluation snapshot without fixture-label filtering', () => {
+  const dialogue = fixture('zh-rp-baseline')
+  const assistantTexts = dialogue.turns.filter(turn => turn.role === 'assistant').map(turn => turn.text)
+  const hint = live.buildRepetitionHint(assistantTexts, dialogue.labels)
+  assert.match(hint, /<repetition-hint>/)
+  assert.match(hint, /轻轻叹了口气/)
+  // The frozen snapshot has no gold labels at runtime. The A/B scorer, not
+  // the detector, measures whether necessary names/facts were harmed.
+  assert.equal(typeof hint, 'string')
+  assert.equal(hint, snapshot.buildRepetitionHint({ assistantTexts }))
+  assert.equal(hint, live.buildRepetitionHint(assistantTexts, { necessaryPhrases: [], facts: [] }))
+  assert.equal(live.buildRepetitionHint(['only one'], dialogue.labels), '')
+})
+
+test('generateSample uses the original prefix and adds a hint only in the candidate condition', async () => {
+  const dialogue = fixture('zh-rp-baseline')
+  const calls = []
+  const fakeChat = async ({ messages }) => {
+    calls.push(messages)
+    return '林眠轻轻叹了口气，看着窗外的雨。'
+  }
+  const candidate = await live.generateSample({
+    fixture: dialogue,
+    condition: 'candidate',
+    chat: fakeChat,
+    config: { ready: true, model: 'fake', baseUrl: 'http://127.0.0.1' },
+  })
+  assert.equal(candidate.kind, 'repetition-eval-live-sample')
+  assert.equal(candidate.condition, 'candidate')
+  assert.equal(candidate.prefixTurns.filter(turn => turn.role === 'user').length, 3)
+  assert.equal(candidate.prefixTurns.filter(turn => turn.role === 'assistant').length, 2)
+  assert.equal(calls.length, 1)
+  assert.ok(calls[0].some(message => message.role === 'assistant' && message.content.includes('桌角')))
+  assert.ok(calls[0].some(message => message.role === 'user'
+    && message.source?.kind === 'plugin:dsh-memu-memory'
+    && message.content?.[0]?.text?.includes('<repetition-hint>')))
+  assert.equal(candidate.hintApplied, true)
+  const pluginIndex = calls[0].findIndex(message => message.source?.kind === 'plugin:dsh-memu-memory')
+  assert.equal(pluginIndex, calls[0].length - 2)
+  assert.equal(calls[0].filter(message => message.role === 'system').length, 1)
+  assert.doesNotMatch(String(calls[0].find(message => message.role === 'system').content), /character names|user quotes|agreements|established facts/i)
+
+  calls.length = 0
+  const baseline = await live.generateSample({
+    fixture: dialogue,
+    condition: 'baseline',
+    chat: fakeChat,
+    config: { ready: true, model: 'fake', baseUrl: 'http://127.0.0.1' },
+  })
+  assert.equal(calls.length, 1)
+  assert.equal(calls[0].some(message => message.source?.kind === 'plugin:dsh-memu-memory'), false)
+  assert.equal(baseline.hintApplied, false)
+})
+
+test('only labels for the generated target are scored, not every earlier answer', async () => {
+  const dialogue = fixture('agreement-baseline')
+  const target = live.targetAssistantIndex(dialogue)
+  const sample = await live.generateSample({
+    fixture: dialogue, condition: 'baseline',
+    chat: async () => dialogue.turns[target].text,
+  })
+  assert.equal(sample.labels.facts.length, 1)
+  assert.equal(sample.evaluation.factCompleteness, 1)
+  assert.equal(sample.evaluation.necessaryRetentionRate, 1)
+})
+
+test('the A/B pack contains twenty unique scenarios and self-consistent target labels', () => {
+  const dataset = scenarios.loadAbDataset()
+  const ab = dataset.dialogues.filter(dialogue => dialogue.id.startsWith('ab-'))
+  assert.equal(ab.length, 14)
+  assert.equal(new Set(ab.map(dialogue => dialogue.pairId)).size, 14)
+  for (const dialogue of ab) {
+    base.validateDialogueShape(dialogue)
+    const target = live.targetAssistantIndex(dialogue)
+    const evaluation = base.evaluateAssistantTurn({
+      text: dialogue.turns[target].text,
+      priorAssistantTexts: [],
+      labels: {
+        necessaryPhrases: dialogue.labels.necessaryPhrases.filter(label => label.turn === target),
+        facts: dialogue.labels.facts.filter(label => label.turn === target),
+      },
+    })
+    assert.equal(evaluation.factsTotal === 0 || evaluation.factCompleteness === 1, true, dialogue.id)
+    assert.equal(evaluation.necessaryRetentionRate, 1, dialogue.id)
+  }
+})
+
+test('twenty scenarios and three repeats use exactly 120 calls with paired outputs', async () => {
+  let calls = 0
+  const report = await live.runLivePilot({
+    ab: true, repeats: 3, concurrency: 4, outDir: freshRoot(),
+    config: { ready: true, model: 'fake', baseUrl: 'https://example.test' },
+    chat: async () => { calls += 1; return '这是一条合成测试输出。' },
+  })
+  assert.equal(calls, 120)
+  assert.equal(report.config.attempts, 120)
+  assert.equal(report.config.automaticRetries, 0)
+  assert.equal(report.failures.length, 0)
+  assert.equal(report.dialogues.length, 120)
+})
+
+test('an over-budget plan is rejected before any generation call', async () => {
+  let calls = 0
+  await assert.rejects(() => live.runLivePilot({
+    ab: true, repeats: 4, outDir: freshRoot(),
+    config: { ready: true },
+    chat: async () => { calls += 1; return 'not reached' },
+  }), /120-attempt limit/)
+  assert.equal(calls, 0)
+})
+
+test('a failed provider is not retried and details or credentials are not reported', async () => {
+  let calls = 0
+  const report = await live.runLivePilot({
+    outDir: freshRoot(), config: { ready: true, model: 'fake', baseUrl: 'https://example.test', apiKey: 'unit-secret' },
+    chat: async () => { calls += 1; throw new Error('unit-secret provider-body') },
+  })
+  assert.equal(calls, 4)
+  assert.equal(report.ok, false)
+  assert.equal(report.config.stoppedEarly, true)
+  assert.equal(report.failures.length, 4)
+  assert.equal(JSON.stringify(report).includes('unit-secret'), false)
+  assert.equal(JSON.stringify(report).includes('provider-body'), false)
+})
+
+test('runLivePilot writes twelve samples and reports both conditions without claiming gold', async () => {
+  const outDir = freshRoot()
+  const report = await live.runLivePilot({
+    outDir,
+    config: { ready: true, model: 'fake-model', baseUrl: 'http://127.0.0.1', apiKey: 'not-used' },
+    chat: async () => '我会继续，但不会重复刚才的套话。',
+  })
+  assert.equal(report.status, 'live-pilot-not-validated')
+  assert.equal(report.draft, true)
+  assert.equal(report.notGold, true)
+  assert.equal(report.dataset.dialogueCount, 12)
+  assert.equal(report.dataset.fileCount, 12)
+  assert.equal(report.dialogues.length, 12)
+  assert.equal(report.metrics.byCondition.baseline.emptySet.phraseRepetitionRate, false)
+  assert.equal(report.metrics.byCondition.candidate.emptySet.phraseRepetitionRate, false)
+  assert.equal(report.metrics.humanPreference.status, 'not-collected')
+  assert.ok(fs.existsSync(path.join(outDir, 'report.json')))
+  assert.equal(fs.readdirSync(outDir).filter(name => name.endsWith('.json')).length, 13)
+  assert.match(fs.readFileSync(path.join(outDir, 'report.json'), 'utf8'), /\r\n/)
+  const sample = JSON.parse(fs.readFileSync(path.join(outDir, '1-zh-rp-baseline-live-candidate.json'), 'utf8'))
+  assert.equal(sample.kind, 'repetition-eval-live-sample')
+  assert.equal(sample.prefixTurns.length, 5)
+})