dsh-memu-memory 1.1.3 → 1.2.0

package/scripts/chain-matrix.mjs

@@ -262,9 +262,19 @@ function remoteVectorRetrieve(libraryId) {
 }
 
 // ------------------------------------------------------------ 宿主 ctx（fork 宿主）
+// 加权唤醒要求真实的检查理由：多回合、有结论、有去重后的工具工作。
+// 只有一条消息 + 一个工具调用的旧 fixture 现在会（正确地）落进 low-score。
 const TRANSCRIPT = [
   { seq: 0, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: '帮我把这段对话里值得记的东西整理成记忆，尤其是海边的那个傍晚。' }] } },
-  { seq: 1, type: 'assistant/message', data: { message: { content: [{ type: 'tool-call', name: 'read', arguments: '{}' }] } } },
+  { seq: 1, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: '另外把回滚步骤和失败原因也写清楚。' }] } },
+  { seq: 2, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: '最后给我一版可以直接照做的清单。' }] } },
+  { seq: 3, type: 'assistant/message', data: { message: { content: [
+    { type: 'text', text: '海边的傍晚那一段是这次对话里最值得留下的内容。'.repeat(120) },
+    { type: 'tool-call', name: 'read', arguments: '{}' },
+  ] } } },
+  { seq: 4, type: 'tool/result', data: { message: { isError: false, content: [{ type: 'text', text: '回滚步骤与失败明细'.repeat(160) }] } } },
+  { seq: 5, type: 'tool/result', data: { message: { isError: false, content: [{ type: 'text', text: '迁移账本与索引差异'.repeat(160) }] } } },
+  { seq: 6, type: 'tool/result', data: { message: { isError: false, content: [{ type: 'text', text: '验收清单与测试输出'.repeat(160) }] } } },
 ]
 
 function makeHost({ sessionId, cwd, onFork }) {

package/scripts/check-all.mjs

@@ -18,7 +18,16 @@ const check = (label, command, args) => {
 }
 
 for (const dir of ['lib', 'scripts', 'tests']) {
-  for (const file of fs.readdirSync(path.join(root, dir), { recursive: true })) {
+  const abs = path.join(root, dir)
+  // 一个目录可以合法缺席：老版本 npm 包不发布 tests/，开发检出里才有。
+  // 以前这里直接 readdirSync，产物内 `npm run check` 会 ENOENT 崩在第一步，
+  // 而 `npm test` 因为通配符匹配不到文件反而报 0 条测试、exit 0（假绿）。
+  // 缺席就 skip 并说明，不当作失败，也不让脚本崩。
+  if (!fs.existsSync(abs)) {
+    console.log(`skip ${dir}/: directory not present in this install`)
+    continue
+  }
+  for (const file of fs.readdirSync(abs, { recursive: true })) {
     if (!/\.(js|mjs)$/.test(file)) continue
     check(`${dir}/${file}`, process.execPath, ['--check', path.join(dir, file)])
   }

package/tests/activation.test.mjs

@@ -0,0 +1,89 @@
+// The activation line is the only place that answers "is memory actually on" without
+// a debugger, and the silent-recall bug (P0-1) would have been visible from it. It was
+// written by hand into a doc as an acceptance step nobody could run, because the host
+// keeps no log on disk. So the line is asserted here instead: apply() runs against a
+// fake context and the message has to match the live settings, not a stale copy.
+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-activation-'))
+process.env.DSH_MEMU_HOME = home
+
+const plugin = await import('../lib/index.js')
+const { ENGINE_VERSION } = await import('../lib/engine.js')
+const { getSettings, getMemoryBackend } = await import('../lib/state.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function fakeCtx() {
+  const info = []
+  const warn = []
+  const tools = []
+  const disposers = []
+  const handlers = []
+  const scope = {
+    effect(fn, _label) { const dispose = fn(); if (typeof dispose === 'function') disposers.push(dispose) },
+    tools: { register(tool) { tools.push(tool); return () => {} } },
+    webServer: { register() { return () => {} } },
+    connection: { requestRejection: () => undefined },
+    interval() { return 1 },
+    // cordis event API: everything this plugin hangs off the agent loop arrives here.
+    on(event, handler) { handlers.push({ event, handler }); return () => {} },
+  }
+  const ctx = {
+    ...scope,
+    logger: { info: (m) => info.push(m), warn: (m) => warn.push(m) },
+    inject(_deps, callback) { callback(scope) },
+  }
+  return { ctx, info, warn, tools, disposers, handlers }
+}
+const LOADED = /^dsh-memu-memory: loaded \(engine (\S+)\) backend=(\S+) autoInject=(\S+) anchorTokens=(\d+) turnTokens=(\d+) mustRememberCap=(\d+) unpinBudget=(\d+)$/
+
+test('the activation line reports the live configuration', () => {
+  const { ctx, info, warn } = fakeCtx()
+  plugin.apply(ctx)
+  const line = info.find((message) => message.startsWith('dsh-memu-memory: loaded'))
+  assert.ok(line, 'apply() must log the activation line')
+  const match = LOADED.exec(line)
+  assert.ok(match, 'the line must keep the shape the docs promise: ' + line)
+
+  const settings = getSettings()
+  assert.equal(match[1], ENGINE_VERSION, 'the engine version must be the one the code expects')
+  assert.equal(match[2], getMemoryBackend(), 'the backend must be the live one')
+  assert.equal(match[3], settings.autoInject)
+  assert.equal(Number(match[4]), settings.anchorTokens, 'the budget is config, not a hard-coded number')
+  assert.equal(Number(match[5]), settings.turnTokens)
+  assert.equal(Number(match[6]), settings.mustRememberCap)
+  assert.equal(Number(match[7]), settings.unpinBudgetPerSession)
+  assert.equal(warn.filter((m) => m.includes('startup summary failed')).length, 0, 'the summary must not fall back to a warning')
+})
+
+test('a changed budget shows up in the next activation', async () => {
+  const state = await import('../lib/state.js')
+  state.updateSettings({ anchorTokens: 512, turnTokens: 320, mustRememberCap: 7 })
+  try {
+    const { ctx, info } = fakeCtx()
+    plugin.apply(ctx)
+    const match = LOADED.exec(info.find((message) => message.startsWith('dsh-memu-memory: loaded')))
+    assert.equal(Number(match[4]), 512, 'the line reads the setting, so a tuning change is visible in the log')
+    assert.equal(Number(match[5]), 320)
+    assert.equal(Number(match[6]), 7)
+  } finally {
+    state.updateSettings({ anchorTokens: 800, turnTokens: 800, mustRememberCap: 12 })
+  }
+})
+
+test('a second apply() on the same context warns instead of registering twice', () => {
+  const { ctx, tools, warn } = fakeCtx()
+  plugin.apply(ctx)
+  const first = tools.length
+  const infoAfterFirst = warn.length
+  plugin.apply(ctx)
+  assert.equal(tools.length, first, 'tools must not be registered twice')
+  assert.ok(warn.slice(infoAfterFirst).some((m) => /already ran/.test(m)), 'the guard must say so')
+})