@modusensus/dsh-mneme 0.9.5 → 0.10.0

package/test/differentiate-feedback.test.js

@@ -0,0 +1,248 @@
+// Issue #533：differentiate 的正反馈死循环回归护栏。
+//
+// 现象（issue #533 实测）：sleepActionSet="full" 下，一对高相似记忆被判成
+// differentiate，旧实现把**同一段**差异注记同时追加到两侧正文，指望"注记进
+// embedding 后下一轮不再判重复"。离线复现证明恰好相反——两侧共享同一段后缀会让
+// 向量同向靠拢（0.876 → 0.960 只用 5 轮，把注记截到 0 字照样往上爬，因为推高相似
+// 度的是共享前缀本身而不是注记长短），于是下一轮又被判重复、又追加一段，实测单条
+// 堆到 19 段、正文 150 字膨胀到 2200+ 字。
+//
+// 现在的契约：differentiate **不改正文**，裁决落 differentiated_pairs 账本；候选
+// 构造阶段读账本，已裁决且两侧正文未变就不送模型。本文件锁的就是这两件事——
+// 「正文不变」和「第二轮不再花钱」。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { applyDecisions, validateDecisions } from "../src/dream/decisions.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+import { runSleep } from "../src/dream/sleep.js";
+
+const embedder = {
+  // 批量接口要按输入条数返回（向量回填走这一条），返回单个向量会让 usable 判空。
+  embedSingle: async () => [1, 0, 0],
+  embed: async (texts) => (Array.isArray(texts) ? texts.map(() => [1, 0, 0]) : [1, 0, 0]),
+  schedule: () => {},
+  modelHash: "mock#1",
+  dimension: 3
+};
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const vectorIndex = createVectorIndex({ store });
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vectorIndex);
+  return { store, service, vectorIndex };
+}
+
+function makeMemory(service, title, content, type = "project") {
+  return service.saveWithDedupe({ type, title, content, importance: 3 }).memory;
+}
+
+function snapshotOf(store, ...mems) {
+  return new Map(mems.map((m) => [m.id, store.getById(m.id)]));
+}
+
+function captureCtx(reply) {
+  const seen = [];
+  return {
+    seen,
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream(options) {
+        seen.push(options.messages.find((m) => m.system ?? m.role === "system")?.content?.[0]?.text ?? "");
+        yield { type: "text-delta", index: 0, text: typeof reply === "function" ? reply() : reply };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+function baseConfig(overrides = {}) {
+  return {
+    sleepModeEnabled: true,
+    sleepIdleMinutes: 5,
+    sleepMinIntervalHours: 8,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 100,
+    sleepMaxPatternPerRun: 3,
+    ...overrides
+  };
+}
+
+function seedPair(service, vectorIndex, t1, t2, sim = 1.0) {
+  const a = makeMemory(service, t1, `${t1} 的内容`);
+  const b = makeMemory(service, t2, `${t2} 的内容`);
+  const sin = Math.sqrt(Math.max(0, 1 - sim * sim));
+  vectorIndex.saveEmbedding(a.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(b.id, [sim, sin, 0]);
+  return { a, b };
+}
+
+// ---------------------------------------------------------------- 正文不变
+
+test("issue#533: repeated differentiate with drifting wording never grows the bodies", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "内网 SSH 端口", "内网走 22");
+  const b = makeMemory(service, "外网 SSH 端口", "外网映射 2222");
+  const before = { [a.id]: service.getById(a.id).content, [b.id]: service.getById(b.id).content };
+  // 模型每轮换一种说法——这正是字面 includes 幂等失效的场景，也是 issue 里单条堆到
+  // 19 段的真实成因。账本口径下措辞漂移不再产生任何正文副作用。
+  const wordings = [
+    ["内网直连", "外网映射"],
+    ["走内网", "走外网映射"],
+    ["内网那台直连", "外网那台做映射"],
+    ["内网的机器直连", "外网的机器走映射"],
+    ["内网直连（22）", "外网映射（2222）"]
+  ];
+  let appliedRounds = 0;
+  for (const distinctions of wordings) {
+    const snapshot = snapshotOf(store, service.getById(a.id), service.getById(b.id));
+    const { applied } = applyDecisions(
+      [{ action: "differentiate", ids: [a.id, b.id], distinctions }],
+      service, null, snapshot, {}
+    );
+    appliedRounds += applied;
+  }
+  assert.equal(appliedRounds, 1, "only the first round is a real verdict; the rest are idempotent");
+  // 这一条是 #533 的核心断言：无论判多少轮，正文长度一个字节都不许变。
+  assert.equal(service.getById(a.id).content, before[a.id], "side A body is byte-identical");
+  assert.equal(service.getById(b.id).content, before[b.id], "side B body is byte-identical");
+  assert.equal(service.getById(a.id).content.length, "内网走 22".length, "no note accumulates");
+  store.close();
+});
+
+test("issue#533: the ledger keeps one row per pair and refreshes the distinctions", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "甲", "内容甲");
+  const b = makeMemory(service, "乙", "内容乙");
+  for (const distinctions of [["第一版"], ["第二版", "补充版"]]) {
+    applyDecisions(
+      [{ action: "differentiate", ids: [a.id, b.id], distinctions }],
+      service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+    );
+  }
+  // 顺序归一：不管送审时谁在前，账本只有一行。
+  assert.equal(store.listDifferentiatedPairs().length, 1, "one pair, one row");
+  const record = service.findDifferentiatedPair(b.id, a.id);
+  assert.deepEqual(record.distinctions, ["第一版"], "an unchanged body keeps the original verdict");
+  store.close();
+});
+
+// -------------------------------------------------------------- 三层幂等
+
+test("issue#533: a body edited after the verdict re-opens the pair", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "甲", "内容甲");
+  const b = makeMemory(service, "乙", "内容乙");
+  applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  // 原样重放 → 幂等。
+  const replay = applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  assert.equal(replay.applied, 0, "an unchanged pair is idempotent");
+  // 一侧被改写 → 结论可能不再成立，必须能重新裁决（宁可再判一次，不静音真的演化）。
+  service.update(a.id, { content: "内容甲被改写" });
+  const reopened = applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面", "改写后"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  assert.equal(reopened.applied, 1, "an edited side re-opens the pair");
+  assert.deepEqual(
+    service.findDifferentiatedPair(a.id, b.id).distinctions, ["甲面", "乙面", "改写后"],
+    "the refreshed verdict replaces the stale one"
+  );
+  store.close();
+});
+
+test("issue#533: legacy rows that still carry the old note are treated as adjudicated", () => {
+  const { service, store } = setup();
+  // 旧版本写进正文的注记块原样造出来（升级不清账：这些行没有账本行）。
+  const a = makeMemory(service, "甲", "内容甲\n\n（差异注记：甲面；乙面）");
+  const b = makeMemory(service, "乙", "内容乙\n\n（差异注记：甲面；乙面）");
+  const { applied } = applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  assert.equal(applied, 0, "no ledger row is needed once both sides carry the note");
+  assert.equal(service.getById(a.id).content, "内容甲\n\n（差异注记：甲面；乙面）", "the legacy body is untouched");
+  store.close();
+});
+
+test("issue#533: a bare service without the ledger degrades to skipped, never throws", () => {
+  // 人工确认路径（service.js 的裸 applyService）没有账本透传——此时「正文不变」本身
+  // 就是全部副作用，没有账本就没有可写之处，只能是 skipped，不能算 applied。
+  const mems = new Map();
+  const bare = {
+    getById: (id) => mems.get(id) ?? null,
+    update: (id, patch) => { mems.set(id, { ...mems.get(id), ...patch }); },
+    setArchived: () => {},
+    transaction: (fn) => fn()
+  };
+  mems.set("a", { id: "a", title: "甲", content: "内容甲", archived: false });
+  mems.set("b", { id: "b", title: "乙", content: "内容乙", archived: false });
+  const { applied, failures } = applyDecisions(
+    [{ action: "differentiate", ids: ["a", "b"], distinctions: ["甲面", "乙面"] }],
+    bare, null, null, {}
+  );
+  assert.equal(applied, 0, "nothing to record, nothing applied");
+  assert.equal(failures.length, 0, "degrades cleanly");
+  assert.equal(mems.get("a").content, "内容甲", "still never touches the body");
+});
+
+// ------------------------------------------------------- 候选构造阶段抑制
+
+test("issue#533: a second sleep cycle does not pay for an already-adjudicated pair", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "甲端口", "乙端口");
+  const reply = () => JSON.stringify([
+    { action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }
+  ]);
+  const ctx1 = captureCtx(reply);
+  const first = await runSleep(ctx1, service, baseConfig({ sleepActionSet: "full" }), ctx1.logger, { embedder, vectorIndex }, null);
+  assert.equal(first.phases.conflicts.applied, 1, "the first cycle adjudicates the pair");
+  const callsAfterFirst = ctx1.seen.length;
+  assert.ok(service.findDifferentiatedPair(a.id, b.id), "the verdict landed in the ledger");
+
+  // 第二轮：同一对、同一相似度，账本命中且两侧正文未变 → 候选在送 LLM 之前就被压掉。
+  const ctx2 = captureCtx(reply);
+  const second = await runSleep(ctx2, service, baseConfig({ sleepActionSet: "full" }), ctx2.logger, { embedder, vectorIndex }, null);
+  assert.equal(second.phases.conflicts.status, "noop", "the phase has nothing left to adjudicate");
+  assert.equal(second.phases.conflicts.suppressed, 1, "the pair is accounted for, not silently dropped");
+  // 只数冲突阶段那次调用：patterns 阶段与本题无关，别把它的调用算进来。
+  assert.equal(ctx2.seen.filter((p) => p.includes("冲突仲裁")).length, 0,
+    "no LLM call is made for a settled pair");
+
+  // 但这不等于「永远不再判」：一侧被改写后必须重新回到候选里。
+  service.update(a.id, { content: "甲端口 的内容被改写" });
+  const ctx3 = captureCtx(reply);
+  const third = await runSleep(ctx3, service, baseConfig({ sleepActionSet: "full" }), ctx3.logger, { embedder, vectorIndex }, null);
+  assert.ok(ctx3.seen.some((p) => p.includes("冲突仲裁")), "an edited pair is re-sent to the model");
+  assert.ok(third.phases.conflicts, "the phase still runs");
+  store.close();
+});
+
+test("issue#533: the audit row reports suppressed separately from 'no conflicts found'", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "甲端口", "乙端口");
+  // 先手工记一笔账（正文与相似度都没变），第二轮应报 noop + suppressed。
+  applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  const ctx = captureCtx(JSON.stringify([]));
+  const result = await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.status, "noop");
+  assert.equal(result.phases.conflicts.reason, "all candidate pairs already differentiated");
+  assert.equal(result.phases.conflicts.suppressed, 1);
+  assert.equal(result.phases.conflicts.pairs, undefined, "no pair is reported as pending work");
+  store.close();
+});

package/test/dream-decision-evidence.test.js

@@ -0,0 +1,314 @@
+// issue #534：[0.9.5] dream 决策层 19 轮里 17 轮整轮判定无效，两轮 ok 也 applied=0，
+// 失败时不落原始决策。作者报的是三件互相独立的观测缺口，本文件各锁一条：
+//
+// 1. 失败的轮次只剩「N errors」这个结论，模型原文随日志滚掉，事后无法复现；
+//    → dream_runs.raw_output（不入 decisions 列：那一列的语义是「可重放决策数组」，
+//      applyDecisions 直接吃它，塞非决策对象会污染重放者）。
+// 2. skipped 里只有 index/action/ids/error 四键，看不出这条决策是「缺 title」
+//    还是「缺 content」——都是同一个 error 串里的不同分支；
+//    → 逐条补 has_keepSource / has_title / has_content 三个布尔。
+// 3. 审计算 95% 成功率、真实整轮只有 10.5%：两套账没有共同分母。
+//    → llm_audit_logs.metadata.decision_validation（verdict + 三个计数 + 动作名），
+//      不改 status/token/timestamp（那是调用层事实，改写等于伪造账本）。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import {
+  createDreamScheduler,
+  rawOutputPayload,
+  decisionValidationMeta,
+  validateDecisions
+} from "../src/dream.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { mockCtx } from "./helpers/dream-mock.js";
+
+function snapshot(ids) {
+  return new Map(ids.map((id) => [id, {
+    id, type: "project", title: `t-${id}`, content: `c-${id}`, importance: 3, archived: false, forgotten: false
+  }]));
+}
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  return { store, service, dream };
+}
+
+function consolidateAudits(service) {
+  return service.listLlmAudits({ limit: 20 }).filter((a) => a.operation_type === "dream_consolidate");
+}
+
+function metaOf(row) {
+  const meta = row.metadata;
+  return typeof meta === "string" ? JSON.parse(meta) : meta;
+}
+
+// ---------------------------------------------------------------- 建议 2 载荷
+
+test("#534: rawOutputPayload 只留头尾，空文本整键不写", () => {
+  assert.equal(rawOutputPayload(""), undefined, "空文本不许落空壳对象冒充「有原文」");
+  assert.equal(rawOutputPayload(undefined), undefined);
+  assert.equal(rawOutputPayload(null), undefined);
+
+  const short = rawOutputPayload("抱歉，我无法处理这个任务");
+  assert.equal(short.raw_len, 12);
+  assert.equal(short.raw_has_bracket, false, "有没有 '[' 是区分「没按格式写」与「格式对但救不回来」的判据");
+  assert.equal("raw_tail" in short, false, "短文本不补 tail：tail 是给跑飞的长输出定位收尾的");
+
+  const long = `起手 ${"填".repeat(600)} 收尾段落`;
+  const payload = rawOutputPayload(long);
+  assert.equal(payload.raw_len, long.length);
+  assert.equal(payload.raw_head, long.slice(0, 300), "头部固定 300 字，口径沿用 #504");
+  assert.equal(payload.raw_tail, long.slice(-200), "仅 >500 字时补末 200 字");
+  assert.equal(payload.raw_has_bracket, false);
+
+  assert.equal(rawOutputPayload("[{").raw_has_bracket, true);
+});
+
+test("#534: 拒收轮与合法子集的载荷形状一致，只是 verdict 不同", () => {
+  const rejected = decisionValidationMeta({ verdict: "rejected", errors: ["e1", "e2"], skipped: [{ action: "merge" }, { action: "merge" }, { action: "archive" }], survivorCount: 0 });
+  assert.deepEqual(rejected.decision_validation, {
+    verdict: "rejected",
+    error_count: 2,
+    skipped_count: 3,
+    survivor_count: 0,
+    invalid_actions: ["merge", "archive"]
+  });
+  const ok = decisionValidationMeta({ verdict: "ok", errors: [], skipped: [], survivorCount: 4 });
+  assert.equal(ok.decision_validation.verdict, "ok");
+  assert.deepEqual(ok.decision_validation.invalid_actions, []);
+  assert.equal(ok.decision_validation.survivor_count, 4);
+});
+
+// ---------------------------------------------------------------- 建议 1 三布尔
+
+test("#534: skipped 逐条带 has_keepSource / has_title / has_content，能区分缺哪一项", () => {
+  const ids = ["a", "b"];
+  const snap = snapshot(ids);
+  // ① merge 什么都不给 → 三个布尔全 false（keepSource 不在 ids 里、title/content 空）
+  const bare = validateDecisions([{ action: "merge", ids }], snap, { skipInvalid: true });
+  assert.equal(bare.skipped.length, 1);
+  const skippedBare = bare.skipped[0];
+  assert.deepEqual(Object.keys(skippedBare).sort(), ["action", "error", "has_content", "has_keepSource", "has_title", "ids", "index"],
+    "既有四键保留，只加三个布尔——不塞原文");
+  assert.equal(skippedBare.has_keepSource, false);
+  assert.equal(skippedBare.has_title, false);
+  assert.equal(skippedBare.has_content, false);
+
+  // ② 三项都给但 keepSource 不指向自家人 → 仍被拒，但三布尔能看出「字段是齐的」
+  const full = validateDecisions([{
+    action: "merge", ids, keepSource: "zzz", title: "合并标题", content: "合并正文", importance: 4
+  }], snap, { skipInvalid: true });
+  assert.equal(full.skipped.length, 1);
+  assert.equal(full.skipped[0].has_keepSource, true, "写了 keepSource 就要看清「写了但不合法」");
+  assert.equal(full.skipped[0].has_title, true);
+  assert.equal(full.skipped[0].has_content, true);
+  assert.match(full.skipped[0].error, /keepSource/, "具体不合法的点仍在 error 里，布尔只补形状");
+
+  // ③ 空白字符串不算「有」：模型常把缺省值写成空串
+  const blank = validateDecisions([{ action: "merge", ids, keepSource: "a", title: "   ", content: "\n" }], snap, { skipInvalid: true });
+  assert.equal(blank.skipped[0].has_title, false);
+  assert.equal(blank.skipped[0].has_content, false);
+});
+
+// ---------------------------------------------------------------- 建议 2 落库（端到端）
+
+test("#534: 解析失败轮把模型原文写进 raw_output，decisions 仍然不落库", async () => {
+  const { store, service, dream } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const prose = "抱歉，我无法处理这个任务";
+  const result = await dream.runDream(mockCtx({ onConsolidation: () => prose }), service, {});
+  assert.equal(result.ok, false);
+  assert.match(result.error, /no json array/);
+
+  const run = store.getDreamRun(result.runId);
+  assert.equal(run.decisions, undefined, "回归锁：decisions 列仍只承载「可重放决策数组」");
+  assert.ok(run.raw_output, "失败轮必须留下原文读数（此前只有一条会滚掉的 warn）");
+  assert.equal(run.raw_output.raw_len, prose.length);
+  assert.equal(run.raw_output.raw_head, prose, "原文本身要能在库外复现模型到底吐了什么");
+  assert.equal(run.raw_output.raw_has_bracket, false);
+  store.close();
+});
+
+test("#534: 校验整单拒绝轮同样落 raw_output（原文是有效的 JSON 数组）", async () => {
+  const { store, service, dream } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const decisions = JSON.stringify([{ action: "archive", ids: ["deadbeef"] }]);
+  const result = await dream.runDream(mockCtx({ onConsolidation: () => decisions }), service, {});
+  assert.equal(result.ok, false);
+  assert.match(result.error, /invalid decisions/);
+
+  const run = store.getDreamRun(result.runId);
+  assert.equal(run.decisions[0]._validationFailed, true, "既有哨兵不变（#135 锁）");
+  assert.equal(run.raw_output.raw_len, decisions.length);
+  assert.equal(run.raw_output.raw_head, decisions, "被拒但格式合法的轮次，原文最有价值：能离线重跑校验");
+  assert.equal(run.raw_output.raw_has_bracket, true, "区分「格式对但内容不合法」与「压根没写 JSON」");
+  store.close();
+});
+
+test("#534: 流错误（没有文本可留）落 NULL，不许写空壳对象", async () => {
+  const { store, service, dream } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const ctx = {
+    logger: { warn: () => {}, info: () => {} },
+    llm: {
+      async *stream() {
+        yield { type: "finish", reason: { kind: "error", failure: { code: "RATE_LIMIT", message: "429" } } };
+      }
+    }
+  };
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, false);
+  const run = store.getDreamRun(result.runId);
+  assert.equal(run.raw_output, undefined, "提供方错误时模型没吐过正文，落 NULL 而不是 {raw_len:0}");
+  store.close();
+});
+
+// ---------------------------------------------------------------- 建议 3 分账
+
+test("#534: 校验判决补回同一行的 metadata，调用层事实不动", async () => {
+  const { store, service, dream } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  await dream.runDream(mockCtx({ onConsolidation: () => "抱歉，我无法处理这个任务" }), service, {});
+  const row = consolidateAudits(service).find((a) => a.status === "error");
+  assert.ok(row, "调用层仍按既有口径记 error（吐了正文却不是 JSON 数组）");
+  const meta = metaOf(row);
+  assert.deepEqual(meta.decision_validation, {
+    verdict: "unparsed",
+    error_count: 0,
+    skipped_count: 0,
+    survivor_count: 0,
+    invalid_actions: []
+  }, "「没解析出数组」是判决的第四种状态，不能跟「整单拒绝」混成一个");
+  assert.equal(meta.parse_failure, true, "#504 的解析失败读数必须保留（dream-fence 锁）");
+  assert.equal(row.status, "error", "补注不许改写调用层 status");
+  assert.ok(row.total_tokens >= 0, "token 计数原样保留");
+  store.close();
+});
+
+test("#534: 调用成功但决策被整单拒绝 → 同一行同时读出两层结论", async () => {
+  const { store, service, dream } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  await dream.runDream(mockCtx({
+    onConsolidation: () => JSON.stringify([{ action: "archive", ids: ["deadbeef"] }])
+  }), service, {});
+  const rows = consolidateAudits(service);
+  const row = rows[0];
+  assert.equal(row.status, "success", "调用是真的成功了——这是作者说的「审计 95% 成功率」那一侧");
+  const meta = metaOf(row);
+  assert.equal(meta.decision_validation.verdict, "rejected", "整轮无效在这一侧才看得见（真实 10.5%）");
+  assert.equal(meta.decision_validation.skipped_count, 1);
+  assert.deepEqual(meta.decision_validation.invalid_actions, ["archive"]);
+  assert.ok(meta.decision_validation.error_count >= 1, "all-invalid 的整单错误串要计入 error_count");
+  store.close();
+});
+
+test("#534: 合法子集（degraded）的 verdict 与 survivor_count 对得上", async () => {
+  const { store, service, dream } = setup();
+  const { memory: m } = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  await dream.runDream(mockCtx({
+    onConsolidation: () => JSON.stringify([
+      { action: "keep", ids: [m.id] },
+      { action: "archive", ids: ["deadbeef"] }
+    ])
+  }), service, {});
+  const row = consolidateAudits(service)[0];
+  assert.equal(row.status, "success");
+  const meta = metaOf(row);
+  assert.equal(meta.decision_validation.verdict, "degraded");
+  assert.equal(meta.decision_validation.skipped_count, 1);
+  // 校验器就地 splice 掉被跳过的条目，所以存活数就是校验后的 decisions 长度：
+  // 这里 1 条 keep 存活、1 条 archive 被跳过（隐式 keep 不会重复补已 claim 的 id）。
+  assert.equal(meta.decision_validation.survivor_count, 1, "存活数是校验后真正会被消费的条目数");
+  store.close();
+});
+
+test("#534: 全部合法的轮次 verdict=ok，metadata 不因补注长出多余键", async () => {
+  const { store, service, dream } = setup();
+  const { memory: m } = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const result = await dream.runDream(mockCtx({
+    onConsolidation: () => JSON.stringify([{ action: "keep", ids: [m.id] }])
+  }), service, {});
+  assert.equal(result.ok, true);
+  const row = consolidateAudits(service)[0];
+  const meta = metaOf(row);
+  assert.equal(meta.decision_validation.verdict, "ok");
+  assert.equal(meta.decision_validation.skipped_count, 0);
+  assert.equal(meta.parse_failure, undefined, "成功轮不许带解析失败读数");
+  store.close();
+});
+
+test("#534: 覆盖率不足（没有逐条跳过）也判 degraded，与 dream_runs.status 同源", async () => {
+  // CodeRabbit on #535：coverageShortfall 同样是校验层降级。此前 verdict 只认
+  // skippedInvalid，于是「模型给了合法子集、但覆盖不到半数」的轮次会落成
+  // dream_runs.status="degraded" 而 metadata 写 verdict="ok"——两套账在最该
+  // 对齐的一格上又对不上。这条锁把它们绑死在同一个判据上。
+  const { store, service, dream } = setup();
+  const ids = [];
+  for (let i = 0; i < 5; i += 1) {
+    ids.push(service.saveWithDedupe({ type: "project", title: `覆盖-${i}`, content: `覆盖正文-${i}`, importance: 3 }).memory.id);
+  }
+  const result = await dream.runDream(mockCtx({
+    // 2/5 = 40% 覆盖 < 下限 50%，且没有一条被逐条跳过——降级理由只能是 coverage。
+    // 必须让一条真落地（archive 掉一条）：全 keep 轮会先被 noChange 分支截走
+    // （那里 status 只由 summaryStored 决定），走不到 coverage 这一格。
+    onConsolidation: () => JSON.stringify([
+      { action: "keep", ids: [ids[0]] },
+      { action: "archive", ids: [ids[1]], reason: "重复条目" }
+    ])
+  }), service, { dreamImplicitKeep: true, dreamMinExplicitCoverage: 0.5 });
+  const run = store.getDreamRun(result.runId);
+  assert.equal(run.applied, 1, "先确认这条路径真的落地了改动（否则测的还是 noChange 分支）");
+  assert.equal(run.status, "degraded", "覆盖率不足在 run 行上一直是 degraded（#104 方向 1）");
+  const meta = metaOf(consolidateAudits(service)[0]);
+  assert.equal(meta.decision_validation.verdict, "degraded", "审计 metadata 必须跟 run 行说同一件事");
+  assert.equal(meta.decision_validation.skipped_count, 0, "这条路径没有逐条跳过，判据只能是 coverage");
+  assert.equal(meta.decision_validation.survivor_count, 5, "未 claim 的 4 条被隐式 keep 补齐，全部存活");
+  store.close();
+});
+
+test("#534: 审计行的 id 来自本次插入，不是「当前最大 id」", async () => {
+  // CodeRabbit on #535（Major）：saveLlmAudit 原来先 INSERT 再
+  // `SELECT * ORDER BY id DESC LIMIT 1`。库支持多进程共用，另一个写者插在
+  // 中间就会把这行读成别人的调用，随后 annotate 把本轮判决写到别人头上。
+  // 这里用「连续两次写入各自拿回自己那行」锁住回读口径。
+  const { store, service } = setup();
+  const first = service.saveLlmAudit({ trigger_source: "t", operation_type: "o1", model_id: "m", status: "success" });
+  service.saveLlmAudit({ trigger_source: "t", operation_type: "o2", model_id: "m", status: "success" });
+  const second = service.saveLlmAudit({ trigger_source: "t", operation_type: "o3", model_id: "m", status: "success" });
+  assert.equal(first.operation_type, "o1", "回读的必须是自己插入的那一行");
+  assert.equal(second.operation_type, "o3");
+  assert.ok(second.id > first.id, "id 单调，但取值只认本次插入");
+
+  // 判决补注同样按 id 定位：插一行噪声在后面，也不能改变目标行。
+  service.saveLlmAudit({ trigger_source: "t", operation_type: "noise", model_id: "m", status: "success" });
+  const updated = service.annotateLlmAudit(first.id, { decision_validation: { verdict: "rejected" } });
+  assert.equal(updated.operation_type, "o1", "补注不许漂到别的行");
+  const rows = service.listLlmAudits({ limit: 20 });
+  assert.equal(rows.find((r) => r.operation_type === "noise").metadata, undefined, "噪声行不许被写上本轮判决");
+  store.close();
+});
+
+test("#534: saveLlmAudit 不再用「取最大 id」回读（源码锁）", () => {
+  const src = readFileSync(new URL("../src/store.js", import.meta.url), "utf8");
+  const body = src.slice(src.indexOf("function saveLlmAudit(entry)"));
+  const head = body.slice(0, body.indexOf("\n  }\n"));
+  // 先去注释再判：解释这条坑的注释本身会引述旧写法，不剥掉就永远命中自己。
+  const code = head.replace(/^\s*\/\/.*$/gm, "");
+  assert.equal(code.includes("ORDER BY id DESC LIMIT 1"), false,
+    "多进程共用同一库时「取最大 id」会读成别人的行——必须用 lastInsertRowid");
+  assert.match(code, /lastInsertRowid/, "回读口径锁在本次插入返回的 rowid 上");
+  assert.match(code, /SELECT \* FROM llm_audit_logs WHERE id = \?/, "回读用主键定位，不用排序取首行");
+});
+
+// ---------------------------------------------------------------- 改动面守卫
+
+test("#534: decisions 列之外没有别的写入口往那一列塞非决策对象", () => {
+  // 这条锁防的是「后来有人图省事，把原文/诊断内联进 decisions」——那会同时打挂
+  // applyDecisions 的重放语义与所有按决策数组消费的下游。
+  const src = readFileSync(new URL("../src/dream.js", import.meta.url), "utf8");
+  assert.match(src, /raw_output:\s*result\.raw_output/, "finish 必须把 raw_output 转发给 saveDreamRun");
+  assert.equal(src.includes("_rawOutput"), false, "不许另起一个内联标记走 decisions 列");
+});

package/test/dream-fence.test.js

@@ -14,6 +14,9 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { breakFenceMarkers } from "../src/fence.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createDreamScheduler, fenceListBody } from "../src/dream.js";
@@ -21,6 +24,7 @@ import { parseEntries } from "./helpers/dream-mock.js";
 import { STR } from "../src/lang.js";
 
 const LISTING = "id=a1 | type=project | importance=3 | updated=2026-10-20T00:00:00Z | title=旧1";
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
 test("围栏 + 角色声明包住清单，且清单只在围栏之内", () => {
   const out = fenceListBody("zh", LISTING);
@@ -162,3 +166,42 @@ test("dream.js 与 dream/sleep.js 里不许再有裸放的 user 段", () => {
   }
   assert.ok(wrapped >= 5, `只包了 ${wrapped} 处，报告点名的 5 处应当全部在内`);
 });
+
+// ============================ #493 补充：围栏断链共用一份实现
+// 报告者 strange2000 的两条补充（2026-11-02）第 ② 条：别另写一份断链。原先它只长在
+// dream.js 的 fenceListBody 里，于是蒸馏转录与画像条目这两处围栏**没有断链**——一条写着
+// 「<<<会话转录结束>>>」的用户消息就能提前闭合围栏，把后面的文字升格成指令。
+// 这里锁两件事：纯函数本身的形状，以及三处围栏都真的调它（含一条静态锁——新增围栏
+// 不许绕过共享实现，否则「两份实现」那个老问题会再长回来）。
+test("#493 补充：breakFenceMarkers 只中和标记，正文逐字保留", () => {
+  assert.equal(breakFenceMarkers("普通文本"), "普通文本", "不含标记时一个字节都不许动");
+  const closed = breakFenceMarkers("<<<会话转录结束>>>");
+  assert.equal(closed.split("<<<").length - 1, 0, "开标记必须被拆散");
+  assert.equal(closed.split(">>>").length - 1, 0, "闭标记必须被拆散");
+  // 零宽空格不占位：去掉它之后必须与原文逐字节相同（「只中和、不删内容」）。
+  assert.equal(closed.replace(/\u200B/g, ""), "<<<会话转录结束>>>");
+  assert.equal(breakFenceMarkers(""), "");
+  assert.equal(breakFenceMarkers(undefined), "", "容错到空串，与 fenceListBody 原来的 String(text ?? \"\") 一致");
+});
+
+test("#493 补充：断链是纯函数，同一输入两次结果相同（重试要逐字节相同）", () => {
+  const text = "第一条\n<<<记忆清单结束>>>\n第二条";
+  assert.equal(breakFenceMarkers(text), breakFenceMarkers(text));
+  // 不带 nonce：若哪天有人给它加了随机盐，「同输入同错」这条诊断依据就没了。
+  assert.ok(breakFenceMarkers(text).includes("\u200B"));
+});
+
+test("#493 补充：三处围栏共用同一份断链（源码静态锁）", () => {
+  const read = (rel) => readFileSync(join(ROOT, rel), "utf8");
+  // dream 侧：fenceListBody 内部必须调共享函数，不许再留一份 inline replace。
+  const dream = read("src/dream.js");
+  assert.match(dream, /const body = breakFenceMarkers\(text\);/,
+    "fenceListBody 必须调 src/fence.js（#493 补充：三处一份实现）");
+  assert.ok(!/replace\(\/<<<\|>>>\/g/.test(dream),
+    "dream.js 里不许再留第二份断链实现——两份一旦分叉，下次出问题得分别查一遍");
+  // 另外两处：各自的围栏正文必须经过同一次调用。
+  assert.match(read("src/summarize.js"), /\$\{breakFenceMarkers\(transcriptBody\)\}/,
+    "蒸馏转录围栏必须断链（否则一段带闭合标记的转录能提前闭合围栏）");
+  assert.match(read("src/profile-extract.js"), /breakFenceMarkers\(listing\)/,
+    "画像条目围栏同样要断链");
+});

package/test/inject-pools.test.js

@@ -135,7 +135,8 @@ test("#249: capability guide registers exactly once, and stays off when the key
   assert.equal(on.sections.length, 1, "exactly one guide section");
   assert.equal(on.sections[0].name, "memory-guide");
   assert.equal(on.sections[0].order, 150, "插件指引段的既有 order 惯例");
-  assert.equal(on.sections[0].text, MEMORY_GUIDE_SECTION, "常量文本 → 同会话内稳定");
+  assert.equal(typeof on.sections[0].text, "function", "guide text resolves per prompt context so session gating can apply");
+  assert.equal(on.sections[0].text({}), MEMORY_GUIDE_SECTION, "normal sessions receive the same guide text");
   // 不可逆工具（memory_delete）的克制指引必须在场：这是全 guide 里唯一有数据
   // 损失后果的一句，被误删掉的回归要能立刻转红。
   assert.ok(MEMORY_GUIDE_SECTION.includes("memory_delete"), "guide keeps the irreversible-tool warning");