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

package/test/dream-archive-guardrail.test.js

@@ -1,116 +1,116 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createDreamScheduler, validateDecisions } from "../src/dream.js";
-import { mockCtx } from "./helpers/dream-mock.js";
-
-// 回归（issue #104 方向 2）：archive 决策语义越界 + 批量大扫除。
-// 实测事故：一轮 12 条互不相关主题被批量 archive，LLM 自述理由是「价值判断」
-// （对核心知识库长期参考价值较低、保持整洁和高信噪比），而提示词对 archive 的
-// 定义是「重复或过时」；12 条中 8 条疑似误伤，含 rejected_solution ×2、
-// constraint ×3、pitfall ×1 等长保留类型——这些类型的存在意义即长期保存，
-// 误归档损失最大。修复：
-//   1. 类型护栏——长保留类型（preference / pattern / rejected_solution /
-//      constraint / pitfall）的 archive 必须命中「重复/过时」类理由，否则单条
-//      跳过记 skipped（run 记 degraded），绝不整单拒绝；
-//   2. 批量上限——单轮 archive 条数封顶（dreamMaxArchivePerRun，默认 8），
-//      与 update 上限同类的全局闸门：skipInvalid 也不豁免，超限整单拒绝；
-//   3. 提示词同步强化（辅助防线）。
-// conflict 裁决的败者归档不经过 archive action，不受护栏影响。
-
-function snap(entries) {
-  return new Map(entries.map(([id, type]) => [id, { id, type, title: `t-${id}`, content: `c-${id}`, importance: 3, archived: false, forgotten: false }]));
-}
-
-// ---------------------------------------------------------- 类型护栏（纯函数）
-
-test("#104-2: long-retention archive with a duplicate/outdated rationale passes", () => {
-  const s = snap([["p1", "preference"], ["rs1", "rejected_solution"]]);
-  const decisions = [
-    { action: "archive", ids: ["p1"], reason: "与后续偏好重复，已被新条目取代" },
-    { action: "archive", ids: ["rs1"], reason: "duplicate of an earlier rejected approach (stale)" }
-  ];
-  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
-  assert.equal(ok, true);
-  assert.deepEqual(skipped, [], "duplicate/outdated rationales are accepted");
-});
-
-test("#104-2: long-retention archive with a value-judgment rationale is skipped (run degrades)", () => {
-  const s = snap([["c1", "constraint"], ["k1", "project"]]);
-  const decisions = [
-    { action: "archive", ids: ["c1"], reason: "多为一次性调试细节，对核心知识库长期参考价值较低，保持整洁和高信噪比" },
-    { action: "archive", ids: ["k1"], reason: "价值较低" }
-  ];
-  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
-  assert.equal(ok, true, "guard skips the single decision instead of rejecting the run");
-  assert.equal(skipped.length, 1, "only the guarded long-retention archive is skipped");
-  assert.match(skipped[0].error, /long-retention type\(s\) constraint/);
-  assert.match(skipped[0].error, /duplicate\/outdated rationale/);
-  // 幸存列表：普通类型照常归档，c1 被跳过后由隐式 keep 补位
-  assert.deepEqual(decisions.map((d) => d.action), ["archive", "keep"]);
-});
-
-test("#104-2: plain-type archive needs no rationale keywords (guard boundary)", () => {
-  const s = snap([["d1", "decision"], ["f1", "factor"]]);
-  const decisions = [
-    { action: "archive", ids: ["d1"], reason: "阶段性结论，已沉淀进项目记忆" },
-    { action: "archive", ids: ["f1"], reason: "清理" }
-  ];
-  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
-  assert.equal(ok, true);
-  assert.deepEqual(skipped, [], "guard applies to long-retention types only");
-});
-
-test("#104-2: conflict-loser archive is exempt (adjudication, not archive action)", () => {
-  const s = snap([["w", "preference"], ["l", "preference"]]);
-  const decisions = [{ action: "conflict", winner: "w", loser: "l", reason: "内容矛盾，保留更新的信息" }];
-  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
-  assert.equal(ok, true);
-  assert.deepEqual(skipped, [], "conflict adjudication does not go through the archive guard");
-});
-
-// ---------------------------------------------------------- 批量上限（纯函数）
-
-test("#104-2: archive count above the cap rejects the whole batch (global gate)", () => {
-  const entries = Array.from({ length: 10 }, (_, i) => [`d${i}`, "decision"]);
-  const s = snap(entries);
-  const decisions = entries.map(([id]) => ({ action: "archive", ids: [id], reason: "stale" }));
-  const { ok, errors } = validateDecisions(decisions, s, { skipInvalid: true });
-  assert.equal(ok, false, "9 archives > default cap 8 → reject even under skipInvalid");
-  assert.ok(errors.some((e) => e.includes("too many archive decisions")), `cap error present, got: ${errors.join("; ")}`);
-});
-
-test("#104-2: archive cap is configurable", () => {
-  const entries = Array.from({ length: 10 }, (_, i) => [`d${i}`, "decision"]);
-  const s = snap(entries);
-  const decisions = entries.map(([id]) => ({ action: "archive", ids: [id], reason: "stale" }));
-  const { ok, errors } = validateDecisions(decisions, s, { skipInvalid: true, maxArchivePerRun: 20 });
-  assert.equal(ok, true, `raised cap lets the sweep through, got: ${errors.join("; ")}`);
-});
-
-// ---------------------------------------------------------- 端到端（runDream）
-
-test("#104-2: runDream skips a value-judgment archive of a long-retention type and lands the rest", async () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  service.saveWithDedupe({ type: "project", title: "旧项目", content: "已完结并被取代", importance: 3 });
-  service.saveWithDedupe({ type: "constraint", title: "接口约束", content: "v1 接口只能串行调用", importance: 3 });
-  const ctx = mockCtx({
-    onConsolidation: (listText) => {
-      const entries = [...listText.matchAll(/id=([^\s|]+)\s*\|\s*type=(\w+)/g)].map((m) => ({ id: m[1], type: m[2] }));
-      const projectId = entries.find((e) => e.type === "project").id;
-      const constraintId = entries.find((e) => e.type === "constraint").id;
-      return JSON.stringify([
-        { action: "archive", ids: [projectId], reason: "重复或过时" },
-        { action: "archive", ids: [constraintId], reason: "保持知识库整洁，参考价值较低" }
-      ]);
-    }
-  });
-  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
-  const result = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
-  assert.notEqual(result.status, "failed", "guard skips instead of failing the run");
-  const constraint = service.all().find((m) => m.type === "constraint");
-  assert.equal(constraint.archived, false, "value-judgment archive of a long-retention type must not land");
-  store.close();
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler, validateDecisions } from "../src/dream.js";
+import { mockCtx } from "./helpers/dream-mock.js";
+
+// 回归（issue #104 方向 2）：archive 决策语义越界 + 批量大扫除。
+// 实测事故：一轮 12 条互不相关主题被批量 archive，LLM 自述理由是「价值判断」
+// （对核心知识库长期参考价值较低、保持整洁和高信噪比），而提示词对 archive 的
+// 定义是「重复或过时」；12 条中 8 条疑似误伤，含 rejected_solution ×2、
+// constraint ×3、pitfall ×1 等长保留类型——这些类型的存在意义即长期保存，
+// 误归档损失最大。修复：
+//   1. 类型护栏——长保留类型（preference / pattern / rejected_solution /
+//      constraint / pitfall）的 archive 必须命中「重复/过时」类理由，否则单条
+//      跳过记 skipped（run 记 degraded），绝不整单拒绝；
+//   2. 批量上限——单轮 archive 条数封顶（dreamMaxArchivePerRun，默认 8），
+//      与 update 上限同类的全局闸门：skipInvalid 也不豁免，超限整单拒绝；
+//   3. 提示词同步强化（辅助防线）。
+// conflict 裁决的败者归档不经过 archive action，不受护栏影响。
+
+function snap(entries) {
+  return new Map(entries.map(([id, type]) => [id, { id, type, title: `t-${id}`, content: `c-${id}`, importance: 3, archived: false, forgotten: false }]));
+}
+
+// ---------------------------------------------------------- 类型护栏（纯函数）
+
+test("#104-2: long-retention archive with a duplicate/outdated rationale passes", () => {
+  const s = snap([["p1", "preference"], ["rs1", "rejected_solution"]]);
+  const decisions = [
+    { action: "archive", ids: ["p1"], reason: "与后续偏好重复，已被新条目取代" },
+    { action: "archive", ids: ["rs1"], reason: "duplicate of an earlier rejected approach (stale)" }
+  ];
+  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, true);
+  assert.deepEqual(skipped, [], "duplicate/outdated rationales are accepted");
+});
+
+test("#104-2: long-retention archive with a value-judgment rationale is skipped (run degrades)", () => {
+  const s = snap([["c1", "constraint"], ["k1", "project"]]);
+  const decisions = [
+    { action: "archive", ids: ["c1"], reason: "多为一次性调试细节，对核心知识库长期参考价值较低，保持整洁和高信噪比" },
+    { action: "archive", ids: ["k1"], reason: "价值较低" }
+  ];
+  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, true, "guard skips the single decision instead of rejecting the run");
+  assert.equal(skipped.length, 1, "only the guarded long-retention archive is skipped");
+  assert.match(skipped[0].error, /long-retention type\(s\) constraint/);
+  assert.match(skipped[0].error, /duplicate\/outdated rationale/);
+  // 幸存列表：普通类型照常归档，c1 被跳过后由隐式 keep 补位
+  assert.deepEqual(decisions.map((d) => d.action), ["archive", "keep"]);
+});
+
+test("#104-2: plain-type archive needs no rationale keywords (guard boundary)", () => {
+  const s = snap([["d1", "decision"], ["f1", "factor"]]);
+  const decisions = [
+    { action: "archive", ids: ["d1"], reason: "阶段性结论，已沉淀进项目记忆" },
+    { action: "archive", ids: ["f1"], reason: "清理" }
+  ];
+  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, true);
+  assert.deepEqual(skipped, [], "guard applies to long-retention types only");
+});
+
+test("#104-2: conflict-loser archive is exempt (adjudication, not archive action)", () => {
+  const s = snap([["w", "preference"], ["l", "preference"]]);
+  const decisions = [{ action: "conflict", winner: "w", loser: "l", reason: "内容矛盾，保留更新的信息" }];
+  const { ok, skipped } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, true);
+  assert.deepEqual(skipped, [], "conflict adjudication does not go through the archive guard");
+});
+
+// ---------------------------------------------------------- 批量上限（纯函数）
+
+test("#104-2: archive count above the cap rejects the whole batch (global gate)", () => {
+  const entries = Array.from({ length: 10 }, (_, i) => [`d${i}`, "decision"]);
+  const s = snap(entries);
+  const decisions = entries.map(([id]) => ({ action: "archive", ids: [id], reason: "stale" }));
+  const { ok, errors } = validateDecisions(decisions, s, { skipInvalid: true });
+  assert.equal(ok, false, "9 archives > default cap 8 → reject even under skipInvalid");
+  assert.ok(errors.some((e) => e.includes("too many archive decisions")), `cap error present, got: ${errors.join("; ")}`);
+});
+
+test("#104-2: archive cap is configurable", () => {
+  const entries = Array.from({ length: 10 }, (_, i) => [`d${i}`, "decision"]);
+  const s = snap(entries);
+  const decisions = entries.map(([id]) => ({ action: "archive", ids: [id], reason: "stale" }));
+  const { ok, errors } = validateDecisions(decisions, s, { skipInvalid: true, maxArchivePerRun: 20 });
+  assert.equal(ok, true, `raised cap lets the sweep through, got: ${errors.join("; ")}`);
+});
+
+// ---------------------------------------------------------- 端到端（runDream）
+
+test("#104-2: runDream skips a value-judgment archive of a long-retention type and lands the rest", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  service.saveWithDedupe({ type: "project", title: "旧项目", content: "已完结并被取代", importance: 3 });
+  service.saveWithDedupe({ type: "constraint", title: "接口约束", content: "v1 接口只能串行调用", importance: 3 });
+  const ctx = mockCtx({
+    onConsolidation: (listText) => {
+      const entries = [...listText.matchAll(/id=([^\s|]+)\s*\|\s*type=(\w+)/g)].map((m) => ({ id: m[1], type: m[2] }));
+      const projectId = entries.find((e) => e.type === "project").id;
+      const constraintId = entries.find((e) => e.type === "constraint").id;
+      return JSON.stringify([
+        { action: "archive", ids: [projectId], reason: "重复或过时" },
+        { action: "archive", ids: [constraintId], reason: "保持知识库整洁，参考价值较低" }
+      ]);
+    }
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  assert.notEqual(result.status, "failed", "guard skips instead of failing the run");
+  const constraint = service.all().find((m) => m.type === "constraint");
+  assert.equal(constraint.archived, false, "value-judgment archive of a long-retention type must not land");
+  store.close();
+});

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

@@ -1,174 +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"
-  );
-});
+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"
+  );
+});