@ilaomianyang/dsh-memory-graph 0.10.0

package/test/auto.mjs

@@ -0,0 +1,295 @@
+/**
+ * The automatic distiller.
+ *
+ * Two triggers, one tick, and one rule that matters more than the features: a tick
+ * *decides*, it does not run. That is what makes this testable at all — the whole
+ * decision is a pure function of (config, clock, last attempt, pending episodes),
+ * so these checks never wait a minute and never spend a token.
+ *
+ * The state that survives a restart lives in the vault, so it is faked here the
+ * same way the real one behaves: read what was written.
+ *
+ *   node test/auto.mjs
+ */
+import assert from 'node:assert/strict'
+
+import { autoDecision, createAutoDistiller, inQuietHours, registerAutoDistill } from '../src/auto.js'
+import { parseQuietHours, resolveConfig } from '../src/config.js'
+
+const results = []
+function check(name, fn) {
+  return Promise.resolve()
+    .then(fn)
+    .then(
+      () => results.push(`  ok   ${name}`),
+      (error) => {
+        results.push(`  FAIL ${name}: ${error.message}`)
+        process.exitCode = 1
+      },
+    )
+}
+
+const MINUTE = 60 * 1000
+const AUTO = { enabled: true, minEpisodes: 10, everyMinutes: 0, minGapMinutes: 30, quietHours: '', project: '' }
+
+/** A vault that only remembers what `writeAutoState` was told. */
+const makeVault = ({ pending = 0, state = {}, failWrite = false } = {}) => {
+  const vault = {
+    written: state,
+    reads: 0,
+    async readUndistilled(limit) {
+      vault.reads += 1
+      vault.lastLimit = limit
+      return Array.from({ length: Math.min(pending, limit) }, (_, i) => ({ file: 'f.jsonl', line: i, record: {} }))
+    },
+    async readAutoState() {
+      return vault.written
+    },
+    async writeAutoState(patch) {
+      if (failWrite) throw new Error('disk full')
+      vault.written = { ...vault.written, ...patch }
+      return vault.written
+    },
+  }
+  return vault
+}
+
+const makeDistiller = ({ auto = AUTO, pending = 0, state = {}, clock = { at: 1_000_000 }, run, failWrite } = {}) => {
+  const calls = []
+  const logs = []
+  const vault = makeVault({ pending, state, failWrite })
+  const distiller = createAutoDistiller({
+    cfg: { auto, extractor: { maxEpisodesPerRun: 40 } },
+    vault,
+    now: () => clock.at,
+    run: async (options) => {
+      calls.push(options)
+      return run ? run(options) : { ok: true, episodes: pending, written: 2, model: 'deepseek-chat' }
+    },
+    log: (level, message) => logs.push(`${level}: ${message}`),
+  })
+  return { distiller, vault, calls, logs, clock }
+}
+
+/* --------------------------------------------------------------- the rules */
+
+await check('off by default: a tick does nothing at all', async () => {
+  const { distiller, calls, vault } = makeDistiller({ auto: { ...AUTO, enabled: false }, pending: 100 })
+  const decision = await distiller.tick()
+  assert.equal(decision.due, false)
+  assert.equal(decision.reason, 'auto is off')
+  assert.equal(vault.reads, 0, 'an off switch does not even read the vault')
+  assert.equal(calls.length, 0)
+})
+
+await check('the threshold rule fires only once enough episodes have piled up', () => {
+  const base = { auto: AUTO, now: 5_000_000, lastAttemptAt: null }
+  assert.equal(autoDecision({ ...base, pending: 9 }).due, false)
+  const hit = autoDecision({ ...base, pending: 10 })
+  assert.equal(hit.due, true)
+  assert.equal(hit.rule, 'threshold')
+  assert.equal(autoDecision({ ...base, pending: 0 }).reason, 'nothing to distill')
+})
+
+await check('the schedule rule fires on elapsed time, and 0 disables it', () => {
+  const auto = { ...AUTO, minEpisodes: 0, everyMinutes: 60 }
+  const now = 10 * 60 * MINUTE
+  // No clock yet is never "overdue": the ticker starts it, so switching a daily
+  // schedule on cannot spend before the first interval has passed.
+  assert.equal(autoDecision({ auto, now, lastAttemptAt: null, pending: 1 }).due, false)
+  assert.equal(autoDecision({ auto, now, lastAttemptAt: now - 61 * MINUTE, pending: 1 }).due, true)
+  assert.equal(autoDecision({ auto, now, lastAttemptAt: now - 59 * MINUTE, pending: 1 }).due, false)
+  assert.equal(autoDecision({ auto: { ...auto, everyMinutes: 0 }, now, lastAttemptAt: now - 999 * MINUTE, pending: 1 }).due, false)
+})
+
+await check('a schedule with no clock starts one instead of spending on the spot', async () => {
+  const { distiller, calls, vault, clock } = makeDistiller({ auto: { ...AUTO, minEpisodes: 0, everyMinutes: 1440 }, pending: 5 })
+  const first = await distiller.tick()
+  assert.equal(first.due, false, 'switching a daily schedule on does not run immediately')
+  assert.equal(first.reason, 'nothing is due yet')
+  assert.equal(calls.length, 0)
+  assert.equal(vault.written.startedAt, clock.at, 'the clock starts now')
+  assert.equal(vault.written.lastAttemptAt, undefined, 'and it is not an attempt: the gap must not be armed by it')
+  clock.at += 24 * 60 * MINUTE
+  const next = await distiller.tick()
+  assert.equal(next.due, true)
+  assert.equal(next.rule, 'schedule')
+  assert.equal(calls.length, 1, 'and a day later it runs')
+})
+
+await check('a threshold with no clock still fires at once: that rule is the pile, not the clock', async () => {
+  const { distiller, calls } = makeDistiller({ auto: { ...AUTO, minEpisodes: 3, everyMinutes: 1440 }, pending: 5 })
+  const decision = await distiller.tick()
+  assert.equal(decision.ran, true)
+  assert.equal(decision.rule, 'threshold')
+  assert.equal(calls.length, 1)
+})
+
+await check('both rules can be on: whichever is satisfied first runs', () => {
+  const auto = { ...AUTO, minEpisodes: 10, everyMinutes: 60 }
+  const now = 100 * MINUTE
+  // Past the gap, inside the schedule window: only the pile of episodes can fire it.
+  assert.equal(autoDecision({ auto, now, lastAttemptAt: now - 31 * MINUTE, pending: 40 }).rule, 'threshold')
+  assert.equal(autoDecision({ auto, now, lastAttemptAt: now - 61 * MINUTE, pending: 1 }).rule, 'schedule')
+  assert.equal(autoDecision({ auto, now, lastAttemptAt: now - 31 * MINUTE, pending: 1 }).due, false)
+})
+
+await check('the minimum gap holds whichever rule fired', () => {
+  const auto = { ...AUTO, minEpisodes: 1, everyMinutes: 1, minGapMinutes: 30 }
+  const now = 100 * MINUTE
+  assert.equal(autoDecision({ auto, now, lastAttemptAt: now - 10 * MINUTE, pending: 99 }).due, false)
+  assert.equal(autoDecision({ auto, now, lastAttemptAt: now - 31 * MINUTE, pending: 99 }).due, true)
+})
+
+await check('quiet hours save the run for later, including a window past midnight', () => {
+  const at = (hour, minute = 0) => new Date(2026, 10, 3, hour, minute).getTime()
+  const auto = { ...AUTO, quietHours: '23:00-08:00' }
+  assert.equal(inQuietHours('23:00-08:00', at(23, 30)), true)
+  assert.equal(inQuietHours('23:00-08:00', at(2)), true)
+  assert.equal(inQuietHours('23:00-08:00', at(8)), false)
+  assert.equal(inQuietHours('02:00-03:00', at(2, 30)), true)
+  assert.equal(inQuietHours('02:00-03:00', at(4)), false)
+  assert.equal(inQuietHours('', at(3)), false, 'empty means always')
+  assert.equal(inQuietHours('nonsense', at(3)), false, 'unreadable text must not silence it forever')
+  assert.equal(autoDecision({ auto, now: at(23, 30), lastAttemptAt: null, pending: 50 }).reason, 'quiet hours')
+})
+
+/* ------------------------------------------------------------- the ticker */
+
+await check('a tick that decides yes runs exactly one distillation and records the attempt', async () => {
+  const { distiller, calls, vault, logs } = makeDistiller({ pending: 12 })
+  const decision = await distiller.tick()
+  assert.equal(decision.due, true)
+  assert.equal(decision.ran, true)
+  assert.equal(calls.length, 1, 'one tick, one run')
+  assert.equal(typeof vault.written.lastAttemptAt, 'number', 'the gap clock is persisted, so a restart cannot lose it')
+  assert.ok(logs.some((line) => line.includes('read 12 episode(s) → wrote 2 card(s)')), logs.join('\n'))
+})
+
+await check('the same tick right after does not run again: the gap is armed before the call', async () => {
+  const { distiller, calls, clock } = makeDistiller({ pending: 12 })
+  await distiller.tick()
+  clock.at += 5 * MINUTE
+  const again = await distiller.tick()
+  assert.equal(again.due, false)
+  assert.equal(again.reason, 'the gap between runs has not elapsed')
+  assert.equal(calls.length, 1)
+  clock.at += 30 * MINUTE
+  assert.equal((await distiller.tick()).due, true, 'and it comes back after the gap')
+  assert.equal(calls.length, 2)
+})
+
+await check('nor after a restart, which is what the vault state file is for', async () => {
+  const first = makeDistiller({ pending: 12 })
+  await first.distiller.tick()
+  const written = first.vault.written
+  const second = makeDistiller({ pending: 12, state: written, clock: { at: 1_000_000 + 6 * MINUTE } })
+  const decision = await second.distiller.tick()
+  assert.equal(decision.due, false, 'a fresh process reads the attempt clock instead of starting over')
+  assert.equal(second.calls.length, 0)
+})
+
+await check('a run that produced nothing still arms the gap, so a quiet vault is not re-asked', async () => {
+  const { distiller, calls, clock } = makeDistiller({
+    pending: 12,
+    run: async () => ({ ok: true, episodes: 12, written: 0, reason: 'nothing worth keeping' }),
+  })
+  await distiller.tick()
+  clock.at += 2 * MINUTE
+  assert.equal((await distiller.tick()).due, false)
+  assert.equal(calls.length, 1)
+})
+
+await check('an automatic run never overlaps one already in flight', async () => {
+  const { distiller, calls, logs } = makeDistiller({
+    pending: 12,
+    run: async () => ({ ok: false, busy: true, reason: 'A distillation is already running.' }),
+  })
+  const decision = await distiller.tick()
+  assert.equal(decision.ran, true)
+  assert.equal(calls.length, 1)
+  assert.ok(logs.some((line) => line.includes('already running')), logs.join('\n'))
+})
+
+await check('a failed run is logged with the reason, and the gap still holds', async () => {
+  const { distiller, calls, clock, logs } = makeDistiller({
+    pending: 12,
+    run: async () => ({ ok: false, reason: 'Extractor is disabled. Set config extractor.enabled = true.' }),
+  })
+  await distiller.tick()
+  assert.ok(logs.some((line) => line.includes('Extractor is disabled')), logs.join('\n'))
+  clock.at += 5 * MINUTE
+  await distiller.tick()
+  assert.equal(calls.length, 1, 'a refusal is not retried on the next tick')
+})
+
+await check('the configured project reaches the run', async () => {
+  const { distiller, calls } = makeDistiller({ auto: { ...AUTO, project: 'Article2' }, pending: 12 })
+  await distiller.tick()
+  assert.equal(calls[0].project, 'Article2', 'automatic cards land in the project the user named')
+})
+
+await check('an unreadable vault is a logged skip, not a crashed ticker', async () => {
+  const { distiller, logs } = makeDistiller({ pending: 12 })
+  distiller.state()
+  const broken = createAutoDistiller({
+    cfg: { auto: AUTO, extractor: { maxEpisodesPerRun: 40 } },
+    vault: {
+      async readUndistilled() {
+        throw new Error('EACCES')
+      },
+      async readAutoState() {
+        return {}
+      },
+      async writeAutoState() {},
+    },
+    run: async () => {
+      throw new Error('should not run')
+    },
+    log: (level, message) => logs.push(`${level}: ${message}`),
+  })
+  const decision = await broken.tick()
+  assert.equal(decision.ran, false)
+  assert.ok(logs.some((line) => line.includes('EACCES')), logs.join('\n'))
+})
+
+/* ------------------------------------------------------------- the wiring */
+
+await check('the ticker asks for enough episodes to see the threshold', async () => {
+  const { distiller, vault } = makeDistiller({ auto: { ...AUTO, minEpisodes: 200 }, pending: 250 })
+  await distiller.tick()
+  assert.ok(vault.lastLimit >= 200, `asked for ${vault.lastLimit}, which would hide the threshold`)
+})
+
+await check('registering the ticker returns a stop that clears both timers', () => {
+  let ticks = 0
+  const stop = registerAutoDistill({
+    ctx: {},
+    distiller: {
+      async tick() {
+        ticks += 1
+        return { due: false }
+      },
+    },
+    intervalMs: 5,
+  })
+  assert.equal(typeof stop, 'function')
+  stop()
+  assert.equal(typeof stop, 'function', 'stopping twice must not throw')
+  stop()
+})
+
+await check('a malformed quiet window is dropped instead of silencing the feature', () => {
+  assert.equal(parseQuietHours(''), null)
+  assert.equal(parseQuietHours('25:00-08:00'), null)
+  assert.equal(parseQuietHours('later'), null)
+  const cfg = resolveConfig({})
+  assert.equal(cfg.auto.enabled, false, 'automatic distillation is off unless someone asks for it')
+  assert.equal(cfg.auto.quietHours, '')
+  const weird = resolveConfig({ auto: { quietHours: 'nonsense', minEpisodes: '12' } })
+  assert.equal(weird.auto.quietHours, '', 'the broken window is dropped')
+  assert.equal(weird.auto.minEpisodes, 12, 'a numeric string is still a number')
+})
+
+console.log(results.join('\n'))
+console.log(process.exitCode === 1 ? '\nSOME CHECKS FAILED' : `\nall ${results.length} checks passed`)

package/test/capture.mjs

@@ -0,0 +1,264 @@
+/**
+ * Capture test: drives the session/event listener with the real event shapes
+ * and checks what lands in the vault.   node test/capture.mjs
+ */
+import assert from 'node:assert/strict'
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+import { resolveConfig } from '../src/config.js'
+import { createRedactor } from '../src/privacy.js'
+import { createVault } from '../src/vault.js'
+import { registerCapture } from '../src/capture.js'
+
+const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'memgraph-cap-'))
+const cfg = resolveConfig({ vaultDir: dir })
+const redactor = createRedactor(cfg.privacy)
+const vault = createVault(cfg, redactor)
+
+/** Minimal stand-in for the Cordis context. */
+const handlers = new Map()
+const ctx = {
+  on(name, fn) {
+    if (!handlers.has(name)) handlers.set(name, [])
+    handlers.get(name).push(fn)
+    return () => {
+      const list = handlers.get(name) ?? []
+      const at = list.indexOf(fn)
+      if (at !== -1) list.splice(at, 1)
+    }
+  },
+  logger: { info() {}, warn() {} },
+}
+
+function emit(name, ...args) {
+  for (const fn of handlers.get(name) ?? []) fn(...args)
+}
+
+const results = []
+function check(name, fn) {
+  try {
+    fn()
+    results.push(`  ok   ${name}`)
+  } catch (error) {
+    results.push(`  FAIL ${name}: ${error.message}`)
+    process.exitCode = 1
+  }
+}
+
+const dispose = registerCapture(ctx, { cfg, vault, redactor })
+const session = { id: 's-abc', header: { cwd: 'G:\\TempProject\\测试\\memory-graph-plugin' } }
+
+/* A turn exactly as the harness records it. */
+emit('session/event', session, {
+  type: 'user/message',
+  seq: 1,
+  time: Date.now(),
+  data: {
+    role: 'user',
+    content: [{ type: 'text', text: '把 vault 改成纯文本，顺便 key 是 sk-abcdefghijklmnopqrstuvwxyz012345' }],
+    source: { kind: 'user', rpcId: 'r-1', clientTimeZone: 'Asia/Shanghai' },
+  },
+})
+emit('session/event', session, {
+  type: 'assistant/message',
+  seq: 2,
+  time: Date.now(),
+  data: {
+    turn: 7,
+    step: 1,
+    message: { role: 'assistant', content: [{ type: 'text', text: '改成纯文本了，因为没有二进制合并问题。' }] },
+    stream: null,
+  },
+})
+emit('session/event', session, { type: 'tool/result', seq: 3, time: Date.now(), data: { turn: 7, step: 1, message: {} } })
+emit('session/event', session, { type: 'turn/end', seq: 4, time: Date.now(), data: { turn: 7, reason: { kind: 'completed' } } })
+
+await new Promise((resolve) => setTimeout(resolve, 60))
+
+const files = await vault.episodeFiles()
+check('a closed turn becomes one episode file', () => {
+  assert.equal(files.length, 1, files.join(','))
+})
+
+const raw = await fsp.readFile(path.join(dir, 'episodes', files[0]), 'utf8')
+const lines = raw.split('\n').filter((line) => line.trim() !== '')
+check('one line per turn', () => {
+  assert.equal(lines.length, 1, raw)
+})
+
+const record = JSON.parse(lines[0])
+check('the episode carries project, turn and both sides', () => {
+  assert.equal(record.project, 'memory-graph-plugin')
+  assert.equal(record.turn, 7)
+  assert.ok(record.user.includes('纯文本'), record.user)
+  assert.ok(record.assistant.includes('二进制合并'), record.assistant)
+})
+check('a secret in the user text never reaches the file', () => {
+  assert.equal(raw.includes('sk-abcdefghij'), false, raw)
+  assert.ok(record.user.includes('[REDACTED]'), record.user)
+})
+
+/* A second turn, flushed by the next user message rather than turn/end. */
+emit('session/event', session, {
+  type: 'user/message',
+  seq: 5,
+  time: Date.now(),
+  data: { role: 'user', content: [{ type: 'text', text: '第二个问题：实体页要不要自动合并别名？' }] },
+})
+emit('session/event', session, {
+  type: 'assistant/message',
+  seq: 6,
+  time: Date.now(),
+  data: { turn: 8, step: 1, message: { role: 'assistant', content: [{ type: 'text', text: '先按 slug 归一化，别名靠人工。' }] }, stream: null },
+})
+emit('session/event', session, { type: 'turn/end', seq: 7, time: Date.now(), data: { turn: 8, reason: { kind: 'completed' } } })
+await new Promise((resolve) => setTimeout(resolve, 60))
+
+const after = (await fsp.readFile(path.join(dir, 'episodes', files[0]), 'utf8')).split('\n').filter((l) => l.trim() !== '')
+check('the second turn appends instead of rewriting', () => {
+  assert.equal(after.length, 2, String(after.length))
+  assert.ok(after[1].includes('实体页'), after[1])
+})
+
+/* Trivial turns are dropped, so the vault does not fill with noise. */
+emit('session/event', session, {
+  type: 'user/message',
+  seq: 8,
+  time: Date.now(),
+  data: { role: 'user', content: [{ type: 'text', text: 'ok' }] },
+})
+emit('session/event', session, { type: 'turn/end', seq: 9, time: Date.now(), data: { turn: 9, reason: { kind: 'completed' } } })
+await new Promise((resolve) => setTimeout(resolve, 60))
+
+const finalLines = (await fsp.readFile(path.join(dir, 'episodes', files[0]), 'utf8')).split('\n').filter((l) => l.trim() !== '')
+check('a one-word turn is not stored', () => {
+  assert.equal(finalLines.length, 2, String(finalLines.length))
+})
+
+/* An unknown session with no cwd still gets a sensible project tag. */
+emit('session/event', { id: 's-nocwd' }, {
+  type: 'user/message',
+  seq: 1,
+  time: Date.now(),
+  data: { role: 'user', content: [{ type: 'text', text: '这个会话没有工作目录，也应该能记下来。' }] },
+})
+emit('session/event', { id: 's-nocwd' }, { type: 'turn/end', seq: 2, time: Date.now(), data: { turn: 1, reason: { kind: 'completed' } } })
+await new Promise((resolve) => setTimeout(resolve, 60))
+
+const allLines = (await fsp.readFile(path.join(dir, 'episodes', files[0]), 'utf8')).split('\n').filter((l) => l.trim() !== '')
+check('a session without cwd falls back to the default project', () => {
+  assert.equal(allLines.length, 3, String(allLines.length))
+  assert.equal(JSON.parse(allLines[2]).project, cfg.defaultProject)
+})
+
+/* Injected context — a compaction checkpoint, a runtime snapshot, a time
+   prelude, a skill catalog, an approval notice — arrives as a user message but
+   is not a conversation. `source.kind` marks it; the last entry has no
+   provenance at all, to exercise the text-pattern fallback. */
+const injections = [
+  { source: { kind: 'compact-checkpoint', form: 'checkpoint' }, text: 'This is an automatically generated checkpoint condensing an earlier span of the conversation to free up context. Treat the captured context as established background.' },
+  { source: { kind: 'runtime-context', form: 'snapshot' }, text: 'Current runtime context. This snapshot supersedes earlier runtime-context snapshots.' },
+  { source: { kind: 'time-context', form: 'sampled' }, text: 'Time sampled while preparing turn 3, step 1: 2026-11-02T15:37:18+08:00[Asia/Shanghai]' },
+  { source: { kind: 'skill-catalog', form: 'catalog' }, text: '<system-reminder>\nThe available skill catalog changed. This complete catalog replaces every earlier available-skills list in this session.\n</system-reminder>' },
+  { source: { kind: 'user-approval' }, text: 'The approval policy changed from "ask" to "never" (changed by the user).' },
+  { text: 'Current runtime context. This snapshot supersedes earlier runtime-context snapshots.' },
+  // The live bug: a runtime snapshot arriving tagged as if the person typed it.
+  { source: { kind: 'user' }, text: 'Current runtime context. This snapshot supersedes earlier runtime-context snapshots.' },
+]
+for (const [i, { source, text }] of injections.entries()) {
+  emit('session/event', session, {
+    type: 'user/message',
+    seq: 20 + i,
+    time: Date.now(),
+    data: { role: 'user', content: [{ type: 'text', text }], ...(source ? { source } : {}) },
+  })
+  emit('session/event', session, {
+    type: 'assistant/message',
+    seq: 40 + i,
+    time: Date.now(),
+    data: { turn: 20 + i, step: 1, message: { role: 'assistant', content: [{ type: 'text', text: '收到，继续原来的工作。' }] }, stream: null },
+  })
+  emit('session/event', session, { type: 'turn/end', seq: 60 + i, time: Date.now(), data: { turn: 20 + i, reason: { kind: 'completed' } } })
+}
+await new Promise((resolve) => setTimeout(resolve, 60))
+
+const readLines = async () =>
+  (await fsp.readFile(path.join(dir, 'episodes', files[0]), 'utf8')).split('\n').filter((l) => l.trim() !== '')
+
+const afterInjections = await readLines()
+check('injected context is never stored as a memory', () => {
+  assert.equal(afterInjections.length, 3, String(afterInjections.length))
+  assert.equal(afterInjections.some((l) => l.includes('automatically generated checkpoint')), false)
+  assert.equal(afterInjections.some((l) => l.includes('system-reminder')), false)
+  assert.equal(afterInjections.some((l) => l.includes('Time sampled')), false)
+  assert.equal(afterInjections.some((l) => l.includes('approval policy')), false)
+})
+
+/* The filter must not swallow the real turn that follows an injection. */
+emit('session/event', session, {
+  type: 'user/message',
+  seq: 80,
+  time: Date.now(),
+  data: { role: 'user', content: [{ type: 'text', text: '压缩之后继续：请检查一下 capture 的 flush 时机。' }], source: { kind: 'user', rpcId: 'r-2' } },
+})
+emit('session/event', session, {
+  type: 'assistant/message',
+  seq: 81,
+  time: Date.now(),
+  data: { turn: 30, step: 1, message: { role: 'assistant', content: [{ type: 'text', text: 'flush 现在挂在 turn/end 上。' }] }, stream: null },
+})
+emit('session/event', session, { type: 'turn/end', seq: 82, time: Date.now(), data: { turn: 30, reason: { kind: 'completed' } } })
+await new Promise((resolve) => setTimeout(resolve, 60))
+
+const afterReal = await readLines()
+check('a real turn after an injection is still stored', () => {
+  assert.equal(afterReal.length, 4, String(afterReal.length))
+  assert.ok(afterReal[3].includes('flush'), afterReal[3])
+})
+
+check('an injected turn is dropped even when the model replied to it', () => {
+  assert.equal(afterReal.some((l) => l.includes('收到，继续原来的工作')), false, afterReal.join('\n'))
+})
+
+/* A real message that carries a reminder keeps its own words: the block is
+   stripped, the message is not thrown away with it. */
+emit('session/event', session, {
+  type: 'user/message',
+  seq: 90,
+  time: Date.now(),
+  data: {
+    role: 'user',
+    content: [{ type: 'text', text: '<system-reminder>\nThe available skill catalog changed. This complete catalog replaces every earlier available-skills list in this session.\n</system-reminder>\n\n为什么以前的会话有些没有情节' }],
+    source: { kind: 'user' },
+  },
+})
+emit('session/event', session, {
+  type: 'assistant/message',
+  seq: 91,
+  time: Date.now(),
+  data: { turn: 31, step: 1, message: { role: 'assistant', content: [{ type: 'text', text: '因为采集是从插件在场那一刻开始的。' }] }, stream: null },
+})
+emit('session/event', session, { type: 'turn/end', seq: 92, time: Date.now(), data: { turn: 31, reason: { kind: 'completed' } } })
+await new Promise((resolve) => setTimeout(resolve, 60))
+
+const afterReminder = await readLines()
+check('a reminder inside a real message is stripped, not the message', () => {
+  assert.equal(afterReminder.length, 5, String(afterReminder.length))
+  const last = JSON.parse(afterReminder[4])
+  assert.equal(last.user, '为什么以前的会话有些没有情节')
+  assert.equal(afterReminder[4].includes('skill catalog'), false)
+})
+check('disposing removes the listeners', () => {
+  for (const item of dispose) item()
+  assert.equal((handlers.get('session/event') ?? []).length, 0)
+})
+
+console.log(results.join('\n'))
+if (process.exitCode) {
+  console.log('\nSOME CHECKS FAILED')
+} else {
+  console.log(`\nall ${results.length} checks passed`)
+  await fsp.rm(dir, { recursive: true, force: true })
+}