@modusensus/dsh-mneme 0.9.3 → 0.9.5

package/test/organize-tool.test.js

@@ -0,0 +1,232 @@
+// issue #231 的第二批：把已造好的整理引擎接到 agent 的调用面上（organizeEnabled
+// + memory_organize 工具）。src/organize.js 的本体语义由 test/organize.test.js 守，
+// 本文件只守**出口**这一层：闸门、报告/落地的两步协议、以及 strictScope 下
+// 「看不见的行按不存在处理」这条可信上下文。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+import { applyLightModePreset } from "../src/config.js";
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const registered = [];
+  const ctx = {
+    tools: {
+      register(def) {
+        registered.push(def);
+        return () => {};
+      }
+    }
+  };
+  createTools(ctx, service, config, undefined);
+  const byName = Object.fromEntries(registered.map((def) => [def.name, def]));
+  return { store, service, byName, registered };
+}
+
+const CANDIDATES = [
+  { type: "project", title: "发布只在包目录内", content: "根目录发过坏包，发布必须在 dsh-mneme/ 内执行。" },
+  { type: "project", title: "另一条", content: "第二条候选的正文。" }
+];
+
+test("memory_organize registers when organizeEnabled is on", async () => {
+  const { byName } = setup({ organizeEnabled: true });
+  const tool = byName.memory_organize;
+  assert.ok(tool, "organizeEnabled=true 应当注册 memory_organize");
+  const report = await tool.execute({ mode: "dryRun", candidates: CANDIDATES });
+  assert.equal(report.status, "ok");
+  assert.equal(report.counts.total, 2, "两条候选都应进报告");
+  assert.equal(report.run_id ? typeof report.run_id : "none", "string", "dryRun 必须回一个 run_id 供 apply 引用");
+});
+
+// 默认关=零行为变化是仓库红线（AGENTS.md 自查清单第 1 条）。这条现在就会绿——
+// 它防的是「以后有人把默认翻成 true」，而不是今天的缺失实现。
+test("memory_organize stays unregistered by default", () => {
+  const { registered } = setup();
+  assert.equal(registered.some((t) => t.name === "memory_organize"), false, "organizeEnabled 缺省时不得注册");
+});
+
+test("lightMode preset turns organize off, but an explicit user switch wins", () => {
+  // 轻量档那一格是**预设**，不是强制（合并顺序「用户开关 > 轻量预设 > bundle」在
+  // index.js），所以这里断言的是预设值本身——同 continuity.test.js 的
+  // continuityRescueEnabled 那条。工具侧的注册与否由上一条默认关用例守着。
+  assert.equal(applyLightModePreset({ lightMode: true }).organizeEnabled, false);
+  assert.equal(applyLightModePreset({ lightMode: true, organizeEnabled: true }).organizeEnabled, false, "预设写死 false，赢的是合并时的用户开关，不是这里");
+});
+
+test("dryRun writes no memory rows but leaves one organize audit row", () => {
+  const { store, byName } = setup({ organizeEnabled: true });
+  return byName.memory_organize.execute({ mode: "dryRun", candidates: CANDIDATES }).then((report) => {
+    assert.deepEqual(store.list({ limit: null }), [], "比对是报告，不是动作：记忆表必须一行不写");
+    const runs = store.listDreamRuns({ limit: 10 });
+    assert.equal(runs.length, 1, "dryRun 只留 dream_runs 一行回执");
+    assert.equal(runs[0].run_type, "organize");
+    assert.equal(runs[0].id, report.run_id);
+  });
+});
+
+test("apply lands the decisions it references and reports counters", async () => {
+  const { store, byName } = setup({ organizeEnabled: true });
+  const report = await byName.memory_organize.execute({ mode: "dryRun", candidates: CANDIDATES });
+  const applied = await byName.memory_organize.execute({
+    mode: "apply",
+    run_id: report.run_id,
+    decisions: [
+      { action: "save", index: 0 },
+      { action: "discard", index: 1 }
+    ]
+  });
+  assert.equal(applied.saved, 1, "只数新建的行");
+  assert.equal(applied.discarded, 1);
+  assert.equal(applied.status, "ok");
+  assert.equal(store.list({ limit: null }).length, 1, "一条 save、一条 discard → 库里只有一行");
+  const types = store.listDreamRuns({ limit: 10 }).map((r) => r.run_type);
+  assert.deepEqual(types, ["organize", "organize"], "报告与落地各留一行审计");
+});
+
+test("apply refuses a run_id that was never reported", async () => {
+  const { byName } = setup({ organizeEnabled: true });
+  await assert.rejects(
+    () => byName.memory_organize.execute({ mode: "apply", run_id: "no-such-run", decisions: [{ action: "discard", index: 0 }] }),
+    /unknown organize run/,
+    "没有比对过的候选一律不落库（organize 硬规则 2）"
+  );
+});
+
+test("apply refuses a missing run_id", async () => {
+  const { byName } = setup({ organizeEnabled: true });
+  await assert.rejects(
+    () => byName.memory_organize.execute({ mode: "apply", decisions: [{ action: "discard", index: 0 }] }),
+    /run_id is required/,
+    "apply 必须引用一次真实 dryRun"
+  );
+});
+
+// 整理接口不能成为第二条「写进库却不带 scope」的通道：memory_save 在 scopeEnabled
+// 下按会话身份盖 auto 章，organize 落地的候选必须同源。显式参数改盖 explicit，
+// 与 memory_save / memory_register_document 同一规则。
+test("save lands candidates stamped with the session scope (auto), like memory_save", async () => {
+  const { store, byName } = setup({ organizeEnabled: true, scopeEnabled: true });
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "me", cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute({ mode: "dryRun", candidates: CANDIDATES }, exec);
+  await byName.memory_organize.execute({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] }, exec);
+  const row = store.list({ limit: null })[0];
+  assert.equal(row.agent_scope, "me", "缺省吃会话身份");
+  assert.equal(row.agent_scope_source, "auto");
+  assert.equal(row.workspace_scope, "D:\\p");
+});
+
+test("explicit scope arguments stamp as explicit and win over the session label", async () => {
+  const { store, byName } = setup({ organizeEnabled: true, scopeEnabled: true });
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "me", cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute(
+    { mode: "dryRun", candidates: CANDIDATES, agent_scope: "other-agent" },
+    exec
+  );
+  await byName.memory_organize.execute({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] }, exec);
+  const row = store.list({ limit: null })[0];
+  assert.equal(row.agent_scope, "other-agent", "显式参数盖在会话身份之上");
+  assert.equal(row.agent_scope_source, "explicit");
+});
+
+test("unknown mode is rejected", async () => {
+  const { byName } = setup({ organizeEnabled: true });
+  await assert.rejects(() => byName.memory_organize.execute({ mode: "force" }), /unknown mode/);
+});
+
+// #170 复核项 4 的口径延伸到整理接口的**两侧**：报告侧不得泄漏存在性，落地侧不得
+// 绕过 scope 治理改库。用例形状是刻意挑的：比对键只看三列**值**（sensitivity/agent/
+// workspace），可见性还多认一个 `explicit` 来源，所以要造出「按值该命中、但会话看不见」
+// 那一格——匿名会话（解析不到 agentPreset）对 explicit 行 fail-closed。
+// 报告侧少了过滤就是探测口：`agent_scope` 是模型自己给的参数，A 会话可以拿 B 的标题问
+// 「那一档有没有这行」，拿回 id/title 就等于确认存在——memory_get 在同一条件下回「不存在」。
+test("dryRun reports an invisible match as new, with no id or title", async () => {
+  const config = { organizeEnabled: true, scopeEnabled: true, strictScope: true };
+  const { store, byName } = setup(config);
+  store.save({
+    type: "project",
+    title: "发布只在包目录内",
+    content: "team-a 名下的旧行。",
+    agent_scope: "team-a",
+    agent_scope_source: "explicit",
+    workspace_scope: "D:\\p",
+    workspace_scope_source: "auto"
+  });
+  const exec = { agent: { session: { id: "s-anon", header: { cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute(
+    {
+      mode: "dryRun",
+      candidates: [{ type: "project", title: "发布只在包目录内", content: "换一种说法的同一件事。" }],
+      agent_scope: "team-a",
+      workspace_scope: "D:\\p"
+    },
+    exec
+  );
+  assert.equal(report.items[0].verdict, "new", "看不见的行按不存在处理 → 报告只能说「新条目」");
+  assert.equal(report.items[0].match, undefined, "不得带回落点 id/title/sim");
+  assert.equal(report.counts.new, 1);
+});
+
+// 反面对照：strictScope 是**可选**硬过滤，关掉它时那行本来就可读（A2 只降权）。少了这条，
+// 过滤就变成「闸门关着也少召回」的第二重惩罚——修安全问题不许顺手改默认行为。
+test("the same row is still reported as exact when strictScope is off", async () => {
+  const config = { organizeEnabled: true, scopeEnabled: true };
+  const { store, byName } = setup(config);
+  const row = store.save({
+    type: "project",
+    title: "发布只在包目录内",
+    content: "team-a 名下的旧行。",
+    agent_scope: "team-a",
+    agent_scope_source: "explicit",
+    workspace_scope: "D:\\p",
+    workspace_scope_source: "auto"
+  });
+  const exec = { agent: { session: { id: "s-anon", header: { cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute(
+    {
+      mode: "dryRun",
+      candidates: [{ type: "project", title: "发布只在包目录内", content: "换一种说法的同一件事。" }],
+      agent_scope: "team-a",
+      workspace_scope: "D:\\p"
+    },
+    exec
+  );
+  assert.equal(report.items[0].verdict, "exact");
+  assert.equal(report.items[0].match.id, row.id, "闸门关着时照常给出落点，否则比对报告失去意义");
+});
+
+// 落地侧：报告已按「不存在」说了，archive 也不许真的动那一行（`opts.hiddenIds` 由可信
+// 调用层算好传入，绝不取 payload 字段——那是调用方可自选的内容，不是授权）。
+test("archive of a row the caller cannot see is skipped as out of scope", async () => {
+  const config = { organizeEnabled: true, scopeEnabled: true, strictScope: true };
+  const { store, byName } = setup(config);
+  const teamRow = store.save({
+    type: "project",
+    title: "发布只在包目录内",
+    content: "team-a 名下的旧行。",
+    agent_scope: "team-a",
+    agent_scope_source: "explicit",
+    workspace_scope: "D:\\p",
+    workspace_scope_source: "auto"
+  });
+  const exec = { agent: { session: { id: "s-anon", header: { cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute(
+    {
+      mode: "dryRun",
+      candidates: [{ type: "project", title: "发布只在包目录内", content: "换一种说法的同一件事。" }],
+      agent_scope: "team-a",
+      workspace_scope: "D:\\p"
+    },
+    exec
+  );
+  const applied = await byName.memory_organize.execute(
+    { mode: "apply", run_id: report.run_id, decisions: [{ action: "archive", id: teamRow.id }] },
+    exec
+  );
+  assert.equal(applied.archived, 0, "看不见的行按不存在处理，不得归档");
+  assert.equal(applied.skipped.length, 1);
+  assert.match(applied.skipped[0].error, /out of scope/, "文案维持「unknown, archived or out of scope」：不泄漏存在性");
+  assert.equal(store.getById(teamRow.id).archived, false, "他人的行原样未动");
+});

package/test/persona-addressing.test.js

@@ -0,0 +1,83 @@
+// 修复一：人格寻址的兜底口径。default 卡的存在理由是「这一帧解析不到会话身份」，
+// 而不是「所有没建卡的 agent 都该拿到它」——后者会把某个人格无条件塞进外部 bot 的
+// 会话（DS Bot 那类：它自己带身份与设定，两处身份声明撞在同一帧里）。
+// 现状（personaStrictAddressing 缺省 = false）已由 test/persona-inject.test.js:113
+// 与 :124 钉住，本文件第一条照样锁它——这是 opt-in，不是把别人的行为改了。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+function setup(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const contexts = [];
+  const ctx = {
+    systemPrompt: {
+      context(def) {
+        contexts.push(def);
+        return () => {};
+      }
+    }
+  };
+  createInjector(ctx, service, settings, { maxInjectedItems: 3, importanceThreshold: 3, ...over });
+  return { store, settings, settingsCtx: contexts.find((c) => c.name === "user-settings") };
+}
+
+const withPreset = (agentPreset) => ({ agent: { session: { id: "s1", header: { agentPreset } } } });
+
+// 种子：default 卡（Amarre）开着 + 一张 zephyr 卡。
+function seed(settings, zephyrEnabled = true) {
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: true });
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危", enabled: zephyrEnabled });
+}
+
+test("缺省（开关关）：没建卡的身份仍落 default——本 PR 不改默认行为", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  seed(settings);
+  const text = settingsCtx.text(withPreset("unknown-bot"));
+  assert.ok(text.includes("Amarre"), "personaStrictAddressing 缺省时行为逐字节不变");
+  store.close();
+});
+
+test("strict on：没建卡的身份不注入任何人格行", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings);
+  settings.setProfile("用户是规划背景");
+  const text = settingsCtx.text(withPreset("unknown-bot"));
+  assert.ok(!text.includes("Amarre"), "外部身份不该收到别人的人格");
+  assert.ok(!text.includes("你的人格名字"), "无人格时整段人格行都不出现，不是留个空标签");
+  store.close();
+});
+
+test("strict on：显式关掉的卡不再回落 default——这让「关掉这张卡」第一次有意义", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings, false);
+  const text = settingsCtx.text(withPreset("zephyr"));
+  assert.ok(!text.includes("泽菲尔"), "关掉的卡本身不注入");
+  assert.ok(!text.includes("Amarre"), "关掉之后落回 default 等于没关");
+  store.close();
+});
+
+test("strict on：解析不到身份（无 session.header）照旧用 default 卡", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings);
+  const text = settingsCtx.text({});
+  assert.ok(text.includes("你的人格名字：Amarre"), "无名会话正是 default 卡的受众，strict 不许把它一起关掉");
+  store.close();
+});
+
+test("strict on：命中的卡照常注入，画像与规则不受影响", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings);
+  settings.setProfile("用户是规划背景");
+  settings.setRules(["不提及用户名"]);
+  const hit = settingsCtx.text(withPreset("zephyr"));
+  assert.ok(hit.includes("你的人格名字：泽菲尔"), "身份命中时行为与现状一致");
+  assert.ok(hit.includes("- 用户画像：用户是规划背景"), "画像恒注入：本开关只管人格行");
+  assert.ok(hit.includes("- 规则：不提及用户名"), "规则恒注入：同上");
+  store.close();
+});

package/test/persona-settings.test.js

@@ -7,6 +7,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { createStore } from "../src/store.js";
 import { createSettings } from "../src/settings.js";
+import { resolvePersonaCard } from "../src/user-settings.js";
 
 function setup() {
   const store = createStore(":memory:");
@@ -81,10 +82,14 @@ test("v1 legacy single-object persona reads as default (zero migration)", () =>
   store.close();
 });
 
-test("byAgent card round-trips via setPersonaFor/getPersonaFor", () => {
+// 寻址口径住在 src/user-settings.js（注入与面板预览共用一份），不在 settings 里——
+// settings 只存卡。原来那两个 getPersonaFor 用例因此改指向 resolvePersonaCard：
+// 断言的是同一件事，但落在唯一那份实现上。
+test("byAgent card round-trips via setPersonaFor/resolvePersonaCard", () => {
   const { store, settings } = setup();
   settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危占有", enabled: true });
-  assert.deepEqual(settings.getPersonaFor("zephyr"), { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  assert.deepEqual(resolvePersonaCard(settings, "zephyr").card, { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  assert.equal(resolvePersonaCard(settings, "zephyr").source, "byAgent");
   // default 仍在且未被影响
   assert.deepEqual(settings.getPersona().default, {});
   // 卡列表含 zephyr
@@ -92,17 +97,34 @@ test("byAgent card round-trips via setPersonaFor/getPersonaFor", () => {
   store.close();
 });
 
-test("getPersonaFor falls back to default when id card missing or disabled", () => {
+test("缺省寻址：身份没建卡、或卡被关掉，都落 default", () => {
   const { store, settings } = setup();
   settings.setPersona({ name: "Amarre", enabled: true }); // 单对象形写 default
   settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: false }); // 卡存在但关
-  // 未注册身份 → default
-  assert.equal(settings.getPersonaFor("unknown-bot").name, "Amarre");
+  assert.equal(resolvePersonaCard(settings, "unknown-bot").card.name, "Amarre");
   // 身份卡存在但 enabled=false → 落 default（兜底优先，不注入半张卡）
-  assert.equal(settings.getPersonaFor("zephyr").name, "Amarre");
+  assert.equal(resolvePersonaCard(settings, "zephyr").card.name, "Amarre");
   // 身份缺失（null/空串）→ default
-  assert.equal(settings.getPersonaFor(null).name, "Amarre");
-  assert.equal(settings.getPersonaFor("").name, "Amarre");
+  assert.equal(resolvePersonaCard(settings, null).card.name, "Amarre");
+  assert.equal(resolvePersonaCard(settings, "").card.name, "Amarre");
+  store.close();
+});
+
+test("strict 寻址：身份没建卡与卡被关掉都不注入，无名会话仍用 default", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: false });
+  const strict = { strict: true };
+  for (const id of ["unknown-bot", "zephyr"]) {
+    const { card, source } = resolvePersonaCard(settings, id, strict);
+    assert.equal(source, "none", `${id} 在严格寻址下不该拿到任何卡`);
+    assert.deepEqual(card, {});
+  }
+  // 开着的身份卡照样命中（strict 不改变命中语义）
+  settings.setPersonaFor("mentor", { name: "导师", enabled: true });
+  assert.equal(resolvePersonaCard(settings, "mentor", strict).source, "byAgent");
+  // 解析不到身份 = default 卡的受众，strict 不动这一格
+  assert.equal(resolvePersonaCard(settings, null, strict).card.name, "Amarre");
   store.close();
 });
 

package/test/pipeline-r1r2.test.js

@@ -147,3 +147,132 @@ test("坏输入不抛", () => {
   assert.doesNotThrow(() => suggestRetirements(p, { runs: [{}] }));
   assert.doesNotThrow(() => suggestRetirements(p, { runs: [{ at: null, steps: null }] }));
 });
+
+// #461：violationSeen 跨整本账本共享，而键里的 `run.at ?? ""` 在 at 缺失时塌缩成
+// 空串——于是**所有**无时间戳的 run，其同 (step, need) 违规会被并成一条。去重本意是
+// 「同一轮里同一条只报一次」，不是「所有轮共享一条」。内容不同的两条 run 该产出两条。
+test("#461：两条内容不同、都无 run.at 的 run，同类违规不被并成一条", () => {
+  const p = makePipeline([
+    step("A", { tool: "npm test" }),
+    step("B", { tool: "git push", needs: ["A"] })
+  ]);
+  // 都只做了 B、都没带 at，但走的不是同一条路：by 不同 → 内容指纹不同 → 各报一条
+  const runs = [
+    { at: null, by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "x" }] },
+    { at: undefined, by: "agent", triggeredBy: "nightly", steps: [{ id: "B", at: "x" }] }
+  ];
+  const v = suggestRetirements(p, { runs }).filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 2, "两条独立的 run 各报一条，不被键塌缩吞掉");
+  assert.equal(v[0].stepId, "B");
+  assert.equal(v[1].stepId, "B");
+});
+
+// #507 评审：同一个 run 在账本里出现两次，同一条违规仍只报一次。
+// 位置索引做不到这件事——它只在「本次遍历的数组顺序」里唯一，同一条 run 出现在
+// 下标 0 和 1 时会拿到两个键。所以 at 缺失时兜底用内容指纹，不用索引。
+test("#507：同一条 run 出现两次，同类违规仍只报一次", () => {
+  const p = makePipeline([
+    step("A", { tool: "npm test" }),
+    step("B", { tool: "git push", needs: ["A"] })
+  ]);
+  const same = { at: null, by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "x" }] };
+  const v = suggestRetirements(p, { runs: [same, same] }).filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 1, "同一条 run 的两份记录是同一个观测，不是两次违规");
+});
+
+// #507 评审（CodeRabbit）：两类键必须不相撞。第 0 条缺 at，而另一条的 at 字面量
+// 正好是 "#0"——用位置索引兜底时两者生成同一个键，后一条违规被静默吞掉。
+test("#507：at 字面量与兜底键不相撞（第 0 条缺 at vs 另一条 at 是 \"#0\"）", () => {
+  const p = makePipeline([
+    step("A", { tool: "npm test" }),
+    step("B", { tool: "git push", needs: ["A"] })
+  ]);
+  const runs = [
+    { at: null, by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "x" }] },
+    { at: "#0", by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "x" }] }
+  ];
+  const v = suggestRetirements(p, { runs }).filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 2, "字面量 #0 与兜底键不是同一个东西，两条都要报");
+});
+
+// at 存在时行为不变：同 at 的重复违规仍然只报一条（原有去重语义不能被修坏）。
+test("#461：at 存在时同轮重复违规仍只报一条（回归保护）", () => {
+  const p = makePipeline([
+    step("A", { tool: "npm test" }),
+    step("B", { tool: "git push", needs: ["A"] })
+  ]);
+  const runs = [
+    RUN("2026-10-17T00:00:00Z", [{ id: "B", at: "x" }]),
+    RUN("2026-10-17T00:00:00Z", [{ id: "B", at: "x" }])
+  ];
+  const v = suggestRetirements(p, { runs }).filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 1, "同一 at 的同一违规仍然只报一次");
+});
+
+// #507（CodeRabbit）：匿名指纹必须收 step 的 at。两条都缺 run.at、只在 steps[0].at 上
+// 不同的 run 是两次不同的观测；漏了 at 会让它们共键，后一条的 violation-precedence 被
+// 去重吞掉。修复前（只取 step.id）报 1 条，修复后（收 at）报 2 条——这是本条的 red→green。
+test("#507：匿名指纹收 step.at——只差 steps[0].at 的两条 at-less run 各报一条", () => {
+  const p = makePipeline([
+    step("A", { tool: "npm test" }),
+    step("B", { tool: "git push", needs: ["A"] })
+  ]);
+  const runs = [
+    { at: null, by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "2026-10-17T00:00:00Z" }] },
+    { at: undefined, by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "2026-10-18T00:00:00Z" }] }
+  ];
+  const v = suggestRetirements(p, { runs }).filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 2, "只差步骤时间的两条 at-less run 是两次观测，不能被并成一条");
+});
+
+// #507：匿名指纹**不能**把整个 step 对象序列化进去——note 是自由文本，进去会让「只差
+// 备注的同一条观测」被当成两次。今天没有任何测试锁这条；不加，未来重构把 note 加回来
+// 还会全绿。这是前瞻守卫：当前修复前后都是 1，但把 note 塞进指纹就会转红（见复盘）。
+test("#507：匿名指纹排除 note——只差 steps[0].note 的两条 at-less run 仍是同一条", () => {
+  const p = makePipeline([
+    step("A", { tool: "npm test" }),
+    step("B", { tool: "git push", needs: ["A"] })
+  ]);
+  const runs = [
+    { at: null, by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "x", note: "第一次跑，网络慢" }] },
+    { at: undefined, by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "x", note: "重跑，还是慢" }] }
+  ];
+  const v = suggestRetirements(p, { runs }).filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 1, "note 是自由文本不是身份，只差备注应仍算同一条观测");
+});
+
+// #507：锁定旗标语义。指纹覆盖归一化 step 的全部结构化字段（含 skipped/detoured/refuted），
+// 而这三个布尔对去重正确性是**惰性**的（violation 判定只读 doneIds 与 id 是否存在，
+// refuted 根本不被读）。代价如实记在这里：两条只差惰性旗标的 at-less run 会各报一条
+// **逐字相同**的提议。锁成 2 + deepEqual，防止将来无声漂移；anon 路径在生产不可达
+// （readStoredRun 强制 run.at），故此代价不落到真实账本上。
+test("#507：只差 refuted 的两条 at-less run 给出两条逐字相同的提议（锁旗标语义）", () => {
+  const p = makePipeline([
+    step("A", { tool: "npm test" }),
+    step("B", { tool: "git push", needs: ["A"] })
+  ]);
+  const runs = [
+    { at: null, by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "x", refuted: false }] },
+    { at: null, by: "human", triggeredBy: "demo", steps: [{ id: "B", at: "x", refuted: true }] }
+  ];
+  const v = suggestRetirements(p, { runs }).filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 2, "refuted 在指纹里：两条只差 refuted 的 run 拿到两个键");
+  assert.deepEqual(v[0], v[1], "两条提议逐字相同——这正是把惰性旗标收进指纹的代价");
+});
+
+// #507：锁编码必须是**无歧义**序列化（JSON.stringify），不能退回手写 `${id}@${at}`。
+// run 侧 step id 只过 isSafeSegment（src/pipeline-runs.js:83），`@` `,` `:` 都是合法 id：
+// 手写拼接会把 [{A,t1},{B,t1},{C,t1}] 与 [{"A@t1,B",t1},{C,t1}] 撞成同一个键，run2 的
+// (C,P) 违规被静默吞掉（只报 3 条）。当前实现与更早的 id-only 实现都报 4；退回手写拼接会红。
+test("#507：step id 含 @/, 不撞键（锁 JSON.stringify 编码，手写拼接会漏报）", () => {
+  const p = makePipeline([
+    step("P"),
+    step("A", { needs: ["P"] }), step("B", { needs: ["P"] }), step("C", { needs: ["P"] })
+  ]);
+  const runs = [
+    { at: null, by: "human", triggeredBy: "demo", steps: [{ id: "A", at: "t1" }, { id: "B", at: "t1" }, { id: "C", at: "t1" }] },
+    { at: null, by: "human", triggeredBy: "demo", steps: [{ id: "A@t1,B", at: "t1" }, { id: "C", at: "t1" }] }
+  ];
+  const v = suggestRetirements(p, { runs }).filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 4, "两条 run 内容不同：run1 断 A/B/C 三条边、run2 断 C 一条，共 4 条");
+});

package/test/policy-epoch.test.js

@@ -45,9 +45,9 @@ function mockCtx({ onConsolidation, summaryText = "记忆库总览：用户偏
     llm: {
       async *stream(options) {
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
+        if (userText.includes("| type=")) {
           yield { type: "block-start", index: 0, blockType: "text" };
-          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
+          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText, options.purpose) : "[]" };
           yield { type: "block-end", index: 0, block: { type: "text" } };
           yield { type: "finish", reason: { kind: "stop" } };
           return;