dsh-lite-memory 0.16.2 → 0.17.0

package/test/runtime-context.test.mjs

@@ -0,0 +1,186 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+process.env.DSH_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-runtime-'));
+const { apply } = await import('../index.js');
+const store = await import('../store.js');
+const state = await import('../state.js');
+
+const effect = (fn) => {
+  const dispose = fn();
+  return typeof dispose === 'function' ? dispose : () => {};
+};
+
+function boot(mode = 'adaptive') {
+  const defs = new Map();
+  const handlers = new Map();
+  const promptContexts = [];
+  const ctx = {
+    tools: { register: (def) => { defs.set(def.name, def); return () => {}; } },
+    effect,
+    inject: () => () => {},
+    get: (name) => (name === 'systemPrompt'
+      ? { context: (entry) => { promptContexts.push(entry); return () => {}; } }
+      : name === 'agents' ? { currentInitiator: () => null } : undefined),
+    on: (event, handler) => {
+      const list = handlers.get(event) || [];
+      list.push(handler);
+      handlers.set(event, list);
+      return () => {};
+    },
+  };
+  apply(ctx, { mode });
+  const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  assert.ok(provider, 'recall provider registered');
+  const exec = (name, args, agent) => defs.get(name).execute(args, { agent });
+  const preStep = (payload, decision) => handlers.get('agent/pre-step').at(-1)(payload, async () => decision);
+  return { defs, provider, exec, preStep, text: (agent, signal) => provider.text({ agent, signal }), debug: globalThis.__liteMemoryRecall };
+}
+
+const signal = () => new AbortController().signal;
+let seq = 0;
+const human = (body) => {
+  seq += 1;
+  return { role: 'user', id: `msg-${seq}`, source: { kind: 'user' }, content: [{ type: 'text', text: body }] };
+};
+const enter = (...messages) => ({ kind: 'enter', messages });
+const mkdir = (label) => fs.mkdtempSync(path.join(os.tmpdir(), `lite-memory-runtime-${label}-`));
+const makeAgent = (id, dir) => ({ id, cwd: dir, session: { id: `session-${id}`, header: { cwd: dir } } });
+
+const save = (scope, fields) => {
+  const result = store.upsert(scope, {
+    applicability: fields.applicability ?? ((fields.conditions || []).length ? 'conditional' : 'all_in_scope'),
+    body: `正文：${fields.title}`,
+    resolution: 'distinct',
+    ...fields,
+    summary: fields.summary ?? `${fields.title}的摘要`,
+  });
+  assert.equal(result.ok !== false, true, result.reason);
+  return { ...result, id: result.record?.id ?? result.id };
+};
+
+const enable = (scope, defaults) => {
+  const turned = store.setEvolution(scope, true, { operationId: `op-on-${Math.random().toString(16).slice(2)}` });
+  assert.equal(turned.ok, true, turned.reason);
+  if (defaults) {
+    const applied = store.setTaskDefault(scope, defaults);
+    assert.equal(applied.ok, true, applied.reason);
+  }
+};
+
+const seedRule = (scope, { title, body, summary, conditions = [], learning = { state: 'active' } }) => {
+  const saved = save(scope, { title, body, summary, tags: ['实验'] });
+  state.transact(scope, {}, (draft) => {
+    const row = draft.entries.find((entry) => entry.id === saved.id);
+    row.origin = 'project_evolution';
+    row.current.conditions = conditions;
+    row.maintenance.learning = { ...learning };
+    return { changed: true };
+  });
+  return saved.id;
+};
+
+/* R01：自进化关闭时，普通条件记忆照常按当前任务召回，且不会注入实验正文。 */
+{
+  const dir = mkdir('normal-off');
+  const scope = store.scopeOf(dir);
+  save(scope, {
+    title: '数据库连接池排查顺序',
+    body: '先看连接数上限，再看慢查询和泄漏。',
+    conditions: [{ key: 'taskKind', value: 'code' }],
+    tags: ['数据库'],
+  });
+  const runtime = boot();
+  const agent = makeAgent('r01', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 'r01' }, enter(human('排查 PostgreSQL 连接池报错')));
+  const text = runtime.text(agent, sig);
+  assert.match(text, /数据库连接池排查顺序/);
+  const win = runtime.debug.windowOf(agent);
+  assert.equal(win.experiment, null);
+  assert.ok(win.runtime && win.runtime.task, 'runtime context exists');
+  assert.equal(win.runtime.task.kind, 'code');
+  assert.equal(win.runtime.experimental, false);
+}
+
+/* R02：明确撤销先于延续；换任务后旧栏目规则不进入本轮。 */
+{
+  const dir = mkdir('revoke');
+  const scope = store.scopeOf(dir);
+  enable(scope, { seriesId: '口播', taskKind: 'content' });
+  seedRule(scope, {
+    title: '口播开头先给结论',
+    body: '开场三句内给结论。',
+    summary: '口播开头规则',
+    conditions: [{ key: 'seriesId', value: '口播' }],
+  });
+  const runtime = boot();
+  const agent = makeAgent('r02', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 'r02' }, enter(human('先不做口播，排查 PostgreSQL 连接池故障')));
+  const text = runtime.text(agent, sig);
+  assert.doesNotMatch(text, /口播开头先给结论|口播开头规则/);
+  const win = runtime.debug.windowOf(agent);
+  assert.equal(win.runtime.task.kind, 'code');
+  assert.equal(win.runtime.task.seriesId, '');
+  assert.ok(win.experiment, 'experiment window is bound to the request');
+  assert.equal(win.experiment.decision.kind, 'rules');
+  assert.equal(win.experiment.experimentParts, null);
+}
+
+/* R03：普通卡片与实验规则共用 3 条 / 1200 字节预算，先到先得、不截断。 */
+{
+  const dir = mkdir('budget');
+  const scope = store.scopeOf(dir);
+  enable(scope, { seriesId: '口播', taskKind: 'content' });
+  for (let index = 0; index < 4; index += 1) {
+    save(scope, {
+      title: `口播节奏规范 ${index}`,
+      body: `第 ${index} 条正文，说明节奏和停顿。`,
+      conditions: [{ key: 'seriesId', value: '口播' }],
+      tags: ['口播'],
+    });
+  }
+  for (let index = 0; index < 4; index += 1) {
+    seedRule(scope, {
+      title: `口播实验规则 ${index}`,
+      body: `实验正文 ${index}，开场结论。`,
+      summary: `实验规则 ${index}`,
+      conditions: [{ key: 'seriesId', value: '口播' }],
+    });
+  }
+  const runtime = boot();
+  const agent = makeAgent('r03', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 'r03' }, enter(human('这期口播开头怎么改')));
+  const text = runtime.text(agent, sig);
+  const win = runtime.debug.windowOf(agent);
+  const auto = win.autoBudget;
+  assert.ok(auto, 'shared budget exists');
+  assert.ok(auto.cards <= 3, `cards ${auto.cards} over cap`);
+  assert.ok(auto.cardBytes <= 1200, `bytes ${auto.cardBytes} over cap`);
+  assert.ok(auto.experimentBytes <= 1200, 'experiment bytes over cap');
+  assert.ok(auto.cardBytes <= 1200);
+  assert.ok(Buffer.byteLength(text) <= 1300, 'rendered text exceeds budget');
+  const heads = new Set(text.split('\n').filter((line) => /口播(节奏规范|实验规则)/.test(line)).map((line) => line.trim()));
+  assert.ok(heads.size <= 3, `too many cards: ${heads.size}`);
+}
+
+/* R04：普通开关关闭时不再召回，但已有数据仍可被管理面读取。 */
+{
+  const dir = mkdir('off');
+  const scope = store.scopeOf(dir);
+  const saved = save(scope, { title: '普通偏好', body: '回复用中文。', tags: ['偏好'] });
+  store.setMemoryEnabled(scope, false);
+  const runtime = boot();
+  const agent = makeAgent('r04', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 'r04' }, enter(human('以后回复用什么语言')));
+  assert.equal(runtime.text(agent, sig), '');
+  const index = store.loadIndex(scope);
+  assert.ok(index.entries.some((entry) => entry.id === saved.id));
+}
+
+console.log('runtime-context: all passed');

package/test/state.test.mjs

@@ -145,10 +145,10 @@ test('D02 响应丢了：同一 operationId 重放回执，不再写一遍', ()
   assert.throws(() => transact(scope, { operationId: 'op-1', payloadDigest: 'digest-b' }, note), /不同内容/);
 });
 
-test('D08 别家进程占着锁：报忙，不猜也不抢', () => {
+test('D08 活进程占着锁：报忙，不猜也不抢（死 pid 的残留锁另行回收）', () => {
   const scope = fresh('d08-lock');
   fs.mkdirSync(scope.dir, { recursive: true });
-  fs.writeFileSync(path.join(scope.dir, '.lock'), '999999:deadbeef');
+  fs.writeFileSync(path.join(scope.dir, '.lock'), `${process.pid}:deadbeef`);
   assert.throws(() => transact(scope, {}, addNote('一条', '正文')), (error) => error instanceof StateError && error.code === 'busy');
   assert.equal(fs.existsSync(stateFile(scope)), false);
   fs.rmSync(path.join(scope.dir, '.lock'));
@@ -481,5 +481,124 @@ test('写入重试不堆临时副本：固定临时名写前清理，成功后
   assert.equal(JSON.parse(raw(scope)).payload.generation, next.state.generation);
 });
 
+
+/** 崩溃残留的 .lock：死 pid 能自动回收，活 pid 仍然 busy，迟到的新锁不能被误删。 */
+const lockPath = (scope) => path.join(scope.dir, '.lock');
+const writeLock = (scope, token) => {
+  fs.mkdirSync(scope.dir, { recursive: true });
+  fs.writeFileSync(lockPath(scope), token);
+};
+const deadPid = () => {
+  for (const pid of [999999, 999998, 999997, 888888]) {
+    try {
+      process.kill(pid, 0);
+    } catch (error) {
+      if (error.code === 'ESRCH') return pid;
+    }
+  }
+  return null;
+};
+
+test('崩溃残留的锁（死 pid）自动回收，不再卡 busy', () => {
+  const pid = deadPid();
+  if (pid === null) return;
+  const scope = fresh('stale-lock-dead');
+  writeLock(scope, `${pid}:deadbeef`);
+  const started = Date.now();
+  const result = withScopeLock(scope, () => 'locked');
+  const elapsed = Date.now() - started;
+  assert.equal(result, 'locked');
+  assert.ok(elapsed < 300, `回收要立刻重试，实际等了 ${elapsed}ms`);
+  assert.equal(fs.existsSync(lockPath(scope)), false, '退出时自己的锁要删掉');
+});
+
+test('活 pid 的锁不回收：仍然报 busy，也不删别人的锁', () => {
+  const scope = fresh('stale-lock-live');
+  const token = `${process.pid}:other`;
+  writeLock(scope, token);
+  fs.utimesSync(lockPath(scope), new Date(0), new Date(0));
+  const started = Date.now();
+  assert.throws(() => withScopeLock(scope, () => 'never'), (error) => error.code === 'busy');
+  assert.ok(Date.now() - started >= LIMITS.lockWaitMs - 50, '活锁要等满等待窗口');
+  assert.equal(fs.readFileSync(lockPath(scope), 'utf8'), token, '活进程的锁一个字节都不能动');
+});
+
+test('回收窗口里锁被换成活 token：不删别人的新锁，最终报 busy', () => {
+  const pid = deadPid();
+  if (pid === null) return;
+  const scope = fresh('stale-lock-race');
+  const stale = `${pid}:stale`;
+  const live = `${process.pid}:live`;
+  writeLock(scope, stale);
+  const originalRead = fs.readFileSync;
+  const originalWrite = fs.writeFileSync;
+  let swapped = false;
+  /**
+   * 真正注入竞态：回收函数第一次读到的还是死 pid 的 token，就在它读完之后、
+   * 二次校验之前，另一个进程把锁换成了活 token。回收必须放弃删除。
+   */
+  fs.readFileSync = function (target, ...rest) {
+    const result = originalRead.call(fs, target, ...rest);
+    if (!swapped && String(target) === lockPath(scope)) {
+      swapped = true;
+      originalWrite.call(fs, lockPath(scope), live);
+    }
+    return result;
+  };
+  try {
+    assert.throws(() => withScopeLock(scope, () => 'never'), (error) => error.code === 'busy');
+    assert.equal(swapped, true, '竞态注入没生效，用例等于没测');
+    assert.equal(originalRead.call(fs, lockPath(scope), 'utf8'), live, '换过主人的锁不能被误删');
+  } finally {
+    fs.readFileSync = originalRead;
+    fs.rmSync(lockPath(scope), { force: true });
+  }
+});
+
+test('P0-B 坏 state + 好 prev：从上一版恢复，坏字节留成副本，写入继续', () => {
+  const scope = fresh('p0b-recover');
+  transact(scope, { expectCreate: true }, addNote('第一条', '正文一'));
+  transact(scope, { expected: { generation: 1 } }, addNote('第二条', '正文二'));
+  const broken = '{"format":';
+  fs.writeFileSync(stateFile(scope), broken);
+  const first = load(scope);
+  assert.equal(first.recovered, true);
+  assert.equal(first.state.generation, 1, '采用上一版，不能凭空造新代数');
+  assert.equal(first.state.entries.length, 1);
+  assert.match(first.recovery.message, /已从上一版恢复/);
+  assert.equal(fs.readFileSync(first.recovery.corruptFile, 'utf8'), broken, '原始字节要原样保留');
+  assert.equal(fs.readFileSync(stateFile(scope), 'utf8'), broken, '读路径不许静默覆盖坏文件');
+  assert.equal(fs.readdirSync(scope.dir).filter((name) => name.startsWith('state.corrupt-')).length, 1);
+  load(scope);
+  assert.equal(fs.readdirSync(scope.dir).filter((name) => name.startsWith('state.corrupt-')).length, 1, '同一份坏字节不重复堆副本');
+  const written = transact(scope, { expected: { generation: 1 } }, addNote('第三条', '正文三'));
+  assert.equal(written.changed, true);
+  const after = load(scope);
+  assert.equal(after.recovered, false);
+  assert.equal(after.state.generation, 2);
+  assert.equal(after.state.entries.length, 2);
+  assert.doesNotThrow(() => JSON.parse(fs.readFileSync(path.join(scope.dir, 'state.prev.json'), 'utf8')), 'prev 不能被坏字节污染');
+});
+
+test('P0-B 坏 state 且没有 prev：报错给出损坏副本与可执行的恢复路径', () => {
+  const scope = fresh('p0b-noprev');
+  fs.mkdirSync(scope.dir, { recursive: true });
+  const broken = '{"format":';
+  fs.writeFileSync(stateFile(scope), broken);
+  let error = null;
+  try {
+    load(scope);
+  } catch (caught) {
+    error = caught;
+  }
+  assert.ok(error, '坏 state 不能当空库');
+  assert.equal(error.code, 'corrupt');
+  assert.match(error.message, /state\.prev\.json/, '要给出上一版路径');
+  assert.match(error.message, /恢复步骤/);
+  assert.ok(error.recovery && error.recovery.corruptFile, '要指出损坏副本');
+  assert.equal(fs.readFileSync(error.recovery.corruptFile, 'utf8'), broken);
+  assert.equal(fs.readFileSync(stateFile(scope), 'utf8'), broken);
+});
+
 for (const dir of dirs) fs.rmSync(dir, { recursive: true, force: true });
 console.log(`state.test.mjs: ${passed} passed`);