@modusensus/dsh-mneme 0.9.2 → 0.9.3

package/test/api-nudge-route.test.js

@@ -0,0 +1,259 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import zlib from "node:zlib";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+
+// /api/dsh-mneme/nudge 的接线锁。三件事分开守，因为它们混在一起时各自的失败长得一样：
+//   1. policy 是 token-write —— GET 免 token（面板每刷一次就 GET 一次），POST 要 token（会写盘）；
+//   2. 「读不到」与「确实没有」必须回不同状态码（503 vs 200），否则故障会被当成答案；
+//   3. GET 是预览、不许落盘 —— 这一条是接线时发现真 bug 的地方：nudgeFromSessions
+//      原先只要算得出项目键就无条件写提议，而面板刷新一次就是一次 GET。
+
+function tmpDir() {
+  return mkdtempSync(join(tmpdir(), "mneme-nudge-route-"));
+}
+
+async function withDir(fn) {
+  const dir = tmpDir();
+  try {
+    return await fn(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/** 一行会话日志，形状照 DSH 会话文件：data.message.content[] 里是 tool-call。 */
+function sessionLine(calls) {
+  const content = calls.map((c) => ({ type: "tool-call", name: c.name, arguments: JSON.stringify(c.args || {}) }));
+  return JSON.stringify({ time: 1700000000000, data: { turn: 1, message: { content } } });
+}
+
+/** 造一份会话日志：sessions/<桶>/<会话>/session.v4.jsonl.zstd，头行带 cwd。 */
+function writeSession(dshHome, { bucket, sessionId, cwd, calls }) {
+  const sub = join(dshHome, "sessions", bucket, sessionId);
+  mkdirSync(sub, { recursive: true });
+  const head = JSON.stringify({ time: 1700000000000, cwd });
+  const body = sessionLine(calls);
+  writeFileSync(join(sub, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from([head, body].join("\n"), "utf8")));
+}
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+/**
+ * POST 分支返回的是「已排进微任务的 promise」，不是自己的 promise：handler 直接
+ * `return;`（src/api.js:2069-2075）。所以拿到 FakeRes 不够，必须等它真的 end，
+ * 否则断言跑在正文还没写之前——第一次写这个文件就是在这里被 200 !== 400 骗了。
+ */
+function awaitEnd(res) {
+  return new Promise((resolve) => res.once("end", resolve));
+}
+
+function req(path, method = "GET", body = null, headers = {}) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = method;
+  r.headers = headers;
+  if (body !== null) {
+    process.nextTick(() => {
+      r.emit("data", Buffer.from(JSON.stringify(body)));
+      r.emit("end");
+    });
+  }
+  return r;
+}
+
+function setup({ apiToken = "", memoryDir = null } = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, commands, null, undefined, apiToken, { memoryDir });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/nudge");
+  assert.ok(route, "路由没注册");
+  return { route, store };
+}
+
+test("/nudge：policy 是 token-write —— GET 免 token，POST 要 token", async () => {
+  const { route } = setup({ apiToken: "secret-token" });
+
+  // GET 是预览（只读），与 /pipeline、/candidates 同级：不带 token 也要能读。
+  // 面板每次展开 M.O. 都会 GET 一次，要 token 等于让预览永远 401。
+  const get = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/nudge?project=relative"), get);
+  assert.notEqual(get.statusCode, 401, "GET 不该要 token");
+
+  // POST 会真写盘（落提议），一律受门控。没有这道闸，任何能打开面板的页面
+  // 都能往记忆库里塞文件。
+  const post = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/nudge?project=relative", "POST", {}), post);
+  assert.equal(post.statusCode, 401);
+  assert.equal(JSON.parse(post.body).error, "unauthorized");
+
+  // 带 token 才放行到业务判断（这里 project 是相对路径，应当由业务层回 400）。
+  const ok = new FakeRes();
+  const okDone = awaitEnd(ok);
+  route.handler(req("/api/dsh-mneme/nudge?project=relative", "POST", {}, { authorization: "Bearer secret-token" }), ok);
+  await okDone;
+  assert.equal(ok.statusCode, 400);
+});
+
+test("/nudge：project 必须是绝对路径，相对路径拒掉而不是静默退成全局", async () => {
+  // 与 /pipeline、/candidates 同一条规矩。忽略相对路径会静默退成「全局」，
+  // 而全局看起来一切正常——那是最难查的一类错。
+  return withDir((dir) => {
+    const { route } = setup({ memoryDir: join(dir, "memory") });
+    const res = new FakeRes();
+    route.handler(req("/api/dsh-mneme/nudge?project=dsh-mneme", "GET"), res);
+    assert.equal(res.statusCode, 400);
+    assert.equal(JSON.parse(res.body).error, "project-not-absolute");
+  });
+});
+
+test("/nudge：「读不到会话」回 503，「这个项目确实没有」回 200", async () => {
+  // 两者在候选列表上都表现为空。混成一个状态码，调用方就只能瞎猜是「没东西」还是「坏了」。
+  await withDir((dir) => {
+    const projectRoot = join(dir, "proj");
+    mkdirSync(projectRoot, { recursive: true });
+    const { route } = setup({ memoryDir: join(dir, "memory") });
+
+    const prev = process.env.DSH_HOME;
+    // 会话根根本不存在 → 新机器 / 路径配错，是**环境问题**。
+    process.env.DSH_HOME = join(dir, "home-missing");
+    try {
+      const broken = new FakeRes();
+      route.handler(req("/api/dsh-mneme/nudge?project=" + encodeURIComponent(projectRoot), "GET"), broken);
+      assert.equal(broken.statusCode, 503);
+      const brokenDoc = JSON.parse(broken.body);
+      assert.equal(brokenDoc.error, "nudge-sessions-unreadable");
+      assert.equal(brokenDoc.skipped, true);
+      assert.equal(brokenDoc.counts.candidates, 0);
+
+      // 有一个桶，但 cwd 指向别处 → 关于这个项目的**答案**：它还没跑过会话。
+      const home = join(dir, "home-other");
+      writeSession(home, {
+        bucket: "other-bucket",
+        sessionId: "sess-x",
+        cwd: join(dir, "somewhere-else"),
+        calls: [{ name: "skill", args: { name: "alpha" } }]
+      });
+      process.env.DSH_HOME = home;
+      const none = new FakeRes();
+      route.handler(req("/api/dsh-mneme/nudge?project=" + encodeURIComponent(projectRoot), "GET"), none);
+      assert.equal(none.statusCode, 200);
+      const noneDoc = JSON.parse(none.body);
+      assert.equal(noneDoc.skipped, true);
+      assert.equal(noneDoc.skippedReason, "no-session-attribution");
+      assert.equal(noneDoc.attribution.reason, "no-bucket");
+      // 跳过与跑完必须是同一句边界话术（同一个 NUDGE_BOUNDARIES 常量）。
+      assert.equal(noneDoc.boundaries.autoActivate, false);
+      assert.equal(noneDoc.boundaries.writesOnlyDrafts, true);
+    } finally {
+      if (prev === undefined) delete process.env.DSH_HOME;
+      else process.env.DSH_HOME = prev;
+    }
+  });
+});
+
+test("/nudge：GET 只预览不落盘，POST 才写提议；materialize 默认关", async () => {
+  // 这条是接线时抓到的真 bug：nudgeFromSessions 原先只要算得出项目键就无条件
+  // 写提议，而面板每刷一次就 GET 一次 —— 等于每刷新一次往记忆库塞一批文件。
+  await withDir(async (dir) => {
+    const projectRoot = join(dir, "proj");
+    mkdirSync(projectRoot, { recursive: true });
+    const memoryDir = join(dir, "memory");
+    const dshHome = join(dir, "dsh-home");
+    const calls = [
+      { name: "skill", args: { name: "alpha" } },
+      { name: "skill", args: { name: "beta" } },
+      { name: "pwsh", args: { command: "npm test" } }
+    ];
+    writeSession(dshHome, { bucket: "ws-bucket", sessionId: "sess-a", cwd: projectRoot, calls });
+    // 两个会话走同一段序列才够 NUDGE_MIN_SUPPORT=2（数的是会话，不是次数）。
+    writeSession(dshHome, { bucket: "ws-bucket", sessionId: "sess-b", cwd: projectRoot, calls });
+
+    const prev = process.env.DSH_HOME;
+    process.env.DSH_HOME = dshHome;
+    try {
+      const { route } = setup({ memoryDir });
+
+      const preview = new FakeRes();
+      await route.handler(req("/api/dsh-mneme/nudge?project=" + encodeURIComponent(projectRoot), "GET"), preview);
+      assert.equal(preview.statusCode, 200);
+      const previewDoc = JSON.parse(preview.body);
+      assert.equal(previewDoc.skipped, false);
+      assert.equal(previewDoc.attribution.reason, "matched");
+      assert.ok(previewDoc.counts.candidates >= 1, "真数据里必须挖得出候选");
+      assert.equal(previewDoc.counts.savedProposals, 0, "预览不许落提议");
+      assert.equal(existsSync(join(memoryDir, "proposals")), false);
+
+      const real = new FakeRes();
+      const realDone = awaitEnd(real);
+      route.handler(req("/api/dsh-mneme/nudge?project=" + encodeURIComponent(projectRoot), "POST", {}), real);
+      await realDone;
+      assert.equal(real.statusCode, 200);
+      const realDoc = JSON.parse(real.body);
+      assert.equal(realDoc.counts.savedProposals, realDoc.counts.candidates);
+      assert.ok(existsSync(realDoc.proposalsDir));
+      // 落草稿是「往仓库里塞文件」，必须 body.materialize===true 才做；自动跑的
+      // 默认语义就是不碰仓库，端点必须与它一致。
+      assert.equal(realDoc.counts.draftsWritten, 0);
+      assert.equal(existsSync(join(projectRoot, ".mneme", "pipelines")), false);
+    } finally {
+      if (prev === undefined) delete process.env.DSH_HOME;
+      else process.env.DSH_HOME = prev;
+    }
+  });
+});
+
+test("/nudge：PATCH/DELETE 一律 405，绝不落进「不是 GET/HEAD 就算写」的分支", async () => {
+  // 这条是从评审里捞出来的真洞：persistProposals 按「method !== GET && !== HEAD」算，
+  // 而方法分流只拦 PUT/POST，于是带 token 的 PATCH/DELETE 会直落 run(null)、
+  // 当成写动作往 memoryDir 里落提议——一个不需要 body 的静默写盘口，正好打在
+  // 这个端点「GET 只预览、写动作一律要 POST」的卖点上。
+  await withDir(async (dir) => {
+    const projectRoot = join(dir, "proj");
+    mkdirSync(projectRoot, { recursive: true });
+    const memoryDir = join(dir, "memory");
+    const dshHome = join(dir, "dsh-home");
+    const calls = [
+      { name: "skill", args: { name: "alpha" } },
+      { name: "skill", args: { name: "beta" } }
+    ];
+    writeSession(dshHome, { bucket: "ws-bucket", sessionId: "sess-a", cwd: projectRoot, calls });
+    writeSession(dshHome, { bucket: "ws-bucket", sessionId: "sess-b", cwd: projectRoot, calls });
+
+    const prev = process.env.DSH_HOME;
+    process.env.DSH_HOME = dshHome;
+    try {
+      const { route } = setup({ apiToken: "secret-token", memoryDir });
+      for (const verb of ["PATCH", "DELETE"]) {
+        const res = new FakeRes();
+        // 带合法 token：证明拦住它的是方法白名单，不是鉴权。
+        await route.handler(req("/api/dsh-mneme/nudge?project=" + encodeURIComponent(projectRoot), verb, {}, { authorization: "Bearer secret-token" }), res);
+        assert.equal(res.statusCode, 405, verb + " 必须回 405");
+        const doc = JSON.parse(res.body);
+        assert.equal(doc.error, "method-not-allowed");
+        assert.equal(doc.allow, "GET, HEAD, POST, PUT");
+        assert.equal(res.headers?.Allow, "GET, HEAD, POST, PUT", "405 要带 Allow 头");
+      }
+      // 最硬的一条：这里必须**一个文件都没落**。只看状态码会漏掉「先写再报错」。
+      assert.equal(existsSync(join(memoryDir, "proposals")), false, "PATCH/DELETE 不许落提议");
+    } finally {
+      if (prev === undefined) delete process.env.DSH_HOME;
+      else process.env.DSH_HOME = prev;
+    }
+  });
+});

package/test/api.test.js

@@ -747,7 +747,8 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // 两个都是嵌套对象子字段，都进 NESTED_FLAG_PATHS）。
   // 合并 #451（人格页）后的真实计数：98（本批前）+ actionRunEnabled + personaEnabled = 99
   // #471 再 + 2 = 101。
-  assert.equal(Object.keys(data.effective).length, 101);
+  // v0.9.3 新增 actionNudgeEnabled（M.O. 自动沉淀；顶层扁平键）= 102。
+  assert.equal(Object.keys(data.effective).length, 102);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMergeGuard, true);
@@ -792,6 +793,10 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(data.effective.actionRunEnabled, false);
   // 人格页（beta）：注入总闸默认关，effective 必须能读到（同 #254 坑形防线）。
   assert.equal(data.effective.personaEnabled, false);
+  // v0.9.3：M.O. 自动沉淀的第三个键。与 actionPipelineEnabled（看图）、
+  // actionRunEnabled（记账）都不是一件事——它挂 session/event 并解压会话日志，
+  // 是三者里最重的一条，所以独立开关、默认关、且进 LIGHT_MODE_OFF。
+  assert.equal(data.effective.actionNudgeEnabled, false);
   // 新增字符串 / URL / 枚举键
   assert.equal(data.effective.localEmbedModel, "Xenova/bge-small-zh-v1.5");
   assert.equal(data.effective.ollamaBaseUrl, "http://localhost:11434");

package/test/client.test.js

@@ -1926,13 +1926,51 @@ test("M.O. empty-state, list and scope copy exist in both languages", () => {
     "memory.actions.scope.project",
     "memory.actions.scope.global",
     "memory.actions.scope.none",
-    "memory.actions.broken"
+    "memory.actions.broken",
+    // 手动沉淀的全部回执：这八句里缺任何一句，按钮点下去就是一行 key 裸奔，
+    // 而那恰好是「点了没反应」的观感来源。
+    "memory.actions.distill.action",
+    "memory.actions.distill.busy",
+    "memory.actions.distill.hint",
+    "memory.actions.distill.noProject",
+    "memory.actions.distill.saved",
+    "memory.actions.distill.none",
+    "memory.actions.distill.noSessions",
+    "memory.actions.distill.unreadable",
+    "memory.actions.distill.failed"
   ]) {
     const hits = (clientSource.match(new RegExp(`"${key.replace(/\./g, "\\.")}":`, "g")) || []).length;
     assert.equal(hits, 2, `${key} must exist in both zh and en (got ${hits})`);
   }
 });
 
+// 手动沉淀按钮：面板上「立即跑一次」的唯一入口。锁三件事，每件都对应一种会静默坏掉的情形：
+//   ① 它必须打 POST 且带上项目根——GET 是预览、不写盘，打成 GET 就成了「点了永远 0 条」；
+//   ② materialize 不许出现：按钮只产提议，落草稿是另一个决定；
+//   ③ 没有 project 时必须禁用——服务端只会回 400，点了必然失败的按钮比没有按钮更糟。
+test("M.O. pane offers a manual distill that posts the project root", () => {
+  const bodyOf = (name) => {
+    const start = clientSource.indexOf(`function ${name}(`);
+    assert.ok(start > -1, `${name} must exist`);
+    const next = clientSource.slice(start + 1).indexOf("\n    function ");
+    return clientSource.slice(start, next > -1 ? start + 1 + next : clientSource.length);
+  };
+  const bar = bodyOf("PipelineDistillButton");
+  assert.ok(bar.includes('"/api/dsh-mneme/nudge?project="'), "the button must hit the nudge route");
+  assert.ok(bar.includes("encodeURIComponent(project)"), "the project root must travel with the request");
+  assert.ok(bar.includes('method: "POST"'), "a preview GET writes nothing — the button must POST");
+  assert.ok(!bar.includes("materialize"), "the button must never materialize a draft");
+  assert.ok(bar.includes("!project"), "the button must be disabled when the project is unknown");
+  assert.ok(bar.includes("503"), "an unreadable session log must be told apart from an empty result");
+  // 座位：按钮挂在清单头上，且清单要拿到 project——漏传的话按钮永远禁用，
+  // 界面上看起来只是「这个功能没做好」。
+  assert.ok(bodyOf("PipelineWorkflowList").includes("PipelineDistillButton"), "the control belongs in the list header");
+  assert.ok(
+    bodyOf("PipelineBrowser").includes("activeId, onOpen: setPicked, project }"),
+    "the browser must hand the project root down to the list"
+  );
+});
+
 // 画布能放大缩小。锁的重点不是「有没有缩放」，而是滚轮那一条必须**自己挂非被动监听**：
 // React 的 onWheel 挂在 root 上且是 passive 的，preventDefault 会被浏览器忽略，
 // 于是 Ctrl+滚轮既缩放画布又缩放整页，谁也没拦住——这个错本地测不出来，只在真浏览器里响。

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

@@ -0,0 +1,224 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createNudgeAutoRun } from "../src/pipeline-nudge-auto.js";
+
+// 这组守的是**触发侧**（v0.9.3）：什么时候跑、跑几次、跑挂了怎么办。
+// 挖掘算法本身在 pipeline-nudge.test.js 里守，这里只守接线，所以 runNudge 全部用假的。
+
+/** 一个假 ctx：只提供 session/event 的订阅面（真宿主用同一个口）。 */
+function fakeCtx() {
+  const listeners = [];
+  return {
+    logger: { info() {}, warn() {} },
+    on(name, fn) {
+      if (name !== "session/event") throw new Error("unexpected event: " + name);
+      listeners.push(fn);
+      return () => {
+        const i = listeners.indexOf(fn);
+        if (i >= 0) listeners.splice(i, 1);
+      };
+    },
+    emit(session, event) {
+      for (const fn of listeners.slice()) fn(session, event);
+    },
+    count: () => listeners.length
+  };
+}
+
+function sessionAt(cwd) {
+  return { header: { cwd } };
+}
+
+/** 把 setTimeout(0) 排的活跑完：本模块刻意不用同步跑（见文件头）。 */
+function tick(ms = 5) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * 等到条件成立。队列是**链式**排程（跑完一个再 defer 下一个），所以「两个项目都跑完」
+ * 至少要等两个宏任务;固定 tick(30) 在满载的 CI 上会假阴性——全量跑时其它测试文件
+ * 同时解压 zstd，一次 setTimeout(0) 被拉长就可能超过 30ms。这里只等该等的东西。
+ */
+async function waitFor(predicate, timeout = 2000) {
+  const started = Date.now();
+  while (!predicate()) {
+    if (Date.now() - started > timeout) return false;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  return true;
+}
+
+test("自动沉淀只认 turn/end：中途事件不排队、不预跑", async () => {
+  const ctx = fakeCtx();
+  const calls = [];
+  const auto = createNudgeAutoRun({
+    ctx,
+    runNudge: (args) => { calls.push(args); return { counts: { savedProposals: 0 } }; },
+    now: () => 1_000_000
+  });
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/start" });
+  ctx.emit(sessionAt("D:/proj"), { type: "message" });
+  await tick();
+  assert.deepEqual(calls, [], "一轮没结束就不是观测窗口");
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  await tick();
+  assert.equal(calls.length, 1);
+  auto();
+});
+
+test("自动跑永远是「只落提议、不落草稿」：materialize 恒 false", async () => {
+  const ctx = fakeCtx();
+  const calls = [];
+  const auto = createNudgeAutoRun({
+    ctx,
+    memoryDir: "D:/memory",
+    runNudge: (args) => { calls.push(args); return { counts: { savedProposals: 0 } }; },
+    now: () => 1_000_000
+  });
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  await tick();
+  assert.equal(calls.length, 1);
+  // 这三条是边界，不是偏好：往别人仓库里塞文件必须是人的显式动作。
+  assert.equal(calls[0].materialize, false, "自动跑不许落草稿");
+  assert.equal(calls[0].persistProposals, true, "提议要落进记忆库");
+  assert.equal(calls[0].memoryDir, "D:/memory");
+  auto();
+});
+
+test("同一个项目在冷却期内不重跑（观测新鲜度，不是防重复写盘）", async () => {
+  const ctx = fakeCtx();
+  const calls = [];
+  let clock = 1_000_000;
+  const auto = createNudgeAutoRun({
+    ctx,
+    runNudge: (args) => { calls.push(args); return { counts: { savedProposals: 0 } }; },
+    now: () => clock,
+    minIntervalMs: 10_000
+  });
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  await tick();
+  assert.equal(calls.length, 1);
+  // 冷却期内：再来几轮也不跑。
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  await tick();
+  assert.equal(calls.length, 1, "十分钟内同一个项目只跑一次");
+  // 过了冷却就该跑。
+  clock += 20_000;
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  await tick();
+  assert.equal(calls.length, 2);
+  auto();
+});
+
+test("冷却按项目分账：另一个项目不受影响，也不许并成一次", async () => {
+  const ctx = fakeCtx();
+  const roots = [];
+  const auto = createNudgeAutoRun({
+    ctx,
+    runNudge: (args) => { roots.push(args.projectRoot); return { counts: { savedProposals: 0 } }; },
+    now: () => 1_000_000,
+    minIntervalMs: 10_000
+  });
+  ctx.emit(sessionAt("D:/a"), { type: "turn/end" });
+  ctx.emit(sessionAt("D:/b"), { type: "turn/end" });
+  assert.ok(await waitFor(() => roots.length === 2), "两个项目都该被跑到");
+  assert.deepEqual(roots.sort(), ["D:/a", "D:/b"], "两个项目各跑一次，跨项目不并账");
+  auto();
+});
+
+test("冷却键不区分大小写与尾斜杠（Windows 同一个项目别算成两个）", async () => {
+  const ctx = fakeCtx();
+  const calls = [];
+  let clock = 1_000_000;
+  const auto = createNudgeAutoRun({
+    ctx,
+    runNudge: (args) => { calls.push(args); return { counts: { savedProposals: 0 } }; },
+    now: () => clock,
+    minIntervalMs: 10_000
+  });
+  ctx.emit(sessionAt("D:/Proj"), { type: "turn/end" });
+  await tick();
+  ctx.emit(sessionAt("d:\\proj\\"), { type: "turn/end" });
+  await tick();
+  assert.equal(calls.length, 1, "同一个项目换个写法不该被当成新项目");
+  auto();
+});
+
+test("挖挂了不许冒泡：session/event 那条链上还挂着摘要与续期", async () => {
+  const ctx = fakeCtx();
+  let ran = 0;
+  const auto = createNudgeAutoRun({
+    ctx,
+    logger: { info() {}, warn() {} },
+    runNudge: () => { ran += 1; throw new Error("boom"); },
+    now: () => 1_000_000
+  });
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  await assert.doesNotReject(tick().then(() => {}), "定时回调里的异常不许掀翻宿主");
+  assert.equal(ran, 1);
+  auto();
+});
+
+test("没有 cwd 的会话不排队（归属不明就别猜）", async () => {
+  const ctx = fakeCtx();
+  const calls = [];
+  const auto = createNudgeAutoRun({
+    ctx,
+    runNudge: (args) => { calls.push(args); return { counts: { savedProposals: 0 } }; },
+    now: () => 1_000_000
+  });
+  ctx.emit({ header: {} }, { type: "turn/end" });
+  ctx.emit(null, { type: "turn/end" });
+  await tick();
+  assert.deepEqual(calls, []);
+  assert.equal(auto.pendingCount(), 0);
+  auto();
+});
+
+test("dispose 之后：取消订阅、清掉排队的活，runNow 也不再跑", async () => {
+  const ctx = fakeCtx();
+  const calls = [];
+  const auto = createNudgeAutoRun({
+    ctx,
+    runNudge: (args) => { calls.push(args); return { counts: { savedProposals: 0 } }; },
+    now: () => 1_000_000
+  });
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  auto();
+  assert.equal(ctx.count(), 0, "订阅必须被摘掉");
+  assert.equal(auto.pendingCount(), 0, "排队的活必须被清掉");
+  await tick();
+  // 关键：dispose 之前排进 timer 的那一次也不许再跑（否则卸载后还会写盘）。
+  assert.deepEqual(calls, [], "卸载之后不许还有一次偷偷的写盘");
+  assert.equal(auto.runNow("D:/proj"), null);
+  assert.deepEqual(calls, []);
+  // 再发事件也不排队了。
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  await tick();
+  assert.deepEqual(calls, []);
+});
+
+test("runNow 绕开冷却与 timer，手动入口可以直接驱动一次", () => {
+  const ctx = fakeCtx();
+  const calls = [];
+  const auto = createNudgeAutoRun({
+    ctx,
+    runNudge: (args) => { calls.push(args); return { counts: { savedProposals: 0 } }; },
+    now: () => 1_000_000,
+    minIntervalMs: 10_000
+  });
+  const doc = auto.runNow("D:/proj");
+  assert.ok(doc, "手动入口要有同步回执");
+  assert.equal(calls.length, 1);
+  // runNow 刻意**不走冷却**：它是人显式要的一次跑，人比定时器知道自己要什么。
+  assert.ok(auto.runNow("D:/proj"));
+  assert.equal(calls.length, 2);
+  // 但它要把时间记上——否则紧接着的自动跑会立刻再来一次。
+  assert.equal(typeof auto.lastRunAt("D:/proj"), "number");
+  ctx.emit(sessionAt("D:/proj"), { type: "turn/end" });
+  return tick().then(() => {
+    assert.equal(calls.length, 2, "runNow 之后冷却生效，自动跑不许立刻重跑");
+    auto();
+  });
+});