@modusensus/dsh-mneme 0.9.4 → 0.10.0

package/test/dream.test.js

@@ -850,7 +850,7 @@ test("runDream with dreamImplicitKeep=false rejects a partial mock output (missi
     llm: {
       async *stream(options) {
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
+        if (userText.includes("| type=")) {
           const ids = [...userText.matchAll(/id=([^\s|]+)\s*\|\s*type=(\w+)\s*\|\s*importance=\d+/g)].map((m) => m[1]);
           yield { type: "text-delta", index: 0, text: JSON.stringify(ids.slice(0, 1).map((id) => ({ action: "archive", ids: [id], reason: "stale" }))) };
         } else {
@@ -1091,7 +1091,7 @@ test("issue#89: dream run with a skipped invalid decision lands the valid subset
     llm: {
       async *stream(options) {
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
+        if (userText.includes("| type=")) {
           // 一条跨类型 merge（非法 → 跳过）+ 两条合法 archive（覆盖 2/4 快照，
   // 高于 50% 显式覆盖率下限）
           yield { type: "text-delta", index: 0, text: JSON.stringify([
@@ -1131,7 +1131,7 @@ test("issue#104: degraded run persists the skipped decision detail into dream_ru
     llm: {
       async *stream(options) {
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
+        if (userText.includes("| type=")) {
           // 一条跨类型 merge（非法 → 跳过）+ 两条合法 archive（显式覆盖 2/4，过 50% 下限）
           yield { type: "text-delta", index: 0, text: JSON.stringify([
             { action: "merge", ids: [pref.id, a.id], keepSource: pref.id, title: "跨类型", content: "不应合并", importance: 4 },
@@ -1169,7 +1169,7 @@ test("issue#89: dreamSkipInvalid:false restores the whole-batch strict rejection
     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: "text-delta", index: 0, text: JSON.stringify([
             { action: "merge", ids: [pref.id, a.id], keepSource: pref.id, title: "跨类型", content: "不应合并", importance: 4 },
             { action: "archive", ids: [b.id], reason: "stale" }
@@ -1291,7 +1291,7 @@ test("issue#258: dreamSummaryMaxInputs caps summary inputs to the newest N (0 =
   const origStream = ctx.llm.stream.bind(ctx.llm);
   ctx.llm.stream = async function* (options) {
     const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-    if (!userText.startsWith("id=")) seenUserText.push(userText);
+    if (!userText.includes("| type=")) seenUserText.push(userText);
     yield* origStream(options);
   };
   const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
@@ -1370,6 +1370,88 @@ test("validateDecisions mergeGuard: non-guarded types unaffected, guard off = le
   );
 });
 
+// Issue #521：merge 护栏与 archive 护栏对齐——真重复/真过时的长保留类型必须
+// 能合，否则提示词催着模型合、护栏一律拦，形成「每轮重提同一簇、满载 token 空
+// 转、merge 恒为 0」的自锁。锁三件事：①同类型 + 重复理由放行；②只有理由没有
+// 同类型不放行（逃生门不跟着放宽跨类型）；③同类型但理由只是「主题相近」不放行
+// （相近 ≠ 重复，这条是故意的）。
+test("validateDecisions mergeGuard: genuine duplicate of a long-retention type passes (issue #521)", () => {
+  const snap = new Map([
+    ["p1", { id: "p1", type: "preference", title: "喜欢深色主题", content: "偏好深色", importance: 3, archived: false, forgotten: false }],
+    ["p2", { id: "p2", type: "preference", title: "偏好深色主题", content: "偏好深色界面", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const decisions = [
+    { action: "merge", ids: ["p1", "p2"], keepSource: "p1", title: "喜欢深色主题", content: "偏好深色界面", importance: 3, reason: "两条重复" }
+  ];
+  const { ok, skipped } = validateDecisions(decisions, snap, { skipInvalid: true, mergeGuard: true });
+  assert.equal(ok, true, "duplicate-rationale merge of guarded type survives the guard");
+  assert.equal(skipped.length, 0, "nothing skipped when the escape hatch opens");
+  assert.equal(decisions.filter((d) => d.action === "merge").length, 1, "merge decision is applied, not dropped");
+});
+
+test("validateDecisions mergeGuard: same type but only 'topically similar' rationale still blocked (issue #521)", () => {
+  const snap = new Map([
+    ["p1", { id: "p1", type: "preference", title: "喜欢深色主题", content: "偏好深色", importance: 3, archived: false, forgotten: false }],
+    ["p2", { id: "p2", type: "preference", title: "喜欢等宽字体", content: "偏好等宽", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const decisions = [
+    { action: "merge", ids: ["p1", "p2"], keepSource: "p1", title: "界面偏好", content: "深色 + 等宽", importance: 3, reason: "主题相近" }
+  ];
+  // 单条决策被跳过后批次整体不成立（覆盖率下限），所以配一条合法的非 guarded
+  // merge 让批次存活，单独观察这条被拦的理由。
+  decisions.push({ action: "merge", ids: ["h1", "h2"], keepSource: "h1", title: "旧事合并", content: "合并内容", importance: 3 });
+  snap.set("h1", { id: "h1", type: "history", title: "旧事", content: "内容", importance: 3, archived: false, forgotten: false });
+  snap.set("h2", { id: "h2", type: "history", title: "旧事2", content: "内容2", importance: 3, archived: false, forgotten: false });
+  const { ok, skipped } = validateDecisions(decisions, snap, { skipInvalid: true, mergeGuard: true });
+  assert.equal(ok, true, "skipInvalid keeps the batch alive");
+  assert.equal(skipped.length, 1, "topically-similar rationale is not a duplicate rationale");
+  assert.match(skipped[0].error, /dreamMergeGuard/);
+  assert.match(skipped[0].error, /重复\/过时/, "skip reason tells the model what would unblock it");
+});
+
+test("validateDecisions mergeGuard: duplicate rationale does not unlock cross-type merge (issue #521)", () => {
+  const snap = new Map([
+    ["c1", { id: "c1", type: "constraint", title: "预算", content: "$12,400", importance: 4, archived: false, forgotten: false }],
+    ["p1", { id: "p1", type: "preference", title: "预算偏好", content: "$12,400", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const decisions = [
+    { action: "merge", ids: ["c1", "p1"], keepSource: "c1", title: "预算", content: "$12,400", importance: 4, reason: "重复" }
+  ];
+  // 显式放开 allowCrossTypeMerge：跨类型本身不再报错，逃生门仍必须拦住它——
+  // 否则「重复」理由会把约束和偏好揉成一条，正是 #339 要防的失真。
+  const { skipped } = validateDecisions(decisions, snap, {
+    skipInvalid: true,
+    mergeGuard: true,
+    allowCrossTypeMerge: true
+  });
+  assert.equal(skipped.length, 1, "escape hatch requires all ids share one type");
+  assert.match(skipped[0].error, /dreamMergeGuard/);
+});
+
+// #522 评审：逃生门的词表只认关键词、不认否定。「并不重复，只是主题相近」与
+// "not a duplicate" 都含「重复」/"duplicate" 子串，放它们过闸等于模型用一句否认
+// 换来合并许可——恰好把 #339 要防的「两条独立表述被揉成一段糊话」放回来。
+test("validateDecisions mergeGuard: a negated duplicate rationale does not open the escape hatch (#522)", () => {
+  const makeSnap = () => new Map([
+    ["p1", { id: "p1", type: "preference", title: "喜欢深色主题", content: "偏好深色", importance: 3, archived: false, forgotten: false }],
+    ["p2", { id: "p2", type: "preference", title: "喜欢等宽字体", content: "偏好等宽", importance: 3, archived: false, forgotten: false }],
+    ["h1", { id: "h1", type: "history", title: "旧事", content: "内容", importance: 3, archived: false, forgotten: false }],
+    ["h2", { id: "h2", type: "history", title: "旧事2", content: "内容2", importance: 3, archived: false, forgotten: false }]
+  ]);
+  // 中英各一条否定表述：都要被拦。配一条合法的非 guarded merge 让批次存活
+  // （单条决策被跳过后覆盖率下限会让整批不成立），单独观察被拦的理由。
+  // 第二轮评审：词表里「过时 / stale / outdated」也是钥匙，同样要挡。
+  for (const reason of ["并不重复，只是主题相近", "not a duplicate, just similar", "并不过时，只是主题相近", "not outdated, merely similar", "not stale, just similar"]) {
+    const decisions = [
+      { action: "merge", ids: ["p1", "p2"], keepSource: "p1", title: "界面偏好", content: "深色 + 等宽", importance: 3, reason },
+      { action: "merge", ids: ["h1", "h2"], keepSource: "h1", title: "旧事合并", content: "合并内容", importance: 3 }
+    ];
+    const { ok, skipped } = validateDecisions(decisions, makeSnap(), { skipInvalid: true, mergeGuard: true });
+    assert.equal(ok, true, "skipInvalid keeps the batch alive");
+    assert.equal(skipped.length, 1, `negated rationale must not open the escape hatch: ${reason}`);
+    assert.match(skipped[0].error, /dreamMergeGuard/);
+  }
+});
 test("validateDecisions archive guard: long-retention type without duplicate/outdated rationale is skipped (prior gap)", () => {
   const snap = new Map([
     ["c", { id: "c", type: "constraint", title: "预算", content: "$12,400", importance: 4, archived: false, forgotten: false }],

package/test/helpers/dream-mock.js

@@ -70,8 +70,12 @@ export function mockCtx({ onConsolidation, summaryText = "记忆库总览：用
     llm: {
       async *stream(options) {
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
-          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
+        // 认「这是巩固那一次调用」的判据：以前看 userText 是否以 `id=` 开头，但
+        // #493 追加的围栏让 user 段以角色声明开头了。改判清单**形状**而不是首行——
+        // `| type=` 只有巩固清单有（叙述条的 listing 形如 `- id=… | title=…`，没有
+        // type=），所以两条调用路径不会串台。
+        if (userText.includes("| type=")) {
+          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText, options.purpose) : "[]" };
         } else {
           yield { type: "text-delta", index: 0, text: summaryText };
         }

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");

package/test/llm-message-source.test.js

@@ -62,7 +62,7 @@ test("dream: consolidation and summary messages carry source", async () => {
         calls.push(options);
         assertMessageSources(options);
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        yield* reply(userText.startsWith("id=") ? "[]" : "记忆库总览：已巩固。");
+        yield* reply(userText.includes("| type=") ? "[]" : "记忆库总览：已巩固。");
       }
     }
   };

package/test/mint-source.test.js

@@ -127,7 +127,7 @@ function sleepCtx(decisionsJson) {
     llm: {
       async *stream(options) {
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        yield { type: "text-delta", index: 0, text: userText.startsWith("id=") ? decisionsJson : "[]" };
+        yield { type: "text-delta", index: 0, text: userText.includes("| type=") ? decisionsJson : "[]" };
         yield { type: "finish", reason: { kind: "stop" } };
       }
     }
@@ -200,3 +200,86 @@ test("mint source: rows are countable by source after minting", () => {
   assert.equal(bySource.get("manual"), undefined, "nothing minted here fell back to the default");
   store.close();
 });
+
+// ── Issue #512：铸造出来的记忆要能追到「哪一轮」 ──
+//
+// source 只说「哪条管道」，不说「哪一次运行」。同一管道跑过几百轮之后，
+// 「这条 pattern 是哪一轮抽出来的」在数据面上仍然不可读——这正是 #512 要补的。
+// 归因落在 memory_mints：dream/sleep 铸造的记忆没有会话区间（session/seq 都不存在），
+// 硬塞合成区间就是编的，所以窗口级归因（memory_provenance）与行级归因（本表）分层。
+
+test("issue#512: a created row remembers which run minted it", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "dream", runId: "run-abc" }
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "pattern minted");
+  const mints = store.mintsFor(row.id);
+  assert.equal(mints.length, 1, "one created row = one mint record");
+  assert.equal(mints[0].run_id, "run-abc");
+  assert.equal(mints[0].run_type, "dream");
+  assert.equal(mints[0].trigger_source, "autoDream");
+  store.close();
+});
+
+// 没有 run id 时什么都不写。旧装配（或直接调 applyDecisions 的调用方）没有 run 概念，
+// 这时候编一个 id 出来比留空更坏：它会让「能追到」变成一句谎话。
+test("issue#512: without a run id no mint record is fabricated", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "无轮模式", content: "规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "dream" }
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "pattern still minted — 记账缺失不该拦铸造");
+  assert.deepEqual(store.mintsFor(row.id), []);
+  store.close();
+});
+
+// 只记 create。merge/conflict/update/supersede 动的是既有行，receipt_chain 已按
+// (run_id, record_id) 记过一遍；再造一份就是第二套账，两边迟早对不上。
+test("issue#512: only creation is recorded — edits to existing rows stay in receipt_chain", () => {
+  const { store, service } = setup();
+  const existing = service.saveWithDedupe({ type: "project", title: "既有行", content: "旧内容", importance: 3 }).memory;
+  applyDecisions(
+    [{ action: "update", ids: [existing.id], content: "新内容", importance: 4 }],
+    service,
+    null,
+    null,
+    { mintSource: "dream", runId: "run-upd" }
+  );
+  assert.deepEqual(store.mintsFor(existing.id), [], "update 不是铸造，不进 memory_mints");
+  store.close();
+});
+
+// 端到端：sleep 真的跑一轮，铸造出来的行要指回那一轮的 runId（不是随便一个 id）。
+test("issue#512: sleep mints point back at the run that produced them", async () => {
+  const { store, service } = setup();
+  mint(service);
+  mint(service);
+  const ctx = sleepCtx(
+    JSON.stringify([{ action: "create", type: "pattern", title: "真模式", content: "从 a 和 b 提取", importance: 3 }])
+  );
+  const config = { sleepModeEnabled: true, sleepPatternMinMemories: 10, sleepMaxPatternPerRun: 3 };
+  const result = await runSleep(ctx, service, config, ctx.logger, null, null);
+  assert.equal(result.phases.patterns.status, "ok", "pattern phase minted");
+
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "pattern minted");
+  const mints = store.mintsFor(row.id);
+  assert.equal(mints.length, 1);
+  assert.equal(mints[0].run_id, result.runId, "归因要指回这一轮的 runId，不是另编一个");
+  assert.equal(mints[0].run_type, "sleep");
+  assert.equal(mints[0].trigger_source, "sleep");
+  // 那一轮 run 台账本身也在：两边能对上，归因才成立。
+  assert.equal(store.getDreamRun(result.runId).run_type, "sleep");
+  store.close();
+});

package/test/pipeline-nudge-auto.test.js

@@ -1,6 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { createNudgeAutoRun } from "../src/pipeline-nudge-auto.js";
+import { createSessionGate } from "../src/session-gate.js";
 
 // 这组守的是**触发侧**（v0.9.3）：什么时候跑、跑几次、跑挂了怎么办。
 // 挖掘算法本身在 pipeline-nudge.test.js 里守，这里只守接线，所以 runNudge 全部用假的。
@@ -25,8 +26,8 @@ function fakeCtx() {
   };
 }
 
-function sessionAt(cwd) {
-  return { header: { cwd } };
+function sessionAt(cwd, id = undefined) {
+  return { ...(id ? { id } : {}), header: { cwd } };
 }
 
 /** 把 setTimeout(0) 排的活跑完：本模块刻意不用同步跑（见文件头）。 */
@@ -66,6 +67,29 @@ test("自动沉淀只认 turn/end：中途事件不排队、不预跑", async ()
   auto();
 });
 
+test("#539：无痕 turn/end 不触发全项目扫描，正常会话仍可触发", async () => {
+  const ctx = fakeCtx();
+  const calls = [];
+  const gate = createSessionGate({ sessionGateEnabled: true, sessionGateSessions: ["private"] });
+  const auto = createNudgeAutoRun({
+    ctx,
+    sessionGate: gate,
+    runNudge: (args) => { calls.push(args); return { counts: { savedProposals: 0 } }; },
+    now: () => 1_000_000
+  });
+
+  ctx.emit(sessionAt("D:/proj", "private"), { type: "turn/end" });
+  await tick();
+  assert.deepEqual(calls, [], "the incognito session itself cannot schedule a scan");
+  assert.equal(auto.pendingCount(), 0);
+
+  ctx.emit(sessionAt("D:/proj", "captain"), { type: "turn/end" });
+  await tick();
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].sessionGate, gate, "later project scans still exclude incognito session files");
+  auto();
+});
+
 test("自动跑永远是「只落提议、不落草稿」：materialize 恒 false", async () => {
   const ctx = fakeCtx();
   const calls = [];

package/test/pipeline-nudge.test.js

@@ -37,6 +37,7 @@ import {
   nudgeForProject,
   resolveProjectSessionDir
 } from "../src/pipeline-nudge.js";
+import { createSessionGate } from "../src/session-gate.js";
 
 // 这组测试守的是 M.O. 的**沉淀链**：一条工作流能不能从真实数据里自己长出来。
 // 三条不许越的分界线（见 src/pipeline-nudge.js 文件头），测试逐条守：
@@ -103,6 +104,92 @@ test("多帧 zstd 要逐帧解：只解第一帧会静默丢掉后面的回合",
   });
 });
 
+test("#539：nudge 日志扫描按精确 id 与真实子代理头过滤会话", () => {
+  withDir((dir) => {
+    const sessions = join(dir, "sessions");
+    const manualDir = join(sessions, "ws", "manual");
+    const childDir = join(sessions, "ws", "child");
+    const captainDir = join(sessions, "ws", "captain");
+    mkdirSync(manualDir, { recursive: true });
+    mkdirSync(childDir, { recursive: true });
+    mkdirSync(captainDir, { recursive: true });
+    const privateCall = sessionLine({ turn: 1, calls: [skill("private-skill"), skill("private-next")] });
+    writeFileSync(join(manualDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(privateCall)));
+    const childHeader = JSON.stringify({
+      type: "session",
+      cwd: "C:\\proj",
+      parentSession: "captain",
+      origin: "subagent",
+      delegationDepth: 1
+    });
+    writeFileSync(join(childDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(`${childHeader}\n${privateCall}`)));
+    const publicCall = sessionLine({ turn: 1, calls: [skill("public-skill"), skill("public-next")] });
+    const captainHeader = JSON.stringify({ type: "session", cwd: "C:\\proj", origin: "main", delegationDepth: 0 });
+    writeFileSync(join(captainDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(`${captainHeader}\n${publicCall}`)));
+    // 只带 parentSession 的会话 = sessions.fork() 出来的主会话分支，不是子代理。
+    // 本机 641 个真实会话头里这样的有 3 个（各 74–136 条用户消息），把它们当子代理
+    // 过滤掉就是「fork 一下就失忆」。
+    const forkedDir = join(sessions, "ws", "forked");
+    mkdirSync(forkedDir, { recursive: true });
+    const forkedHeader = JSON.stringify({
+      type: "session",
+      version: 4,
+      cwd: "C:\\proj",
+      parentSession: "captain",
+      isSeeded: true,
+      delegationDepth: 0
+    });
+    const forkedCall = sessionLine({ turn: 1, calls: [skill("forked-skill"), skill("forked-next")] });
+    writeFileSync(join(forkedDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(`${forkedHeader}\n${forkedCall}`)));
+
+    const gate = createSessionGate({
+      sessionGateEnabled: true,
+      sessionGateSubagents: true,
+      sessionGateSessions: ["manual"]
+    });
+    const read = readSessionObservations({ sessionDir: sessions, sessionGate: gate });
+    assert.deepEqual([...new Set(read.observations.map((item) => item.sessionId))], ["captain", "forked"]);
+    assert.ok(!read.observations.some((item) => item.name.startsWith("private")));
+    assert.ok(read.observations.some((item) => item.name === "forked-skill"), "a forked captain session keeps its observations");
+
+    const disabled = createSessionGate({ sessionGateEnabled: false, sessionGateSessions: ["manual"] });
+    const unchanged = readSessionObservations({ sessionDir: sessions, sessionGate: disabled });
+    assert.ok(unchanged.observations.some((item) => item.sessionId === "manual"), "master-off keeps existing scan behavior");
+  });
+});
+
+// 形状锁：只有首行是 {"type":"session",...} 时才把整行当作会话头。
+// 旧实现的兜底链末尾是 `?? row?.data?.header ?? row?.data?.config ?? row?.data ?? row`，
+// 等于**任何**首行都能被当成 header。这不只是「会不会漏」的问题：一条非会话记录
+// 里只要出现 `origin` / `delegationDepth`，就会被读成一条子代理头，把这个**正常
+// 会话**的观测从扫描结果里整批划掉——M.O. 的提议因此静默少掉一块数据，而现场
+// 回头看日志时那条会话明明在。本机 641 个真实会话首行的 `type` 全部是
+// "session"（v3/v4 都是头字段直接躺在首行顶层），先认 `type` 不漏任何真实会话；
+// 认不出来时返回 null、退回只按 id 判——**宁可少认一条头，也不要凭空造一个头**。
+test("#539：非 session 首行不许把委派标记带进闸门", () => {
+  withDir((dir) => {
+    const sessions = join(dir, "sessions");
+    const captainDir = join(sessions, "ws", "captain");
+    mkdirSync(captainDir, { recursive: true });
+    const call = sessionLine({ turn: 1, calls: [skill("captain-skill")] });
+    // 首行是一条 permission/preset 记录，且 data 里带着委派标记——这一帧里
+    // 根本没有会话头，那两个字只是某条普通记录的字段。
+    const preset = JSON.stringify({ type: "permission/preset", seq: 0, time: 1, data: { origin: "subagent", delegationDepth: 1 } });
+    writeFileSync(join(captainDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(`${preset}\n${call}`)));
+
+    const automatic = createSessionGate({ sessionGateEnabled: true, sessionGateSubagents: true });
+    const read = readSessionObservations({ sessionDir: sessions, sessionGate: automatic });
+    assert.ok(
+      read.observations.some((item) => item.name === "captain-skill"),
+      "首行认不出头时不许凭它的字段判子代理——按 id 判、放行"
+    );
+
+    const manual = createSessionGate({ sessionGateEnabled: true, sessionGateSessions: ["captain"] });
+    const filtered = readSessionObservations({ sessionDir: sessions, sessionGate: manual });
+    assert.equal(filtered.observations.length, 0, "手动名单仍然按目录名里的精确 id 生效");
+  });
+});
+
 test("截断帧：半行被丢掉，不抛错、也不把半行当成一条记录", () => {
   withDir((dir) => {
     const sessions = join(dir, "sessions");

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/pipeline-runner.test.js

@@ -5,6 +5,7 @@ import { writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { createExecutionRecorder, projectRootOf, MAX_BUFFERED_EVENTS } from "../src/pipeline-runner.js";
 import { validatePipeline } from "../src/pipeline.js";
+import { createSessionGate } from "../src/session-gate.js";
 
 // 这组测试守的是串联层：把「事件 → 观察 → 归属 → 窗口 → 落盘」串起来的那一层。
 // 它最要紧的两条性质：
@@ -61,6 +62,31 @@ test("没开窗时一个字都不记：事件到了也不缓冲（这是整个
   assert.equal(rec.stop({ session }).reason, "no-open-window");
 });
 
+test("#539：无痕会话不开始、缓冲或结算执行记录", () => {
+  const f = fakeCtx();
+  const config = { sessionGateEnabled: false, sessionGateSessions: ["s-private"] };
+  const gate = createSessionGate(config);
+  let writes = 0;
+  const rec = createExecutionRecorder({
+    ctx: f.ctx,
+    sessionGate: gate,
+    resolvePipeline: () => PIPE,
+    persistRun: () => { writes += 1; }
+  });
+  const session = { id: "s-private", header: { cwd: "C:\\proj" } };
+
+  assert.equal(rec.start({ session, pipelineId: "demo" }).ok, true);
+  for (const event of callAndResult("npm test")) f.emit(session, event);
+  assert.equal(rec.stop({ session }).state, "awaiting-confirmation");
+
+  config.sessionGateEnabled = true;
+  assert.equal(rec.status({ session }).incognito, true);
+  assert.equal(rec.confirm({ session, answers: { P6: "done" } }).reason, "session-incognito");
+  config.sessionGateEnabled = false;
+  assert.deepEqual(rec.status({ session }), { open: false }, "gating discards both buffered and pending session data");
+  assert.equal(writes, 0, "incognito observation never reaches persistent run storage");
+});
+
 test("开窗 → 走一遍 → 结账：产出并落盘一条账", () => {
   const f = fakeCtx();
   let written = null;

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;