@modusensus/dsh-mneme 0.9.5 → 0.10.0

package/test/mint-source.test.js

@@ -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-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/prompt-stance.test.js

@@ -0,0 +1,128 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { STR } from "../src/lang.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+
+// 防谄媚的**提示词侧**回归锁。
+//
+// 背景：#380 的注入前判定（pre-inject-gate）只拦「已落库的意见/立场」，而落到库里
+// 之前的两个写作环节——蒸馏（summary / codingSummary）与总览叙述（dreamSummary）
+// ——此前对谄媚内容一字未提。这两个环节写出的内容**完全不过** writeAdmission
+// （write-admission.js 只在带 sessionKey 的 memory_save 路径生效），所以提示词是
+// 唯一能施加约束的地方，本轮把「立场纪律 / 叙述纪律」写进字面量（Issue #530）。
+//
+// 这些用例锁的是**形状**（提示词里有没有这条约束、位置对不对），锁不了**行为**
+// （模型是否真的照做）——后者要 LLM 在环 + 预注册判据，属 E12 那类实验，不在单测里
+// 宣称。PR 与 CHANGELOG 不得把本文件写成「已知降低谄媚率」。
+
+const LANGS = ["zh", "en"];
+
+// 五组判据在两种语言里的对应词。写成「中英成对」是刻意的：少一种语言就等于
+// 换语言的用户拿到一份没有防线的提示词（同 lang.test.js 对 profileExtract 的锁法）。
+const STANCE_PATTERNS = [
+  [/立场纪律|Stance discipline/, "立场纪律小节本身"],
+  [/不要记录对用户本人|Never record evaluations of the user/, "规则 a：不记对用户本人的性格/能力/情绪评价"],
+  [/可信度不同|differ in trustworthiness/, "规则 b：转录三种角色可信度不同"],
+  [/事实归属以用户陈述为准|the user statement wins on the facts/, "规则 c：事实归属不记成助手推断"],
+  [/如实并存|keep both sides/, "规则 c：两种说法并存，不写成谁对谁错"],
+  [/不是提高 importance 的理由|never a reason to raise it/, "规则 d：赞许不抬 importance"],
+];
+
+for (const key of ["summary", "codingSummary"]) {
+  test(`${key} 提示词带完整立场纪律（中英成对）`, () => {
+    for (const lang of LANGS) {
+      const text = STR.prompts[key][lang];
+      for (const [re, label] of STANCE_PATTERNS) {
+        assert.match(text, re, `${key}.${lang} 缺少${label}`);
+      }
+    }
+  });
+}
+
+test("立场纪律排在任何 JSON 输出形状之前，不会被后置的时间锚点覆盖", () => {
+  // summarize.js 在提示词**之后**再拼 STR.distillTimeAnchor（「据此换算 occurred_at」）。
+  // 规则若排在那句之后，就成了「先按时间换算、再谈记什么」——指令优先级反了。
+  // 同时它必须排在 schema 行之前：schema 是输出形状，纪律是内容判据，形状压不住判据。
+  for (const key of ["summary", "codingSummary"]) {
+    for (const lang of LANGS) {
+      const text = STR.prompts[key][lang];
+      const stance = text.search(/立场纪律|Stance discipline/);
+      assert.ok(stance > 0, `${key}.${lang}: 立场纪律必须存在于提示词字面量内部`);
+      assert.ok(stance < text.search(/occurred_at|occurred_at/), `${key}.${lang}: 立场纪律必须在 occurred_at 说明之前`);
+      assert.ok(stance < text.search(/只输出 JSON 数组|Output only a JSON array/), `${key}.${lang}: 立场纪律必须在输出形状之前`);
+      assert.ok(text.indexOf("立场纪律") < 0 || stance > text.indexOf("原子记忆原则") - 1,
+        `${key}.${lang}: 立场纪律要跟在原子记忆原则之后，别抢掉开头角色句`);
+    }
+  }
+});
+
+test("工具/报错结论的豁免条款必须在场（删掉它会误杀 pitfall 与 constraint）", () => {
+  // 规则 b 说「助手的结论是推断」，但编码类记忆（pitfall / rejected_solution /
+  // constraint）的内容本来就是工具输出与报错直接给出的技术结论。没有这半句豁免，
+  // 规则 b 会把整个编码回溯功能一并否掉——这是最容易被后人顺手删掉的高危句。
+  for (const lang of LANGS) {
+    const text = STR.prompts.summary[lang];
+    assert.match(text, /工具输出、报错、命令结果|tool output, errors or command results/,
+      `summary.${lang}: 工具结论豁免条款缺失，规则 b 会误杀 pitfall/constraint`);
+  }
+});
+
+test("dreamSummary 带叙述纪律，且散文契约不被破坏", () => {
+  for (const lang of LANGS) {
+    const text = STR.prompts.dreamSummary[lang];
+    assert.match(text, /叙述纪律|Narrative discipline/, `dreamSummary.${lang}: 缺叙述纪律`);
+    assert.match(text, /不要给用户添上|add no characterisation/, `dreamSummary.${lang}: 缺「不给用户添性格评价」`);
+    // 总览是**散文**契约：dream-fence 那条锁要求这里绝不能出现「JSON 数组」，
+    // 否则模型会按数组契约回 `[]`，而 summaryText.trim() 判非空通过，`[]` 就
+    // 被当成摘要存进库（dream.js:326-328 的注释记着这次评审实测）。
+    assert.doesNotMatch(text, /JSON 数组|JSON array/, `dreamSummary.${lang}: 散文契约里不得出现 JSON 数组`);
+    // 硬输出格式锁必须留在末尾，它是「只回叙述文本」的唯一保证。
+    assert.match(lang === "zh" ? text : text, /只输出叙述文本，不要其他内容。|Output only the narrative text, nothing else./,
+      `dreamSummary.${lang}: 末尾输出格式锁丢了`);
+  }
+});
+
+// 下面这条是**输出侧**的接线锁：提示词改了，落库判据不能跟着变。
+// 空字符串仍必须判为「没有摘要」（degraded/noop），不能被新文案带成「存了个空叙述」。
+test("总览落库判据不因提示词改动而放宽", async () => {
+  function mockCtx({ summaryText }) {
+    return {
+      logger: { warn: () => {} },
+      agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+      llm: {
+        async *stream(options) {
+          const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+          if (userText.includes("| type=")) {
+            yield { type: "block-start", index: 0, blockType: "text" };
+            yield { type: "text-delta", index: 0, text: "[]" };
+            yield { type: "block-end", index: 0, block: { type: "text" } };
+            yield { type: "finish", reason: { kind: "stop" } };
+            return;
+          }
+          yield { type: "text-delta", index: 0, text: summaryText };
+          yield { type: "finish", reason: { kind: "stop" } };
+        }
+      }
+    };
+  }
+
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文", importance: 3 });
+
+  const ok = await dream.runDream(mockCtx({ summaryText: "记忆库总览：用户偏好中文。" }), service, {});
+  assert.equal(ok.summary, true, "非空叙述照常落库");
+  const row = service.all().find((m) => m.type === "summary");
+  assert.ok(row, "总览行必须存在");
+  assert.equal(row.source, "dream");
+  assert.equal(row.importance, 5, "总览行的 importance 固定 5（最高注入档）");
+
+  const empty = await dream.runDream(mockCtx({ summaryText: "" }), service, {});
+  assert.equal(empty.summary, false, "空叙述不得落库");
+  const rows = service.all().filter((m) => m.type === "summary");
+  assert.equal(rows.length, 1, "旧总览存活，没有被空叙述覆盖");
+  store.close();
+});