@modusensus/dsh-mneme 0.9.1 → 0.9.3

package/src/store.js

@@ -2,6 +2,15 @@ import { DatabaseSync } from "node:sqlite";
 import { randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
 import { contentHashOf } from "./content-hash.js";
+// 政策轴（issue #471）的归一化函数。刻意只取归一化，不取判定：判定（buildPausedIndex /
+// matchPausedScopes / createScopeStateGate）留在 scope-state.js，由 service 侧消费，
+// 存储层只管「一格状态怎么落」。依赖方向 store → scope-state → scope 是单向的
+// （scope.js 不 import 任何本包模块），所以不构成环。
+import {
+  normalizeScopeStateDimension,
+  normalizeScopeStateState,
+  normalizeScopeStateValue
+} from "./scope-state.js";
 
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS memories (
@@ -185,6 +194,25 @@ CREATE TABLE IF NOT EXISTS scope_changes (
 );
 CREATE INDEX IF NOT EXISTS idx_scope_changes_memory ON scope_changes(memory_id);
 
+-- scope_state: v0.9.1 政策轴（issue #471）。与 scope_changes 那条事实轴相对：
+-- scope_changes 记「某条记忆的归属被人工改过」（跟着记忆走），本表记「某个作用域
+-- 现在通不通」（跟着作用域走）。按下/松开都是单方面动作，不触碰任何记忆行，
+-- 松开即恢复——所以它是可逆的，而逐条 forget/archive 不是。
+-- dimension 只认 'agent'|'workspace'（scopeKeyOf 那两个维度）；scope_value='*'
+-- 表示该维度全局。一行一格，重复按下同一状态不刷新 decided_at（见 setScopeState）。
+-- Bookkeeping like the other audit tables: it never triggers write hooks.
+CREATE TABLE IF NOT EXISTS scope_state (
+  id           TEXT PRIMARY KEY,
+  dimension    TEXT NOT NULL,
+  scope_value  TEXT NOT NULL,
+  state        TEXT NOT NULL,               -- active | paused
+  note         TEXT,
+  decided_at   TEXT NOT NULL
+);
+-- 唯一性靠独立索引（本仓惯例：UNIQUE 不进 CREATE TABLE，见 idx_memory_provenance_link）。
+-- 它同时是 setScopeState 那条 UPSERT 的冲突目标，所以不能省。
+CREATE UNIQUE INDEX IF NOT EXISTS idx_scope_state_key ON scope_state(dimension, scope_value);
+
 -- llm_audit_logs: every background LLM call (autoDream consolidation + summary,
 -- autoSummarize compression) is recorded here — tokens in/out, duration, status
 -- and the trigger that caused it (Bug8). Failures are captured as status='error'
@@ -604,6 +632,20 @@ function toScopeChange(row) {
   };
 }
 
+// scope_state 行 → 读侧对象（issue #471）。NULL note 落 undefined，与
+// toScopeChange 同口径。
+function toScopeState(row) {
+  if (!row) return undefined;
+  return {
+    id: row.id,
+    dimension: row.dimension,
+    scope_value: row.scope_value,
+    state: row.state,
+    note: row.note ?? undefined,
+    decided_at: row.decided_at
+  };
+}
+
 function toRecallRun(row) {
   if (!row) return undefined;
   return {
@@ -1733,6 +1775,32 @@ export function createStore(path) {
     ).all();
   }
 
+  /**
+   * Per-dimension counts over active embedded rows ('' = vector that failed to
+   * parse as an array — legacy garbage rows, not a real dimension).
+   *
+   * Why per-dimension: embeddedCount() alone says "has a vector", but vectors
+   * written by a different model/dimension are not comparable with the current
+   * query embedding — searchVector skips them, so they are "present" without
+   * being "retrievable". The status card needs this split to stop reporting a
+   * coverage number that silently counts unsearchable rows.
+   */
+  function embeddingDimensionBreakdown() {
+    return db.prepare(
+      `SELECT id, embedding FROM memories
+        WHERE embedding IS NOT NULL AND embedding != ''
+          AND forgotten = 0 AND archived = 0`
+    ).all().reduce((acc, row) => {
+      let dim = "";
+      try {
+        const parsed = JSON.parse(row.embedding);
+        dim = Array.isArray(parsed) ? String(parsed.length) : "";
+      } catch { /* unparseable vector counts under "" */ }
+      acc.set(dim, (acc.get(dim) ?? 0) + 1);
+      return acc;
+    }, new Map());
+  }
+
   function search(query, { limit = 20, includeArchived = false } = {}) {
     const q = String(query).trim();
     if (!q) return [];
@@ -1789,6 +1857,11 @@ export function createStore(path) {
     for (const row of rows) {
       const v = getParsedEmbedding(row.id);
       if (!v) continue;
+      // distill-tx-embed-gap 顺带修：维度不匹配的行按维度分流，直接跳过。旧路径
+      // 喂进 cosine 不等长就 return 0，换了模型/维度的旧向量以 0 分混进结果尾部
+      // （threshold 默认 0 时照样入选），检索方拿到的分数是跨向量空间的假值。
+      // 不等长的向量对本次查询没有可比分数，跳过是唯一诚实的处置。
+      if (v.length !== vector.length) continue;
       const score = cosine(vector, v);
       if (score >= threshold) scored.push({ row: { id: row.id }, score });
     }
@@ -2609,6 +2682,66 @@ export function createStore(path) {
     return rows.map(toScopeChange);
   }
 
+  /**
+   * 政策轴（issue #471）：按下或松开一个作用域。一行一格，靠
+   * idx_scope_state_key(dimension, scope_value) 做 UPSERT——重复按下同一状态
+   * 不刷新 decided_at（CASE WHEN），因为「第一次按下的时刻」才是回执该报的东西；
+   * 状态翻转则刷新，那是一次真的决策。
+   *
+   * note 的取舍与 decided_at 相反：非空的新 note 总是覆盖旧的，空的则原样留着。
+   * 理由是这条记录里「当前通不通」由 state 那一列承担，note 是**理由**——理由被
+   * 一次不带理由的重按抹掉是净损失（用户回看时只会看到「按下过」却不知道为什么），
+   * 而「清空理由」不是一个真实需求（要改就再按一次带上新理由）。这与本仓防御段
+   * 「宁可留着也不要静默丢」的取向一致。
+   *
+   * 归一化失败（维度/值/状态任一非法）返回 undefined，由调用方拒绝——本表只存
+   * 可解释的三种枚举，与 memories 的 scope 列不同：那里脏输入落 NULL 是正当的
+   * （「未标注」本身有语义），这里落 NULL 没有任何意思，会静默变成一行永远不
+   * 生效的状态。
+   */
+  function setScopeState({ dimension, scope_value, state, note, decided_at }) {
+    const dim = normalizeScopeStateDimension(dimension);
+    const val = normalizeScopeStateValue(scope_value);
+    const st = normalizeScopeStateState(state);
+    if (!dim || !val || !st) return undefined;
+    const at = normalizeOccurredAt(decided_at) ?? nowIso();
+    const noteText = normalizeScopeText(note);
+    db.prepare(
+      `INSERT INTO scope_state (id, dimension, scope_value, state, note, decided_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(dimension, scope_value) DO UPDATE SET
+         state = excluded.state,
+         note = COALESCE(excluded.note, scope_state.note),
+         decided_at = CASE WHEN scope_state.state = excluded.state THEN scope_state.decided_at ELSE excluded.decided_at END`
+    ).run(randomUUID(), dim, val, st, noteText, at);
+    return toScopeState(
+      db.prepare("SELECT * FROM scope_state WHERE dimension = ? AND scope_value = ?").get(dim, val)
+    );
+  }
+
+  /** 政策轴状态行（单格）。 */
+  function getScopeState(dimension, scope_value) {
+    const dim = normalizeScopeStateDimension(dimension);
+    const val = normalizeScopeStateValue(scope_value);
+    if (!dim || !val) return undefined;
+    return toScopeState(
+      db.prepare("SELECT * FROM scope_state WHERE dimension = ? AND scope_value = ?").get(dim, val)
+    );
+  }
+
+  /**
+   * 政策轴状态行（全量）。不提供按维度/值过滤的参数——闸门判定要的就是全量
+   * （一次现读一次索引），过滤留到 scope-state.js 的 buildPausedIndex 里做。
+   * 排 decided_at DESC + rowid DESC 同 listScopeChanges（毫秒精度同毫秒写入
+   * 时 UUID 排序随机，回执要报「最近一次决策」就得有确定的次键）。
+   */
+  function listScopeStates({ state } = {}) {
+    const rows = state
+      ? db.prepare("SELECT * FROM scope_state WHERE state = ? ORDER BY decided_at DESC, rowid DESC").all(state)
+      : db.prepare("SELECT * FROM scope_state ORDER BY decided_at DESC, rowid DESC").all();
+    return rows.map(toScopeState);
+  }
+
   function getFailureStats({ since } = {}) {
     const clause = since ? "WHERE created_at >= ?" : "";
     const params = since ? [since] : [];
@@ -3233,6 +3366,7 @@ export function createStore(path) {
     needsEmbeddingFor,
     hasStaleEmbedding,
     embeddingModelBreakdown,
+    embeddingDimensionBreakdown,
     searchVector,
     saveDreamRun,
     lastDreamRunAt,
@@ -3281,6 +3415,11 @@ export function createStore(path) {
     countConflictPending,
     saveScopeChange,
     listScopeChanges,
+    // 政策轴（issue #471）：按下/松开一个作用域。纯 bookkeeping，不调
+    // incrementGeneration()——它不动任何记忆行，动它只会让所有缓存无谓失效。
+    setScopeState,
+    getScopeState,
+    listScopeStates,
     createEntity,
     findEntityByName,
     findEntityById,

package/src/tools.js

@@ -7,6 +7,7 @@ import { matchesPlatform } from "./runtime/closure.js";
 import { verifyPayload } from "./runtime/verify.js";
 import { TOOL_GUIDE, CONTINUITY_TOOL_RULE } from "./guide.js";
 import { injectChildEnabled } from "./config.js";
+import { normalizeScopeStateDimension, normalizeScopeStateValue, normalizeScopeStateState } from "./scope-state.js";
 import { lastUserQuery } from "./inject.js";
 
 const TEXT_OUTPUT = (text) => [{ type: "text", text }];
@@ -500,6 +501,76 @@ export function createTools(ctx, service, config, embedder) {
       }
     }),
 
+    // #471：政策轴——作用域级可逆闸门。与 memory_forget/memory_archive 的分工：
+    // 那两个是事实轴的单条操作（改的是「这条记忆属于谁 / 还算不算数」，一条条来）；
+    // 本工具是政策轴的按作用域操作（改的是「这一路现在通不通」，跨会话存续、
+    // 松开即原样回来，一条记忆行都不动）。判断指引：整条工作线要临时静音用本工具；
+    // 单条记忆不该再被想起才用 memory_forget/memory_archive。
+    defineTool({
+      name: "set_scope_state",
+      description:
+        "Press or release the reversible scope gate for one scope (issue #471): while paused, that scope's memories stay stored and unchanged but are held back from injection and dream consolidation. " +
+        "This is not deletion and not forgetting — release with state=active and everything comes back exactly as it was, which is why it is the right tool for temporarily silencing a whole work stream rather than editing memories one by one. " +
+        "dimension is agent or workspace; scope_value is the label itself, or * for that dimension's global gate. " +
+        "Both switches (scopeState.enabled/enforce) are off by default, so setting a state has no effect on injection until the user turns them on in the panel.",
+      parameters: {
+        dimension: { type: "string", required: true, description: "Scope dimension to press: \"agent\" or \"workspace\"" },
+        scope_value: { type: "string", required: true, description: "The scope label, or \"*\" for that dimension's global gate" },
+        state: { type: "string", required: true, description: "\"paused\" presses the gate, \"active\" releases it" },
+        note: { type: "string", description: "Optional short reason, stored with the decision so the next reader knows why it was pressed" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            scope: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                dimension: { type: "string", required: true },
+                scope_value: { type: "string", required: true },
+                state: { type: "string", required: true },
+                // 理由要能读回来：不带它，下次读的人只知道「按下过」却不知道为什么。
+                // 这与库层 setScopeState 的 note 取舍是同一条理由——不带理由的重按
+                // 不抹掉旧理由，正是为了让这里读得回来。可选：从没写过就没有。
+                note: { type: "string" },
+                decided_at: { type: "string", required: true }
+              }
+            }
+          }
+        },
+        // 回执如实回显当前值（不是回显入参）：同一个状态重复按下时 decided_at 保持
+        // 首次值，回显它才看得出「这次没有真的改变什么」。
+        render: (_args, value) =>
+          TEXT_OUTPUT(
+            `Scope ${value.scope.dimension}:${value.scope.scope_value} is now ${value.scope.state} (decided at ${value.scope.decided_at}).`
+          )
+      },
+      async execute(args) {
+        const dimension = normalizeScopeStateDimension(args.dimension);
+        const scopeValue = normalizeScopeStateValue(args.scope_value);
+        const state = normalizeScopeStateState(args.state);
+        if (dimension === null) throw new Error("dimension must be \"agent\" or \"workspace\"");
+        if (scopeValue === null) throw new Error("scope_value must be a non-empty label or \"*\"");
+        if (state === null) throw new Error("state must be \"active\" or \"paused\"");
+        const row = service.setScopeState({ dimension, scope_value: scopeValue, state, note: args.note });
+        if (row === undefined) throw new Error("scope state could not be recorded");
+        return {
+          scope: {
+            dimension: row.dimension,
+            scope_value: row.scope_value,
+            state: row.state,
+            // 没写过理由时键整个不出现（而不是 note: undefined）：output schema 是
+            // 闭合的，DTO 矩阵会拿真实返回值过 validateJsonSchemaValue，留一个
+            // 值为 undefined 的键等于留个空壳。
+            ...(row.note === undefined ? {} : { note: row.note }),
+            decided_at: row.decided_at
+          }
+        };
+      }
+    }),
+
     // #230（#164 设计稿评审线）：document 型记忆注册——agent 产长文档的指针
     // 行铸造口。写入权分离：全文归 agent（管线对文件零读零写零改），库里只
     // 存摘要 + doc_path + evidence 三样；C2 比对去重、supersede 记账在

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;
+    }
+  });
+});