@modusensus/dsh-mneme 0.13.0 → 0.14.0-beta.2

package/test/heat.test.js

@@ -1,175 +1,175 @@
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-
-import {
-  computeHeat,
-  buildHeatSignals,
-  TYPE_DECAY_DEFAULTS,
-} from '../src/heat.js';
-
-const HOUR = 3600000;
-
-describe('heat.js', () => {
-  test('未知类型使用默认 λ=0.002；72h 后 heat < 1 且 > 0.8，并随 Δt 单调递减', () => {
-    const now = Date.now();
-    const base = { type: 'episodic', last_accessed_at: now - 72 * HOUR };
-
-    const heat72 = computeHeat(base, now, {});
-    const heat144 = computeHeat(
-      { ...base, last_accessed_at: now - 144 * HOUR },
-      now,
-      {}
-    );
-
-    assert(heat72 < 1.0, '72h 后热度应小于 1');
-    assert(heat72 > 0.8, '72h 后热度应仍大于 0.8');
-    assert(heat144 < heat72, 'Δt 越大，热度应越低');
-  });
-
-  test('λ=0 的免疫类型任意 Δt 返回 1.0', () => {
-    const now = Date.now();
-    const config = { heatTypeDecay: { preference: 0 } };
-
-    assert.strictEqual(
-      computeHeat(
-        { type: 'preference', last_accessed_at: now - 999 * 24 * HOUR },
-        now,
-        config
-      ),
-      1.0
-    );
-
-    assert.strictEqual(
-      computeHeat(
-        { type: 'pattern', last_accessed_at: now - 365 * 24 * HOUR },
-        now,
-        { heatTypeDecay: TYPE_DECAY_DEFAULTS }
-      ),
-      1.0
-    );
-  });
-
-  test('ref 优先使用 last_accessed_at，缺失退 created_at，皆无返回 1.0', () => {
-    const now = Date.now();
-    const config = {
-      heatTypeDecay: { decision: 0.002 },
-      heatGlobalBeta: 1.0,
-    };
-
-    const withLast = computeHeat(
-      {
-        type: 'decision',
-        last_accessed_at: now - 24 * HOUR,
-        created_at: now - 100 * HOUR,
-      },
-      now,
-      config
-    );
-
-    const withCreated = computeHeat(
-      { type: 'decision', created_at: now - 24 * HOUR },
-      now,
-      config
-    );
-
-    assert(withLast < 1.0);
-    assert.strictEqual(withLast, withCreated);
-
-    const noRef = computeHeat({ type: 'decision' }, now, config);
-    assert.strictEqual(noRef, 1.0);
-  });
-
-  test('非法 ref 或 now < ref 时返回 1.0', () => {
-    const now = Date.now();
-
-    assert.strictEqual(
-      computeHeat(
-        { type: 'decision', last_accessed_at: 'not-a-date' },
-        now,
-        {}
-      ),
-      1.0
-    );
-
-    assert.strictEqual(
-      computeHeat(
-        { type: 'decision', last_accessed_at: now + 1000 },
-        now,
-        {}
-      ),
-      1.0
-    );
-  });
-
-  test('β 越大衰减越快（同一 Δt 下 β=2 的热度低于 β=1）', () => {
-    const now = Date.now();
-    const base = {
-      type: 'decision',
-      last_accessed_at: now - 7 * 24 * HOUR,
-    };
-
-    const h1 = computeHeat(base, now, {
-      heatTypeDecay: { decision: 0.002 },
-      heatGlobalBeta: 1.0,
-    });
-
-    const h2 = computeHeat(base, now, {
-      heatTypeDecay: { decision: 0.002 },
-      heatGlobalBeta: 2.0,
-    });
-
-    assert(h2 < h1, 'β 更大时，同一 Δt 热度应更低');
-  });
-
-  test('β=1 退化为纯指数：H=exp(-λΔt)（精确值锚定）', () => {
-    const now = Date.now();
-    const heat = computeHeat(
-      { type: 'decision', last_accessed_at: now - 100 * HOUR },
-      now,
-      { heatTypeDecay: { decision: 0.002 }, heatGlobalBeta: 1.0 }
-    );
-    assert.ok(Math.abs(heat - Math.exp(-0.2)) < 1e-12, 'λ=0.002、Δt=100h、β=1 → exp(-0.2)');
-  });
-
-  test('β 管形状：同 Δt（>1h）下 β=0.5 的亚线性长尾热度高于 β=2', () => {
-    const now = Date.now();
-    const base = { type: 'decision', last_accessed_at: now - 24 * HOUR };
-    const slow = computeHeat(base, now, { heatTypeDecay: { decision: 0.002 }, heatGlobalBeta: 0.5 });
-    const fast = computeHeat(base, now, { heatTypeDecay: { decision: 0.002 }, heatGlobalBeta: 2.0 });
-    assert.ok(slow > fast, 'β 越小长尾越厚');
-  });
-
-  test('touch 回温：last_accessed_at 刷新后热度回到满格', () => {
-    const now = Date.now();
-    const config = { heatTypeDecay: { decision: 0.002 } };
-    const cold = computeHeat({ type: 'decision', last_accessed_at: now - 500 * HOUR }, now, config);
-    const rewarmed = computeHeat({ type: 'decision', last_accessed_at: now - 1 }, now, config);
-    assert.ok(cold < 0.5, '500h 未访问已显著降温');
-    assert.ok(rewarmed > 0.999, '刚触达即回满');
-  });
-
-  test('buildHeatSignals 返回字段齐全且 deltaHours 正确', () => {
-    const now = 1000000000000; // 固定毫秒时间戳
-    const ref = now - 12 * HOUR;
-
-    const signals = buildHeatSignals(
-      { type: 'project', last_accessed_at: ref },
-      { heatGlobalBeta: 1.5 },
-      now
-    );
-
-    assert.deepStrictEqual(Object.keys(signals).sort(), [
-      'beta',
-      'deltaHours',
-      'lambda',
-      'ref',
-      'type',
-    ]);
-
-    assert.strictEqual(signals.type, 'project');
-    assert.strictEqual(signals.lambda, 0.0008);
-    assert.strictEqual(signals.beta, 1.5);
-    assert.strictEqual(signals.ref, ref);
-    assert.strictEqual(signals.deltaHours, 12);
-  });
-});
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  computeHeat,
+  buildHeatSignals,
+  TYPE_DECAY_DEFAULTS,
+} from '../src/heat.js';
+
+const HOUR = 3600000;
+
+describe('heat.js', () => {
+  test('未知类型使用默认 λ=0.002；72h 后 heat < 1 且 > 0.8，并随 Δt 单调递减', () => {
+    const now = Date.now();
+    const base = { type: 'episodic', last_accessed_at: now - 72 * HOUR };
+
+    const heat72 = computeHeat(base, now, {});
+    const heat144 = computeHeat(
+      { ...base, last_accessed_at: now - 144 * HOUR },
+      now,
+      {}
+    );
+
+    assert(heat72 < 1.0, '72h 后热度应小于 1');
+    assert(heat72 > 0.8, '72h 后热度应仍大于 0.8');
+    assert(heat144 < heat72, 'Δt 越大，热度应越低');
+  });
+
+  test('λ=0 的免疫类型任意 Δt 返回 1.0', () => {
+    const now = Date.now();
+    const config = { heatTypeDecay: { preference: 0 } };
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'preference', last_accessed_at: now - 999 * 24 * HOUR },
+        now,
+        config
+      ),
+      1.0
+    );
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'pattern', last_accessed_at: now - 365 * 24 * HOUR },
+        now,
+        { heatTypeDecay: TYPE_DECAY_DEFAULTS }
+      ),
+      1.0
+    );
+  });
+
+  test('ref 优先使用 last_accessed_at，缺失退 created_at，皆无返回 1.0', () => {
+    const now = Date.now();
+    const config = {
+      heatTypeDecay: { decision: 0.002 },
+      heatGlobalBeta: 1.0,
+    };
+
+    const withLast = computeHeat(
+      {
+        type: 'decision',
+        last_accessed_at: now - 24 * HOUR,
+        created_at: now - 100 * HOUR,
+      },
+      now,
+      config
+    );
+
+    const withCreated = computeHeat(
+      { type: 'decision', created_at: now - 24 * HOUR },
+      now,
+      config
+    );
+
+    assert(withLast < 1.0);
+    assert.strictEqual(withLast, withCreated);
+
+    const noRef = computeHeat({ type: 'decision' }, now, config);
+    assert.strictEqual(noRef, 1.0);
+  });
+
+  test('非法 ref 或 now < ref 时返回 1.0', () => {
+    const now = Date.now();
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'decision', last_accessed_at: 'not-a-date' },
+        now,
+        {}
+      ),
+      1.0
+    );
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'decision', last_accessed_at: now + 1000 },
+        now,
+        {}
+      ),
+      1.0
+    );
+  });
+
+  test('β 越大衰减越快（同一 Δt 下 β=2 的热度低于 β=1）', () => {
+    const now = Date.now();
+    const base = {
+      type: 'decision',
+      last_accessed_at: now - 7 * 24 * HOUR,
+    };
+
+    const h1 = computeHeat(base, now, {
+      heatTypeDecay: { decision: 0.002 },
+      heatGlobalBeta: 1.0,
+    });
+
+    const h2 = computeHeat(base, now, {
+      heatTypeDecay: { decision: 0.002 },
+      heatGlobalBeta: 2.0,
+    });
+
+    assert(h2 < h1, 'β 更大时，同一 Δt 热度应更低');
+  });
+
+  test('β=1 退化为纯指数：H=exp(-λΔt)（精确值锚定）', () => {
+    const now = Date.now();
+    const heat = computeHeat(
+      { type: 'decision', last_accessed_at: now - 100 * HOUR },
+      now,
+      { heatTypeDecay: { decision: 0.002 }, heatGlobalBeta: 1.0 }
+    );
+    assert.ok(Math.abs(heat - Math.exp(-0.2)) < 1e-12, 'λ=0.002、Δt=100h、β=1 → exp(-0.2)');
+  });
+
+  test('β 管形状：同 Δt（>1h）下 β=0.5 的亚线性长尾热度高于 β=2', () => {
+    const now = Date.now();
+    const base = { type: 'decision', last_accessed_at: now - 24 * HOUR };
+    const slow = computeHeat(base, now, { heatTypeDecay: { decision: 0.002 }, heatGlobalBeta: 0.5 });
+    const fast = computeHeat(base, now, { heatTypeDecay: { decision: 0.002 }, heatGlobalBeta: 2.0 });
+    assert.ok(slow > fast, 'β 越小长尾越厚');
+  });
+
+  test('touch 回温：last_accessed_at 刷新后热度回到满格', () => {
+    const now = Date.now();
+    const config = { heatTypeDecay: { decision: 0.002 } };
+    const cold = computeHeat({ type: 'decision', last_accessed_at: now - 500 * HOUR }, now, config);
+    const rewarmed = computeHeat({ type: 'decision', last_accessed_at: now - 1 }, now, config);
+    assert.ok(cold < 0.5, '500h 未访问已显著降温');
+    assert.ok(rewarmed > 0.999, '刚触达即回满');
+  });
+
+  test('buildHeatSignals 返回字段齐全且 deltaHours 正确', () => {
+    const now = 1000000000000; // 固定毫秒时间戳
+    const ref = now - 12 * HOUR;
+
+    const signals = buildHeatSignals(
+      { type: 'project', last_accessed_at: ref },
+      { heatGlobalBeta: 1.5 },
+      now
+    );
+
+    assert.deepStrictEqual(Object.keys(signals).sort(), [
+      'beta',
+      'deltaHours',
+      'lambda',
+      'ref',
+      'type',
+    ]);
+
+    assert.strictEqual(signals.type, 'project');
+    assert.strictEqual(signals.lambda, 0.0008);
+    assert.strictEqual(signals.beta, 1.5);
+    assert.strictEqual(signals.ref, ref);
+    assert.strictEqual(signals.deltaHours, 12);
+  });
+});

package/test/helpers/dream-mock.js

@@ -1,86 +1,86 @@
-// test/helpers/dream-mock.js
-// 共享的确定性 LLM 测试桩：consolidation 决策生成器 + 最小 DSH ctx。
-// 被 scripts/stress-dsh.js 与 test/stress.test.js 共用，保证压测与单测
-// 走同一套"LLM 行为"，避免两边决策逻辑漂移。
-
-export function parseEntries(listText) {
-  return [...listText.matchAll(
-    /id=([^\s|]+)\s*\|\s*type=(\w+)\s*\|\s*importance=(\d+)\s*\|\s*updated=([^\s|]+)\s*\|\s*title=([^|]*)/g
-  )].map((m) => ({ id: m[1], type: m[2], importance: Number(m[3]), updated: m[4], title: m[5].trim() }));
-}
-
-/**
- * 长会话检索的确定性决策：title 含「变体」→ archive，其余 keep。
- */
-export function sessionDecisions(listText) {
-  const entries = parseEntries(listText);
-  const decisions = [];
-  const claimed = new Set();
-  for (const e of entries) {
-    if (e.title.includes("变体")) {
-      decisions.push({ action: "archive", ids: [e.id], reason: "stale variant" });
-      claimed.add(e.id);
-    }
-  }
-  for (const e of entries) {
-    if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
-  }
-  return JSON.stringify(decisions);
-}
-
-/**
- * 冲突裁决的确定性决策：title 以「(旧)」结尾 → conflict（胜者为同主题
- * 不带「(旧)」者），无对手 → keep。同一快照必然产出同一决策。
- */
-export function arbitrationDecisions(listText) {
-  const entries = parseEntries(listText);
-  const byKey = new Map();
-  for (const e of entries) {
-    const key = e.title.replace(/\(旧\)$/, "").trim();
-    if (!byKey.has(key)) byKey.set(key, []);
-    byKey.get(key).push(e);
-  }
-  const decisions = [];
-  const claimed = new Set();
-  for (const group of byKey.values()) {
-    const loser = group.find((e) => e.title.includes("(旧)"));
-    const winner = group.find((e) => !e.title.includes("(旧)"));
-    if (winner && loser) {
-      decisions.push({ action: "conflict", winner: winner.id, loser: loser.id, reason: "新信息覆盖旧信息" });
-      claimed.add(winner.id);
-      claimed.add(loser.id);
-      continue;
-    }
-    for (const e of group) {
-      if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
-      claimed.add(e.id);
-    }
-  }
-  return JSON.stringify(decisions);
-}
-
-/**
- * 最小 DSH ctx：consolidation 用 onConsolidation(listText) 产出决策，
- * summary 返回固定文本。
- */
-export function mockCtx({ onConsolidation, summaryText = "记忆库总览：用户偏好中文；关键决策已巩固。" } = {}) {
-  return {
-    logger: { warn: () => {} },
-    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "stress-model" }) },
-    llm: {
-      async *stream(options) {
-        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        // 认「这是巩固那一次调用」的判据：以前看 userText 是否以 `id=` 开头，但
-        // #493 追加的围栏让 user 段以角色声明开头了。改判清单**形状**而不是首行——
-        // `| type=` 只有巩固清单有（叙述条的 listing 形如 `- id=… | title=…`，没有
-        // type=），所以两条调用路径不会串台。
-        if (userText.includes("| type=")) {
-          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText, options.purpose) : "[]" };
-        } else {
-          yield { type: "text-delta", index: 0, text: summaryText };
-        }
-        yield { type: "finish", reason: { kind: "stop" } };
-      }
-    }
-  };
-}
+// test/helpers/dream-mock.js
+// 共享的确定性 LLM 测试桩：consolidation 决策生成器 + 最小 DSH ctx。
+// 被 scripts/stress-dsh.js 与 test/stress.test.js 共用，保证压测与单测
+// 走同一套"LLM 行为"，避免两边决策逻辑漂移。
+
+export function parseEntries(listText) {
+  return [...listText.matchAll(
+    /id=([^\s|]+)\s*\|\s*type=(\w+)\s*\|\s*importance=(\d+)\s*\|\s*updated=([^\s|]+)\s*\|\s*title=([^|]*)/g
+  )].map((m) => ({ id: m[1], type: m[2], importance: Number(m[3]), updated: m[4], title: m[5].trim() }));
+}
+
+/**
+ * 长会话检索的确定性决策：title 含「变体」→ archive，其余 keep。
+ */
+export function sessionDecisions(listText) {
+  const entries = parseEntries(listText);
+  const decisions = [];
+  const claimed = new Set();
+  for (const e of entries) {
+    if (e.title.includes("变体")) {
+      decisions.push({ action: "archive", ids: [e.id], reason: "stale variant" });
+      claimed.add(e.id);
+    }
+  }
+  for (const e of entries) {
+    if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
+  }
+  return JSON.stringify(decisions);
+}
+
+/**
+ * 冲突裁决的确定性决策：title 以「(旧)」结尾 → conflict（胜者为同主题
+ * 不带「(旧)」者），无对手 → keep。同一快照必然产出同一决策。
+ */
+export function arbitrationDecisions(listText) {
+  const entries = parseEntries(listText);
+  const byKey = new Map();
+  for (const e of entries) {
+    const key = e.title.replace(/\(旧\)$/, "").trim();
+    if (!byKey.has(key)) byKey.set(key, []);
+    byKey.get(key).push(e);
+  }
+  const decisions = [];
+  const claimed = new Set();
+  for (const group of byKey.values()) {
+    const loser = group.find((e) => e.title.includes("(旧)"));
+    const winner = group.find((e) => !e.title.includes("(旧)"));
+    if (winner && loser) {
+      decisions.push({ action: "conflict", winner: winner.id, loser: loser.id, reason: "新信息覆盖旧信息" });
+      claimed.add(winner.id);
+      claimed.add(loser.id);
+      continue;
+    }
+    for (const e of group) {
+      if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
+      claimed.add(e.id);
+    }
+  }
+  return JSON.stringify(decisions);
+}
+
+/**
+ * 最小 DSH ctx：consolidation 用 onConsolidation(listText) 产出决策，
+ * summary 返回固定文本。
+ */
+export function mockCtx({ onConsolidation, summaryText = "记忆库总览：用户偏好中文；关键决策已巩固。" } = {}) {
+  return {
+    logger: { warn: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "stress-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        // 认「这是巩固那一次调用」的判据：以前看 userText 是否以 `id=` 开头，但
+        // #493 追加的围栏让 user 段以角色声明开头了。改判清单**形状**而不是首行——
+        // `| type=` 只有巩固清单有（叙述条的 listing 形如 `- id=… | title=…`，没有
+        // type=），所以两条调用路径不会串台。
+        if (userText.includes("| type=")) {
+          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText, options.purpose) : "[]" };
+        } else {
+          yield { type: "text-delta", index: 0, text: summaryText };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}

package/test/helpers/peer-worker.mjs

@@ -1,25 +1,25 @@
-// Multi-process concurrency worker for test/peer-blockers.test.js:
-// opens the SQLite store passed via argv and increments the mirror
-// generation N times, so several real OS processes contend on one DB file.
-// Usage: node test/helpers/peer-worker.mjs <dbPath> <iterations>
-import { createStore } from "../../src/store.js";
-
-const [, , dbPath, iterations] = process.argv;
-
-// Windows CI 上 8 进程并发写同一 generation 行时，busy_timeout(5s) 到期仍偶发
-// SQLITE_BUSY（"database is locked"）。锁是瞬时资源竞争，线性重试即可收敛；
-// incrementGeneration 是单条原子 UPDATE（失败即未执行），重试不会重复计数。
-async function withBusyRetry(fn) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return fn();
-    } catch (err) {
-      if (!/database is locked|SQLITE_BUSY/i.test(String(err?.message ?? err)) || attempt >= 40) throw err;
-      await new Promise((r) => setTimeout(r, 250));
-    }
-  }
-}
-
-const store = await withBusyRetry(() => createStore(dbPath));
-for (let i = 0; i < Number(iterations); i++) await withBusyRetry(() => store.incrementGeneration());
-store.close();
+// Multi-process concurrency worker for test/peer-blockers.test.js:
+// opens the SQLite store passed via argv and increments the mirror
+// generation N times, so several real OS processes contend on one DB file.
+// Usage: node test/helpers/peer-worker.mjs <dbPath> <iterations>
+import { createStore } from "../../src/store.js";
+
+const [, , dbPath, iterations] = process.argv;
+
+// Windows CI 上 8 进程并发写同一 generation 行时，busy_timeout(5s) 到期仍偶发
+// SQLITE_BUSY（"database is locked"）。锁是瞬时资源竞争，线性重试即可收敛；
+// incrementGeneration 是单条原子 UPDATE（失败即未执行），重试不会重复计数。
+async function withBusyRetry(fn) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return fn();
+    } catch (err) {
+      if (!/database is locked|SQLITE_BUSY/i.test(String(err?.message ?? err)) || attempt >= 40) throw err;
+      await new Promise((r) => setTimeout(r, 250));
+    }
+  }
+}
+
+const store = await withBusyRetry(() => createStore(dbPath));
+for (let i = 0; i < Number(iterations); i++) await withBusyRetry(() => store.incrementGeneration());
+store.close();