dsh-memu-memory 1.1.3 → 1.2.0

package/tests/storage.test.mjs

@@ -0,0 +1,125 @@
+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-storage-'))
+process.env.DSH_MEMU_HOME = home
+
+const state = await import('../lib/state.js')
+
+const indexDir = path.join(home, 'index')
+const stateFile = path.join(home, 'state.json')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function quarantinedOf(base) {
+  try {
+    return fs.readdirSync(indexDir).filter((name) => name.startsWith(`${base}.corrupt-`))
+  } catch {
+    return []
+  }
+}
+
+test('a missing index is not a failure and does not block the first write', () => {
+  const libId = 'lib_missing'
+  assert.deepEqual(state.loadPrivateIndex(libId).entries, {})
+  state.savePrivateIndex(libId, { version: 1, entries: { 'mem-1': { id: 'mem-1', content: 'x' } } })
+  assert.equal(state.loadPrivateIndex(libId).entries['mem-1'].content, 'x')
+  assert.deepEqual(quarantinedOf(`${libId}.json`), [])
+  assert.equal(state.storageHealth().issues.length, 0)
+})
+
+test('a corrupt index keeps its raw bytes and is not written over', () => {
+  const libId = 'lib_corrupt'
+  const file = path.join(indexDir, `${libId}.json`)
+  const broken = '{ "entries": { "mem-9": { "content": "别丢" '
+  fs.writeFileSync(file, broken, 'utf8')
+
+  assert.deepEqual(state.loadPrivateIndex(libId).entries, {})
+
+  const kept = quarantinedOf(`${libId}.json`)
+  assert.equal(kept.length, 1)
+  assert.equal(fs.readFileSync(path.join(indexDir, kept[0]), 'utf8'), broken)
+  assert.equal(fs.existsSync(file), false)
+
+  assert.throws(() => state.savePrivateIndex(libId, { entries: {} }), /earlier read failed/)
+  // Recovery is explicit: restore a valid file, then the successful read lifts the barrier.
+  fs.writeFileSync(file, JSON.stringify({ entries: { 'mem-recovered': { content: 'restored' } } }))
+  assert.equal(state.loadPrivateIndex(libId).entries['mem-recovered'].content, 'restored')
+  state.savePrivateIndex(libId, { version: 1, entries: { 'mem-2': { id: 'mem-2' } } })
+  assert.equal(state.loadPrivateIndex(libId).entries['mem-2'].id, 'mem-2')
+  assert.equal(fs.readFileSync(path.join(indexDir, kept[0]), 'utf8'), broken)
+})
+
+test('an unreadable index blocks writes until it reads cleanly again', () => {
+  const libId = 'lib_busy'
+  const file = path.join(indexDir, `${libId}.json`)
+  // A directory where a file is expected makes readFileSync fail with EISDIR —
+  // the same class as EBUSY/EMFILE: the bytes are fine, we just cannot see them.
+  fs.mkdirSync(file, { recursive: true })
+
+  assert.deepEqual(state.loadPrivateIndex(libId).entries, {})
+  assert.deepEqual(quarantinedOf(`${libId}.json`), [], 'an I/O failure must not move the file aside')
+  assert.equal(fs.existsSync(file), true)
+
+  assert.throws(
+    () => state.savePrivateIndex(libId, { version: 1, entries: {} }),
+    (error) => error.code === 'dsh-memu-memory/read-failed',
+  )
+  assert.ok(state.storageHealth().issues.some((issue) => issue.file.includes(libId)))
+
+  // Obstruction gone -> the next successful read lifts the barrier.
+  fs.rmdirSync(file)
+  state.loadPrivateIndex(libId)
+  state.savePrivateIndex(libId, { version: 1, entries: { 'mem-3': { id: 'mem-3' } } })
+  assert.equal(state.loadPrivateIndex(libId).entries['mem-3'].id, 'mem-3')
+})
+
+test('a corrupt state.json is quarantined instead of silently emptying the plugin', () => {
+  state.setWorkspacePolicy(path.join(home, 'proj'), { useLibrary: false })
+  assert.ok(Object.keys(state.loadState().workspacePolicies).length > 0)
+  // Flush first: with local changes pending, the cache is authoritative by design
+  // and an external rewrite would just be overwritten by our own flush.
+  state.flushState()
+
+  const broken = '{ "version": 1, "libraries": { '
+  fs.writeFileSync(stateFile, broken, 'utf8')
+
+  const recovered = state.loadState()
+  assert.deepEqual(recovered.libraries, {})
+  const kept = fs.readdirSync(home).filter((name) => name.startsWith('state.json.corrupt-'))
+  assert.equal(kept.length, 1)
+  assert.equal(fs.readFileSync(path.join(home, kept[0]), 'utf8'), broken)
+
+  state.setWorkspacePolicy(path.join(home, 'proj'), { useGlobal: false })
+  assert.equal(state.getWorkspacePolicy(path.join(home, 'proj')).useGlobal, false)
+  assert.throws(() => state.flushState(), /earlier read failed/)
+  assert.equal(fs.readFileSync(path.join(home, kept[0]), 'utf8'), broken)
+  fs.writeFileSync(stateFile, JSON.stringify({ version: 1, libraries: {}, sessions: {}, workspacePolicies: {} }))
+  state.flushState()
+})
+
+test('an unreadable state.json blocks writes rather than replacing it with defaults', () => {
+  state.flushState()
+  const saved = fs.readFileSync(stateFile, 'utf8')
+  fs.rmSync(stateFile)
+  fs.mkdirSync(stateFile)
+
+  assert.deepEqual(state.loadState().libraries, {})
+  assert.equal(state.storageHealth().issues[0].file, 'state.json')
+
+  // Bookkeeping writes are deferred now, so the refusal surfaces on flush.
+  state.setWorkspacePolicy(path.join(home, 'other'), { useLibrary: false })
+  assert.throws(() => state.flushState(), (error) => error.code === 'dsh-memu-memory/read-failed')
+  assert.ok(fs.statSync(stateFile).isDirectory(), 'the unreadable path was left untouched')
+
+  fs.rmdirSync(stateFile)
+  fs.writeFileSync(stateFile, saved, 'utf8')
+  assert.equal(state.loadState().workspacePolicies != null, true)
+  state.flushState()
+  assert.equal(state.storageHealth().issues.length, 0)
+})

package/tests/stubs/dsh-llm.js

@@ -0,0 +1,5 @@
+import crypto from 'node:crypto'
+
+export function createUserMessage(input) {
+  return { id: crypto.randomUUID(), role: 'user', ...input }
+}

package/tests/stubs/dsh-session.js

@@ -0,0 +1,7 @@
+// The host exports buildForkSeed from @deepseek-ai/dsh-session. Consolidation
+// forks a seeded copy of the transcript, so the fork builder is on the critical
+// path of every agent-backend consolidation — without a stub here those tests
+// could only ever exercise the "fork builder unavailable" failure branch.
+export function buildForkSeed(events, lastSeq) {
+  return { seeded: true, events, lastSeq }
+}

package/tests/stubs/dsh-tools.js

@@ -0,0 +1,101 @@
+// A faithful stand-in for the host's `defineTool`: it compiles tool schemas with
+// the same value-schema DSL rules as @deepseek-ai/dsh-tools, so a schema the real
+// host rejects fails here too. The previous stub was `return spec`, which meant
+// 320 green tests could not see that the host refused every one of the ten tools.
+//
+// Rules mirrored from packages/core/tools/src/schema.ts (host):
+//  - annotations are description/title/default/examples;
+//  - an object node needs an explicit boolean `additionalProperties`;
+//  - an array node accepts only type/items (annotations allowed), and its items are
+//    compiled WITHOUT `required` — nested required must be inline `required: true`;
+//  - `required` on a property must be the literal `true`;
+//  - any other key is rejected.
+
+const ANNOTATION_KEYS = ['description', 'title', 'default', 'examples']
+
+function assertAuthorKeys(source, path, allowed) {
+  for (const key of Object.keys(source)) {
+    if (!allowed.includes(key)) {
+      throw new Error(`${path}.${key} is not supported by the value schema DSL`)
+    }
+  }
+}
+
+function compileValueSchema(source, path, { allowRequired = false } = {}) {
+  if (source === null || typeof source !== 'object' || Array.isArray(source)) {
+    throw new Error(`${path} must be a value schema object`)
+  }
+  const type = source.type
+  switch (type) {
+    case 'object': {
+      assertAuthorKeys(source, path, [
+        ...ANNOTATION_KEYS,
+        ...(allowRequired ? ['required'] : []),
+        'type', 'properties', 'additionalProperties',
+      ])
+      if (allowRequired && Object.hasOwn(source, 'required') && source.required !== true) {
+        throw new Error(`${path}.required must be true when present`)
+      }
+      if (typeof source.additionalProperties !== 'boolean') {
+        throw new Error(`${path}.additionalProperties must be explicitly true or false`)
+      }
+      const properties = source.properties ?? {}
+      if (properties === null || typeof properties !== 'object' || Array.isArray(properties)) {
+        throw new Error(`${path}.properties must be a property map`)
+      }
+      for (const [key, value] of Object.entries(properties)) {
+        compileValueSchema(value, `${path}.properties.${key}`, { allowRequired: true })
+      }
+      return { type: 'object', additionalProperties: source.additionalProperties, properties }
+    }
+    case 'array': {
+      assertAuthorKeys(source, path, [...ANNOTATION_KEYS, 'type', 'items'])
+      if (source.items === undefined) throw new Error(`${path}.items must be a value schema`)
+      compileValueSchema(source.items, `${path}.items`, { allowRequired: false })
+      return { type: 'array', items: source.items }
+    }
+    case 'string':
+    case 'number':
+    case 'integer':
+    case 'boolean':
+    case 'null': {
+      assertAuthorKeys(source, path, [
+        ...ANNOTATION_KEYS,
+        ...(allowRequired ? ['required'] : []),
+        'type', 'enum', 'const',
+      ])
+      if (allowRequired && Object.hasOwn(source, 'required') && source.required !== true) {
+        throw new Error(`${path}.required must be true when present`)
+      }
+      return { type }
+    }
+    default:
+      throw new Error(`${path}.type ${JSON.stringify(type)} is not supported by the value schema DSL`)
+  }
+}
+
+function compileParameterSchema(parameters, path = 'parameters') {
+  if (parameters === null || typeof parameters !== 'object' || Array.isArray(parameters)) {
+    throw new Error(`${path} must be a property map`)
+  }
+  // The host compiles the implicit open parameter object: extra keys are allowed.
+  for (const [key, value] of Object.entries(parameters)) {
+    compileValueSchema(value, `${path}.${key}`, { allowRequired: true })
+  }
+  return parameters
+}
+
+export function defineTool(options) {
+  if (options === null || typeof options !== 'object') throw new Error('defineTool requires an options object')
+  if (typeof options.name !== 'string' || !options.name) throw new Error('defineTool requires a non-empty name')
+  if (typeof options.description !== 'string') throw new Error(`${options.name}: defineTool requires a description`)
+  if (typeof options.timeoutMs !== 'number' || !Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
+    throw new Error(`${options.name}: timeoutMs must be a positive finite number`)
+  }
+  if (typeof options.execute !== 'function') throw new Error(`${options.name}: defineTool requires an execute function`)
+  compileParameterSchema(options.parameters)
+  const outputSchema = options.output?.schema
+  if (outputSchema === undefined) throw new Error(`${options.name}: defineTool requires output.schema`)
+  compileValueSchema(outputSchema, `${options.name}.output.schema`, { allowRequired: false })
+  return options
+}

package/tests/tool-schema.test.mjs

@@ -0,0 +1,73 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import { defineTool } from './stubs/dsh-tools.js'
+
+// The stub compiles tool schemas with the host's value-schema DSL rules. These
+// cases pin the two shapes that the real host refused in production — the reason
+// all ten memu tools were missing from the tool surface while every test passed:
+// the old stub was `return spec`, so nothing was ever compiled.
+
+const good = (parameters) => ({
+  name: 'probe',
+  description: 'probe',
+  parameters,
+  output: { schema: { type: 'string' } },
+  timeoutMs: 1000,
+  execute: async () => 'ok',
+})
+
+test('an object node without an explicit additionalProperties is refused', () => {
+  assert.throws(
+    () => defineTool(good({
+      entity: { type: 'object', properties: { name: { type: 'string' } } },
+    })),
+    /parameters\.entity\.additionalProperties must be explicitly true or false/,
+  )
+})
+
+test('array-form required inside array items is refused', () => {
+  assert.throws(
+    () => defineTool(good({
+      attachments: {
+        type: 'array',
+        items: { type: 'object', properties: { sha256: { type: 'string' } }, required: ['sha256'], additionalProperties: true },
+      },
+    })),
+    /parameters\.attachments\.items\.required is not supported by the value schema DSL/,
+  )
+})
+
+test('nested required must be the literal true', () => {
+  assert.throws(
+    () => defineTool(good({
+      attachments: {
+        type: 'array',
+        items: { type: 'object', additionalProperties: true, properties: { sha256: { type: 'string', required: false } } },
+      },
+    })),
+    /required must be true when present/,
+  )
+  const tool = defineTool(good({
+    attachments: {
+      type: 'array',
+      items: { type: 'object', additionalProperties: true, properties: { sha256: { type: 'string', required: true } } },
+    },
+  }))
+  assert.equal(tool.name, 'probe')
+})
+
+test('a non-positive timeout is refused', () => {
+  assert.throws(() => defineTool({ ...good({}), timeoutMs: 0 }), /timeoutMs/)
+})
+
+test('the shipped tool surface compiles under the host rules', async () => {
+  const { registerTools } = await import('../lib/tools.js')
+  const registered = []
+  const dispose = registerTools({
+    tools: { register: (tool) => { registered.push(tool.name); return () => {} } },
+    logger: { warn: (message) => { throw new Error(`unexpected registration warning: ${message}`) } },
+  })
+  assert.equal(registered.length, 10, `registered ${registered.join(', ')}`)
+  dispose()
+})

package/tests/tools.test.mjs

@@ -0,0 +1,184 @@
+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-tools-'))
+process.env.DSH_MEMU_HOME = home
+
+const { registerTools } = await import('../lib/tools.js')
+const state = await import('../lib/state.js')
+const { updateSettings } = state
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function fakeCtx() {
+  const tools = []
+  const ctx = {
+    tools: {
+      register(tool) {
+        tools.push(tool)
+        return () => {}
+      },
+    },
+    logger: { warn() {} },
+  }
+  const dispose = registerTools(ctx)
+  return { ctx, tools, dispose }
+}
+
+const exec = {
+  agent: { session: { header: { id: 'tools-session', cwd: path.join(home, 'project-tools'), agentPreset: 'coding' } } },
+}
+
+test('all v1 tools register', () => {
+  const { tools, dispose } = fakeCtx()
+  const names = tools.map((t) => t.name)
+  for (const name of [
+    'memu_private_link',
+    'memu_private_remember',
+    'memu_private_recall',
+    'memu_private_list',
+    'memu_private_update',
+    'memu_private_archive',
+    'memu_private_unpin',
+    'memu_global_recall',
+    'memu_global_list',
+    'memu_status',
+  ]) {
+    assert.ok(names.includes(name), `missing ${name}`)
+  }
+  // Exactly ten, not "at least these nine": a schema the host DSL refuses used to
+  // abort registerTools() before any register() ran, so counting is the assertion
+  // that actually catches a total registration failure.
+  assert.equal(names.length, 10, `expected 10 tools, got ${names.length}: ${names.join(', ')}`)
+  dispose()
+})
+
+test('status works without an engine', async () => {
+  const { tools, dispose } = fakeCtx()
+  const status = await tools.find((t) => t.name === 'memu_status').execute({}, exec)
+  assert.match(status, /engine:/)
+  assert.match(status, /library:/)
+  // The registration count is the visible signal for a refused schema: without it
+  // a host that rejects the tool and a plugin that never had it look identical.
+  assert.match(status, /tools: 10\/10 registered/)
+  dispose()
+})
+
+test('private list stays usable without an active vector profile and says why', async () => {
+  const { tools, dispose } = fakeCtx()
+  updateSettings({ memoryBackend: 'api' })
+  try {
+    // The conversation must actually be bound: an unbound chat gets the
+    // "no library" answer instead, and never creates one just by listing.
+    state.ensureSession('tools-session', { cwd: path.join(home, 'project-tools') })
+    const text = await tools.find((t) => t.name === 'memu_private_list').execute({}, exec)
+    // No active generation means MemU cannot answer; the index still can. "Empty"
+    // on its own reads as lost memories, so the reason travels with the result.
+    assert.match(text, /私有记忆库 .* 为空。/)
+    assert.match(text, /本地向量未激活/)
+  } finally {
+    updateSettings({ memoryBackend: 'agent' })
+    dispose()
+  }
+})
+
+test('private list on an unbound conversation neither creates a library nor errors', async () => {
+  const { tools, dispose } = fakeCtx()
+  const before = state.listLibraries().length
+  const text = await tools.find((t) => t.name === 'memu_private_list').execute({}, {
+    agent: { session: { header: { id: 'tools-unbound', cwd: path.join(home, 'project-unbound'), agentPreset: 'coding' } } },
+  })
+  assert.match(text, /没有绑定记忆库/)
+  assert.equal(state.listLibraries().length, before, 'listing must not materialize a library')
+  dispose()
+})
+
+test('private list rows carry the same date label recall prints', async () => {
+  const { tools, dispose } = fakeCtx()
+  const cwd = path.join(home, 'project-dates')
+  const execDates = { agent: { session: { header: { id: 'tools-list-dates', cwd, agentPreset: 'coding' } } } }
+  state.ensureSession('tools-list-dates', { cwd })
+  const remember = tools.find((t) => t.name === 'memu_private_remember')
+  // Two forms of the same field: an appointment keeps its year, a birthday keeps MM-DD.
+  await remember.execute({ content: '明天要去考驾照。', title: '明天要考驾照', salient_date: '2026-10-29' }, execDates)
+  await remember.execute({ content: '生日是 10 月 28 日。', title: '生日', salient_date: '10-28' }, execDates)
+  const list = await tools.find((t) => t.name === 'memu_private_list').execute({}, execDates)
+  // A date only recall renders reads as "no date" in the list, so the two surfaces
+  // must agree on the spelling: date= for a one-off, anniversary= for a yearly one.
+  assert.match(list, /date=2026-10-29/)
+  assert.match(list, /anniversary=10-28/)
+  dispose()
+})
+
+test('must_remember requires a pin reason', async () => {
+  const { tools, dispose } = fakeCtx()
+  const text = await tools.find((t) => t.name === 'memu_private_remember').execute({
+    content: 'something worth keeping',
+    layer: 'must_remember',
+  }, exec)
+  assert.match(text, /pin_reason is required/)
+  dispose()
+})
+
+test('status separates "nobody polled" from "nothing was written"', async () => {
+  const { tools, dispose } = fakeCtx()
+  const { dispatch } = await import('../lib/rpc.js')
+  // A pane polling is what records a beat; a save is what records a write event.
+  await dispatch({}, 'getSidebarState', { revisionOnly: true })
+  state.savePrivateIndex('lib-sync', { version: 1, entries: {} })
+  const unbound = { agent: { session: { header: { id: 'tools-sync', cwd: path.join(home, 'project-sync') } } } }
+  const text = await tools.find((t) => t.name === 'memu_status').execute({}, unbound)
+  assert.match(text, /sync: heartbeat \d+s ago, last write private@lib-sync \d+s ago/)
+  dispose()
+})
+
+test('unpin is the model\'s call, guarded by reason, quota and cooldown', async () => {
+  const { tools, dispose } = fakeCtx()
+  const binding = state.ensureSession('tools-session', { cwd: path.join(home, 'project-tools'), agentPreset: 'coding' })
+  const index = state.loadPrivateIndex(binding.libraryId)
+  for (const id of ['mem-unpin', 'mem-unpin-2', 'mem-unpin-3']) {
+    index.entries[id] = {
+      track: 'memory',
+      layer: 'must_remember',
+      title: `A pinned memory ${id}`,
+      content: 'Something that used to matter.',
+      status: 'active',
+      pinSource: 'user_explicit',
+      pinReason: 'keep this',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }
+  }
+  state.savePrivateIndex(binding.libraryId, index)
+
+  const exec = { agent: { session: { header: { id: 'tools-session' } } } }
+  const unpin = (id, reason) => tools.find((t) => t.name === 'memu_private_unpin').execute({ id, reason }, exec)
+
+  const tooShort = await unpin('mem-unpin', 'let it go')
+  assert.match(tooShort, /at least 20 characters/)
+  assert.equal(state.loadPrivateIndex(binding.libraryId).entries['mem-unpin'].layer, 'must_remember')
+
+  const accepted = await unpin('mem-unpin', '那件事已经过去了，我现在能把它当成一件旧事来讲，而不是每次想起都疼。')
+  assert.match(accepted, /long_term|marginalized|边缘化/)
+  const after = state.loadPrivateIndex(binding.libraryId).entries['mem-unpin']
+  assert.equal(after.layer, 'long_term')
+  assert.equal(after.marginalized, true)
+  assert.equal(after.unpinnedBy, 'model')
+  assert.ok(after.originalPinSource !== undefined)
+
+  // Cooldown: a second unpin right after is refused even though quota remains.
+  const cooldown = await unpin('mem-unpin-2', '这次也一样，我已经能平静地说完了，不再需要一直记着。')
+  assert.match(cooldown, /cooldown/)
+  assert.equal(state.loadPrivateIndex(binding.libraryId).entries['mem-unpin-2'].layer, 'must_remember')
+
+  // Quota: once the conversation has spent it, memory stays pinned.
+  state.setSessionBinding('tools-session', { lastUnpinAt: null, unpinCount: 2 })
+  const quota = await unpin('mem-unpin-3', '我已经想清楚了，这件事可以放下来，不必再一直提醒自己。')
+  assert.match(quota, /quota/)
+  dispose()
+})

package/tests/ui-defaults.test.mjs

@@ -0,0 +1,57 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// L3 audit item: the settings page in lib/client.js renders a hard-coded
+// fallback for every numeric field (`settings.x ?? N`). The browser bundle
+// cannot import lib/state.js, so those literals are the only client-side copy
+// of DEFAULT_SETTINGS. They had drifted (privateTopK 4 vs 5, globalTopK 3 vs 5,
+// dedupeTurns 8 vs 16, ...), and because the fallback paints before the first
+// getState reply, saving in that window persisted the wrong value.
+// This gate keeps the two lists equal.
+
+const HERE = path.dirname(fileURLToPath(import.meta.url))
+const REPO = path.resolve(HERE, '..')
+const state = await import(new URL('../lib/state.js', import.meta.url).href)
+const clientSource = fs.readFileSync(path.join(REPO, 'lib', 'client.js'), 'utf8')
+
+function clientFallbacks() {
+  const found = new Map()
+  for (const match of clientSource.matchAll(/settings\.([A-Za-z0-9_]+)\s*\?\?\s*(-?\d+(?:\.\d+)?)/g)) {
+    const key = match[1]
+    const value = Number(match[2])
+    assert.ok(!found.has(key), 'settings.' + key + ' has more than one fallback literal in lib/client.js')
+    found.set(key, value)
+  }
+  return found
+}
+
+test('every client-side settings fallback equals its DEFAULT_SETTINGS value', () => {
+  const fallbacks = clientFallbacks()
+  assert.ok(fallbacks.size >= 10, 'expected the settings grid fallbacks to be discoverable, found ' + fallbacks.size)
+  const drift = []
+  for (const [key, value] of fallbacks) {
+    const expected = state.DEFAULT_SETTINGS[key]
+    if (typeof expected !== 'number') continue
+    if (expected !== value) drift.push('settings.' + key + ' ?? ' + value + ' but DEFAULT_SETTINGS.' + key + ' is ' + expected)
+  }
+  assert.deepEqual(drift, [], 'client fallbacks drifted from DEFAULT_SETTINGS: ' + drift.join('; '))
+})
+
+test('the audited numeric fields are covered by that gate', () => {
+  const fallbacks = clientFallbacks()
+  for (const [key, expected] of [
+    ['privateTopK', 5],
+    ['globalTopK', 5],
+    ['mustRememberCap', 12],
+    ['dedupeTurns', 16],
+    ['globalEveryNTurns', 6],
+    ['randomCueChance', 0.02],
+    ['sleepAfterIdleMinutes', 3],
+  ]) {
+    assert.equal(fallbacks.get(key), expected, 'settings.' + key + ' fallback')
+    assert.equal(state.DEFAULT_SETTINGS[key], expected, 'DEFAULT_SETTINGS.' + key)
+  }
+})