@modusensus/dsh-mneme 0.12.0 → 0.14.0-beta.1

package/test/dream-baseline-clamp.test.js

@@ -0,0 +1,174 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+
+// 回归（issue #634）：阈值基线只在成功轮前进（dream_runs 落库 + 调度器闭包），而
+// 归档/删除/合并把活跃量压下去——活跃量一旦跌破基线，overBase 恒为假，从此再
+// 也不会巩固，且全程静默（报告实测停摆 13 天 / 22 小时零轮：末轮基线 1,475 条，
+// 归档后活跃 798 条，门槛 ≥1,485 永不满足）。修法是判定口夹回：活跃量跌破基线的
+// 轴取 min，阈值从新的低点重新起算，归掉的量不必重新长回来。本文件锁四个面：
+//   1. 活着的调度器亲历收缩：归档压破基线后，重新增长阈值量仍能触发（停摆反例）；
+//   2. 重启后旧峰值种子在第一次判定被夹回——不落库也能自愈（收缩不触发
+//      notifyWrite，调度器本来就无从在归档当下得知，判定口是唯一可靠的收敛处）；
+//   3. 夹回事件走 auditBaselineClamp 记账：每次收缩周期至多一次、不收缩不记；
+//   4. 两轴独立夹回：只缩字符不缩条数时，条数轴的基线不动。
+
+/** 与阈值判定同口径的活跃库规模（测试侧独立实现，避免与被测代码共用一份过滤条件）。 */
+function activeSize(store) {
+  const rows = store.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document");
+  return {
+    count: rows.length,
+    chars: rows.reduce((sum, m) => sum + m.title.length + m.content.length, 0)
+  };
+}
+
+function seedMemories(service, n, tag = "a") {
+  // 标题必须全局唯一（saveWithDedupe 的去重键是 type+title+scope，同名会合并成
+  // 同一条），「累计到阈值」的断言才会真涨。
+  for (let i = 0; i < n; i++) {
+    service.saveWithDedupe({ type: "history", title: `${tag}-${i}`, content: "x".repeat(300), importance: 3 });
+  }
+}
+
+/** 把「上次成功轮的库规模」落进 dream_runs——调度器重启后读到的就是这份种子。 */
+function persistBaseline(store) {
+  const size = activeSize(store);
+  store.saveDreamRun({
+    status: "ok", snapshot_hash: "h", input_count: 1, receipt: "r",
+    created_at: new Date(Date.now() - 10).toISOString(), run_type: "auto",
+    store_count: size.count, store_chars: size.chars
+  });
+  return size;
+}
+
+function makeOpts(store, overrides = {}) {
+  return {
+    onRun: async () => ({ ok: false }),
+    thresholdCount: 10, thresholdChars: 5000, delayMs: 0,
+    baselineSeed: store.lastDreamBaseline("auto"),
+    logger: { warn: () => {} },
+    ...overrides
+  };
+}
+
+/** 把活跃行里除 excludeTag 外的前 n 条归档（归档不触发 notifyWrite，这正是 #634 的一部分）。 */
+function archiveRows(service, store, n, excludeTag = null) {
+  const rows = store.all().filter((m) => !m.archived && (excludeTag === null || !m.title.startsWith(excludeTag)));
+  for (const m of rows.slice(0, n)) service.setArchived(m.id, true);
+}
+
+test("issue#634: a live scheduler survives an archive below the baseline (the freeze, unlocked)", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  seedMemories(service, 12);
+  const baseline = persistBaseline(store);
+  const dream = createDreamScheduler(makeOpts(store));
+  assert.equal(dream.maybeSchedule(service), false, "no growth since the last run → no trigger");
+  // 收缩发生在两次写入之间：归档 10 条，活跃 2 条 < 基线 12 条。
+  archiveRows(service, store, 10);
+  assert.ok(activeSize(store).count < baseline.count, "precondition: archive pulled active below the baseline");
+  // 收缩后的第一次写入把基线夹回当前水平（2+1=3），此后按新的低点起算。
+  seedMemories(service, 1, "g");
+  assert.equal(dream.maybeSchedule(service), false, "the first post-shrink write clamps instead of triggering");
+  seedMemories(service, 9, "p");
+  assert.equal(dream.maybeSchedule(service), false, "+9 from the clamped level is still below the threshold");
+  seedMemories(service, 1, "q"); // 夹回后的第 +10 条
+  assert.equal(dream.maybeSchedule(service), true, "+10 past the clamp fires — pre-fix this stayed silent forever");
+  await dream.dispose();
+  store.close();
+});
+
+test("issue#634: a stale peak seed from dream_runs is clamped on the first judgement after restart", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  seedMemories(service, 12);
+  persistBaseline(store);
+  // 收缩发生在上一进程末轮之后、重启之前（归档不 notifyWrite，调度器无从得知）：
+  // dream_runs 里的种子还是那个峰值。
+  archiveRows(service, store, 10);
+  const dream = createDreamScheduler(makeOpts(store));
+  // 重启后第一条写入：先把旧峰值种子夹回当前水平，再谈阈值。
+  seedMemories(service, 1, "r");
+  assert.equal(dream.maybeSchedule(service), false, "the restart write clamps the stale seed instead of bypassing");
+  seedMemories(service, 9, "s");
+  assert.equal(dream.maybeSchedule(service), false, "+9 from the clamped level is still below the threshold");
+  seedMemories(service, 1, "t");
+  assert.equal(dream.maybeSchedule(service), true, "the clamp makes the threshold reachable again without re-growing archived rows");
+  await dream.dispose();
+  store.close();
+});
+
+test("issue#634: the clamp is audited exactly once per shrink episode, and never without one", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const clamps = [];
+  seedMemories(service, 12);
+  const baseline = persistBaseline(store);
+  const dream = createDreamScheduler(makeOpts(store, {
+    auditBaselineClamp: ({ previous, count, chars }) => clamps.push({ previous, count, chars })
+  }));
+  // 不收缩的写入：正常增长（13 > 12），既不夹回也不记账。
+  seedMemories(service, 1, "n");
+  assert.equal(dream.maybeSchedule(service), false);
+  assert.equal(clamps.length, 0, "no clamp audit without a shrink");
+  // 归档压破基线（12→2），收缩后第一次判定夹回并记一次账。
+  archiveRows(service, store, 10, "n-");
+  seedMemories(service, 1, "p");
+  assert.equal(dream.maybeSchedule(service), false);
+  assert.equal(clamps.length, 1, "the shrink episode produces exactly one clamp audit");
+  assert.deepEqual(clamps[0].previous, baseline, "previous = the stale peak baseline");
+  assert.equal(clamps[0].count, activeSize(store).count, "count/chars = the clamped (current active) level");
+  assert.equal(clamps[0].chars, activeSize(store).chars, "chars axis is clamped to the same level");
+  // 同一收缩周期内活跃只增不减：不再重复记账（夹回后基线 == 活跃量）。
+  seedMemories(service, 5, "u");
+  assert.equal(dream.maybeSchedule(service), false, "still below the threshold from the clamped level");
+  assert.equal(clamps.length, 1, "no repeated clamp audits while active only grows");
+  await dream.dispose();
+  store.close();
+});
+
+test("issue#634: the clamp is per-axis — a chars-only shrink leaves the count baseline alone", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  seedMemories(service, 12);
+  const baseline = persistBaseline(store);
+  const clamps = [];
+  const dream = createDreamScheduler(makeOpts(store, {
+    auditBaselineClamp: (event) => clamps.push(event)
+  }));
+  // 更新类写入（同 type+title+scope 命中去重键）把一条换成短内容：条数不动、字符缩。
+  // 去重命中默认 appendContent（追加），只有显式 _overwrite 才替换——不加的话
+  // 字符数反而变多，这条用例的前置就不成立了。
+  service.saveWithDedupe({ type: "history", title: "a-0", content: "短", _overwrite: true, importance: 3 });
+  assert.equal(activeSize(store).count, baseline.count, "precondition: the count axis did not move");
+  assert.ok(activeSize(store).chars < baseline.chars, "precondition: the chars axis shrank");
+  assert.equal(dream.maybeSchedule(service), false, "the threshold itself is not met yet");
+  assert.equal(clamps.length, 1, "a chars-only shrink still clamps");
+  assert.equal(clamps[0].previous.count, baseline.count, "the count baseline was intact before the clamp");
+  assert.equal(clamps[0].count, baseline.count, "the count baseline survives — only the shrunken axis moves");
+  assert.ok(clamps[0].chars < clamps[0].previous.chars, "the chars baseline is clamped down");
+  await dream.dispose();
+  store.close();
+});
+
+// --- CodeRabbit 在 #291 上的同类要求（源码级锁）：index.js 的接线是单行注入，仓库
+// 没有插件级挂载 harness（apply 需要完整宿主 ctx），删掉该注入行不会让任何单测变
+// 红——所以用正则锁注入本身。import 用 URL 相对本文件解析，不依赖测试进程 CWD。
+const indexSrc = readFileSync(fileURLToPath(new URL("../src/index.js", import.meta.url)), "utf8");
+
+test("issue#634: index.js wires the baseline-clamp audit into llm_audit_logs", () => {
+  assert.match(
+    indexSrc,
+    /auditBaselineClamp:/,
+    "the clamp callback must be wired at assembly — otherwise clamp events stay unobservable (the #634 silence)"
+  );
+  assert.match(
+    indexSrc,
+    /error_message:\s*"baseline-clamp"/,
+    "the audit row must carry the baseline-clamp marker so it can be told apart from peak-hours skips"
+  );
+});

package/test/dream-maxtokens-fallback.test.js

@@ -113,7 +113,7 @@ test("withMaxTokensFallback: 无关报错不触发重试（stream 与 throw 双
 // 接线锁：单测绿不代表真接上了。#478 的第一次实现只挂了 dream 侧三个点，
 // sleep.js 两处仍原样发 config.sleepMaxTokens，而面板 hint 已对外承诺
 // 「超上限同样自动降级」——这种「函数有、没人用」的缺口只靠行为测试抓不到。
-test("接线锁：dreamMaxTokens/sleepMaxTokens 的五个使用点全部包在 withMaxTokensFallback 里", async () => {
+test("接线锁：dreamMaxTokens/sleepMaxTokens 的六个使用点全部包在 withMaxTokensFallback 里", async () => {
   const { readFile } = await import("node:fs/promises");
   const srcDir = new URL("../src/", import.meta.url);
   const files = { "dream.js": await readFile(new URL("dream.js", srcDir), "utf8"), "dream/sleep.js": await readFile(new URL("dream/sleep.js", srcDir), "utf8") };
@@ -124,9 +124,9 @@ test("接线锁：dreamMaxTokens/sleepMaxTokens 的五个使用点全部包在 w
       `${name}: still passes config.*MaxTokens straight into maxTokens — wrap it in withMaxTokensFallback`
     );
   }
-  // 五个调用点：dream 三条（叙述/巩固/摘要）+ sleep 两条（冲突/模式）。
+  // 调用点：dream 三条（叙述/巩固/摘要）+ sleep 三条（冲突/模式/情感归因，#619 新增）。
   const dreamHits = files["dream.js"].match(/withMaxTokensFallback\(ctx, config\.dreamMaxTokens/g) ?? [];
   const sleepHits = files["dream/sleep.js"].match(/withMaxTokensFallback\(ctx, config\.sleepMaxTokens/g) ?? [];
   assert.equal(dreamHits.length, 3, `dream.js must wrap all 3 dreamMaxTokens sites (got ${dreamHits.length})`);
-  assert.equal(sleepHits.length, 2, `dream/sleep.js must wrap both sleepMaxTokens sites (got ${sleepHits.length})`);
+  assert.equal(sleepHits.length, 3, `dream/sleep.js must wrap all 3 sleepMaxTokens sites (got ${sleepHits.length})`);
 });

package/test/dream.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { validateDecisions, applyDecisions, createDreamScheduler } from "../src/dream.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
-import { mockCtx } from "./helpers/dream-mock.js";
+import { mockCtx, sessionDecisions } from "./helpers/dream-mock.js";
 
 function snapshot(ids, type = "project") {
   return new Map(ids.map((id, i) => [id, { id, type, title: `t${i}`, content: `c${i}`, importance: 3, archived: false, forgotten: false }]));
@@ -905,6 +905,67 @@ test("runDream sliding window keeps the newest N memories and excludes the oldes
   store.close();
 });
 
+// --- issue #557：dream 审计行输入快照瘦身（dreamInputSummaryEnabled）-----------
+//
+// dream_runs.input 单行体积随记忆量涨（#557 实测平均 40-79 KB/轮，大头是
+// content），轮数又随天数涨，超线性。本组用例锁三件事：
+//   ① 默认关 = 审计行逐字节一致（content 原样落库）；
+//   ② 开启后 auto 轮只落骨架（id/type/title/importance/updated_at），且
+//      input_count / snapshot_hash / receipt / decisions 都不变——瘦身的只是
+//      落库副本，LLM 输入与 receipt 完整性不受影响；
+//   ③ organize 轮的重放载荷不经过 dream.js 的快照构造（结构性分叉），这里锁
+//      auto 路径的形状，organize 侧由 organize.test.js 的 apply 重放用例兜住。
+
+test("issue#557: 默认关 = 审计行快照带 content（行为与改动前一致）", async () => {
+  const { store, service } = dreamSetup();
+  const content = "很长的正文，瘦身前应原样落库。".repeat(20);
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "project", title: `主题${i}`, content, importance: 3 });
+  }
+  const ctx = mockCtx({ onConsolidation: sessionDecisions });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat"
+  });
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.input_count, 3);
+  assert.deepEqual(
+    Object.keys(run.input[0]).sort(),
+    ["content", "id", "importance", "title", "type", "updated_at"],
+    "默认快照含 content"
+  );
+  assert.equal(run.input[0].content, content, "content 原样落库");
+  store.close();
+});
+
+test("issue#557: dreamInputSummaryEnabled 开启后快照只留骨架，判定与回执不变", async () => {
+  const { store, service } = dreamSetup();
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "project", title: `主题${i}`, content: `很长的正文${i}`.repeat(20), importance: 3 });
+  }
+  const ctx = mockCtx({ onConsolidation: sessionDecisions });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat",
+    dreamInputSummaryEnabled: true
+  });
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.input_count, 3, "input_count 语义不变");
+  for (const m of run.input) {
+    assert.deepEqual(
+      Object.keys(m).sort(),
+      ["id", "importance", "title", "type", "updated_at"],
+      "瘦身快照不含 content"
+    );
+  }
+  assert.deepEqual(run.input.map((m) => m.title).sort(), ["主题0", "主题1", "主题2"], "骨架字段带出标题");
+  assert.ok(run.snapshot_hash && run.snapshot_hash.length === 64, "snapshot_hash 形状不变（内存里对含 content 快照计算）");
+  assert.match(run.receipt, /^dsh-mneme:run:/, "receipt 形状不变");
+  assert.ok(Array.isArray(run.decisions) && run.decisions.length > 0, "决策不受影响");
+  assert.ok(JSON.stringify(run.input).length < 2048, "骨架行确实小（content 不在）");
+  store.close();
+});
+
 // --- v0.4.4 fix: 决策 JSON schema 固化（kimi 等模型输出合规） -----------------
 
 test("consolidation prompt pins the decision schema (action field, single-string winner/loser, single claim per id)", async () => {

package/test/dsh-go-host.test.js

@@ -0,0 +1,134 @@
+// src/dsh-go/host.js —— 进程内派发的判据。
+//
+// 这个文件锁的是「面板能不能拿到宿主真的答复」，而不是某一屏长什么样：
+//   - 请求体必须在 handler 挂好监听之后再 flush，否则 readBody 永远等不到 end；
+//   - handler 返回 undefined 但稍后才 res.end（/version-check 就是这样）时，
+//     调用方必须等到响应真的结束，不能拿着空 body 当成结果；
+//   - 配了 apiToken 之后写路由要带令牌，否则被自家路由注册器拦成 401；
+//   - 超时、未注册路径都要抛错，而不是返回一个空对象让面板显示成「0 条」。
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createHostCall } from "../src/dsh-go/host.js";
+
+function fakeServer(routes) {
+  return {
+    match(pathname) {
+      const handler = routes[pathname];
+      return handler === undefined ? undefined : { kind: "exact", path: pathname, handler };
+    },
+  };
+}
+
+function readAll(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += String(chunk);
+    });
+    req.on("end", () => resolve(data));
+  });
+}
+
+const ctxWith = (routes) => ({ get: (name) => (name === "webServer" ? fakeServer(routes) : undefined) });
+
+test("进程内调用能读到请求体，并且同步响应即可返回", async () => {
+  let seen = null;
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/echo": (req, res) => {
+        seen = { method: req.method, url: req.url };
+        void readAll(req).then((body) => {
+          seen.body = body;
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ ok: true, body: JSON.parse(body) }));
+        });
+      },
+    }),
+  );
+  const result = await call("/echo", { method: "POST", body: { title: "x" } });
+  assert.deepEqual(result, { ok: true, body: { title: "x" } });
+  assert.equal(seen.method, "POST");
+  assert.equal(seen.body, JSON.stringify({ title: "x" }));
+});
+
+test("handler 同步返回 undefined、稍后 res.end 时仍然等到响应结束", async () => {
+  // /version-check 的真实形状：handler 立即 return，答复在 promise 回调里写完。
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/version-check": (req, res) => {
+        setTimeout(() => {
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ version: "0.10.1", status: "latest" }));
+        }, 5);
+        return undefined;
+      },
+    }),
+  );
+  const result = await call("/version-check");
+  assert.equal(result.version, "0.10.1");
+  assert.equal(result.status, "latest");
+});
+
+test("配了 apiToken 就把令牌放进 x-dsh-mneme-token 头", async () => {
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/update": (req, res) => {
+        const token = req.headers["x-dsh-mneme-token"] ?? "";
+        res.writeHead(token === "secret-token" ? 200 : 401);
+        res.end(JSON.stringify(token === "secret-token" ? { ok: true } : { error: "unauthorized" }));
+      },
+    }),
+    { apiToken: "secret-token" },
+  );
+  assert.deepEqual(await call("/update", { method: "POST", body: { id: "m1" } }), { ok: true });
+});
+
+test("没有令牌时写路由的 401 会变成异常，而不是空结果", async () => {
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/update": (req, res) => {
+        res.writeHead(401);
+        res.end(JSON.stringify({ error: "unauthorized" }));
+      },
+    }),
+  );
+  await assert.rejects(call("/update", { method: "POST", body: { id: "m1" } }), /401/);
+});
+
+test("未注册的路径直接报错，不会静默返回空对象", async () => {
+  const call = createHostCall(ctxWith({}));
+  await assert.rejects(call("/list"), /mneme 未注册/);
+});
+
+test("宿主没有 webServer 时报错", async () => {
+  const call = createHostCall({ get: () => undefined });
+  await assert.rejects(call("/list"), /webServer 不可用/);
+});
+
+test("超时抛错（避免面板永远等着）", async () => {
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/slow": () => {
+        // 永不响应
+      },
+    }),
+  );
+  await assert.rejects(call("/slow", { timeoutMs: 30 }), /超时/);
+});
+
+test("空响应体归一成 {}，非 JSON 归一成 { text }", async () => {
+  const call = createHostCall(
+    ctxWith({
+      "/api/dsh-mneme/empty": (req, res) => {
+        res.writeHead(200);
+        res.end("");
+      },
+      "/api/dsh-mneme/plain": (req, res) => {
+        res.writeHead(200);
+        res.end("hello");
+      },
+    }),
+  );
+  assert.deepEqual(await call("/empty"), {});
+  assert.deepEqual(await call("/plain"), { text: "hello" });
+});