@modusensus/dsh-mneme 0.9.2 → 0.9.3

package/lib/scope.js

@@ -14,6 +14,28 @@
 // 只关「自动标注」，不能连读取身份一起关，否则 strictScope 硬墙被静默拆掉
 // （fail-open）。
 
+/**
+ * 免 inject 读取一个可选服务。cordis 4 的 ctx 是 Proxy，裸读未在 inject 声明的
+ * 属性会抛 "cannot get property ... without inject"（不是返回 undefined），所以
+ * 有 reflect 时优先走 ctx.reflect.get；旧宿主没有 reflect、ctx 是普通对象，裸读
+ * 此时安全——与 api.js:205 / index.js:583 的 webServer 同一形状。
+ *
+ * 服务缺失是合法状态（headless / 旧宿主 / 服务未激活），返回 undefined 让调用方
+ * 走既有降级路径，不告警：这不是故障。
+ * @param {object} ctx
+ * @param {string} name
+ * @returns {*}
+ */
+function readOptionalService(ctx, name) {
+  try {
+    if (typeof ctx?.reflect?.get === "function") return ctx.reflect.get(name);
+    return ctx?.[name];
+  } catch {
+    // 无 reflect 却又是 Proxy（或 accessor 自身抛错）：按「未提供」处理。
+    return undefined;
+  }
+}
+
 /**
  * @param {object} deps
  * @param {object} [deps.ctx] 宿主上下文（可能带 workspaceRegistry；旧版 dsh 没有）
@@ -62,9 +84,16 @@ export function createScopeResolver({ ctx, config, logger } = {}) {
 
     // workspace：registry 反查优先（成员资格 = id 命中 + header canonical cwd
     // 校验过，path 已 realpath 归一），失败回退 header.cwd，再失败留 NULL。
+    //
+    // issue #487：这里曾经是裸读 ctx?.workspaceRegistry，而 workspaceRegistry 不在
+    // inject 声明里（index.js:45）。cordis 4 的 ctx 是 Proxy，裸读未注入属性会抛
+    // "cannot get property ... without inject" 而不返回 undefined——于是这层反查
+    // 从 v0.8.0 起一直抛错走降级，canonical 归一与成员资格校验静默失效，只剩
+    // header.cwd。改用免 inject 读取（同 api.js:205 / index.js:583 的 webServer
+    // 先例）；不加进 inject 的理由见 index.js:39-44（v0.7.23 的 apply 阶段崩溃）。
     let workspaceScope = null;
     try {
-      const list = ctx?.workspaceRegistry?.list?.();
+      const list = readOptionalService(ctx, "workspaceRegistry")?.list?.();
       const sessionId = session?.id;
       if (Array.isArray(list) && sessionId != null) {
         const hit = list.find(

package/lib/settings.js

@@ -209,7 +209,7 @@ const FEATURE_FLAG_BOOLEANS = [
   // 点号键平铺存、合并时展开回 distillRecords 对象（同 llmAudit.enabled）。
   // retentionDays 是 int，走下面的 INT_RANGES 表，不进开关白名单。
   "distillRecords.enabled",
-  // v0.9.0：M.O.（Modus Operandi · 手法，beta）客户端视图开关。客户端读 /features
+  // v0.9.0：M.O.（Modus Operandi，beta）客户端视图开关。客户端读 /features
   // 的 effective
   // 决定是否注册座位（会话头图标 / 浮层 / 右栏 / 对话行卡片），服务端只负责把
   // 这个键稳定暴露出来——键若不在 effective 里，客户端静默少键、一个座位都不注册。
@@ -219,6 +219,10 @@ const FEATURE_FLAG_BOOLEANS = [
   // 与上面那个键分开：那个管「看图的座位」，这个管「往账本里写」。默认关（beta、
   // opt-in），顶层扁平键，不需要 NESTED_FLAG_PATHS 条目。
   "actionRunEnabled",
+  // v0.9.0 第三批：M.O. 自动沉淀（会话跑完一轮 → 挖这个项目自己的会话日志 → 落提议）。
+  // 与前两个分开：这个管「从日志里长出候选」，那个管记账、另一个管看图。默认关
+  // （beta、opt-in）；顶层扁平键，不需要 NESTED_FLAG_PATHS 条目。进 LIGHT_MODE_OFF。
+  "actionNudgeEnabled",
   // 人格定义页（beta）：注入器渲染人格段的顶层总闸（双闸门的 config 半边；对象内
   // 的 persona.enabled 是 per-agent 半边，存 user_settings 的 "persona" 键，见
   // getPersona/setPersona）。默认关（beta、opt-in，老用户行为逐字节不变）；不进

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 10 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/api.js

@@ -18,6 +18,14 @@ import { loadRunsById, runsDir, RUNS_SUFFIX } from "./pipeline-runs.js";
 import { observationDir, loadObservationsById } from "./pipeline-observations.js";
 import { projectKey } from "./candidates.js";
 import { readCandidateDoc } from "./candidates.js";
+// M.O. 自动沉淀：/nudge 是 pipeline-nudge.js 的第一个运行时消费者（此前它只有测试在用，
+// 是个孤儿模块——「不能自动沉淀工作流」的根因）。
+import {
+  resolveProjectSessionDir,
+  nudgeForProject,
+  NUDGE_BOUNDARIES,
+  NUDGE_AUTO_BUDGET_MS
+} from "./pipeline-nudge.js";
 
 // headers：少数端点（/export 附件下载）需要追加 Content-Disposition 等响应头。
 function sendJson(res, status, payload, headers = {}) {
@@ -1849,7 +1857,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
-  // --- M.O.（Modus Operandi · 手法）工作流 ---
+  // --- M.O.（Modus Operandi）工作流 ---
   // 只读端点，读的是**项目里**的 `<项目>/.mneme/pipelines/*.json`（文件头在
   // src/pipeline.js），项目层优先、插件包里那份降级成全局层；投影成
   // mneme.pipeline/v1 交给面板与 agent——两边读同一份，画面只是它的投影。
@@ -1992,6 +2000,116 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- M.O. 自动沉淀（nudge）---
+  // 读+写两种方法同路：GET 是**预览**（不落盘），POST 是**真跑**（落提议、可落草稿）。
+  // 为什么不全放 GET：GET 会被浏览器预取、被面板刷新反复调用，而这一跑要解压几十份
+  // zstd 会话日志（同步 I/O,本机实测 16.2s）。预览走 GET 时才关掉提议落盘
+  // （persistProposals:false）——否则每刷一次面板就往 memoryDir 里塞一批文件。
+  //
+  // policy 是 token-write 而不是 open：GET 免 token（与 /pipeline、/candidates 同级的
+  // 只读预览），POST 要 token——它会写盘，写盘面一律受门控。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/nudge",
+    policy: "token-write",
+    handler(req, res) {
+      const method = String(req.method || "GET").toUpperCase();
+      // 只认这四种。为什么必须在**读 body 之前**拦：下面 persistProposals 是按
+      // 「不是 GET/HEAD」算的，于是 PATCH/DELETE 会被当成写动作，走进 run() 落提议；
+      // 而它又不像 PUT/POST 那样读 body，等于一个不需要 body 的静默写盘口。
+      // 这条 PR 自己的卖点是「GET 只预览、写动作一律要 POST」，那就得把口子堵死
+      // （v0.9.3 评审抓出：带 token 的 PATCH/DELETE 会往 memoryDir 里写提议）。
+      const allowed = method === "GET" || method === "HEAD" || method === "POST" || method === "PUT";
+      if (!allowed) {
+        sendJson(res, 405, { error: "method-not-allowed", allow: "GET, HEAD, POST, PUT" }, { Allow: "GET, HEAD, POST, PUT" });
+        return;
+      }
+      const run = (body) => {
+        try {
+          const url = new URL(req.url, "http://localhost");
+          const project = url.searchParams.get("project");
+          // 与 /pipeline、/candidates 同一条规矩：不是绝对路径就拒掉，不能静默退成全局。
+          if (project !== null && !isAbsolute(project)) {
+            sendJson(res, 400, { error: "project-not-absolute", detail: project });
+            return;
+          }
+          // 预算从**这里**起算，不是一个端点两套预算：归属解析（同步扫桶，最多 500 个）
+          // 与后面的挖掘必须共用同一条截止线，否则「真卡就调 budgetMs」对前一段是空话。
+          // POST（显式真跑）给三倍预算，面板预览给短预算。
+          const previewMethod = method === "GET" || method === "HEAD";
+          const startedAt = Date.now();
+          const budgetMs = previewMethod ? NUDGE_AUTO_BUDGET_MS : NUDGE_AUTO_BUDGET_MS * 3;
+          const deadline = startedAt + budgetMs;
+          // 归属解析先做、单独回执：解析不到桶时要能说清是「这个项目还没跑过会话」
+          // 还是「会话目录读不到」——两者在候选列表上都表现为空。
+          const where = resolveProjectSessionDir({ projectRoot: project, deadline });
+          if (!where.sessionDir) {
+            // no-sessions-dir / unreadable / budget-exceeded / bucket-limit 都是**环境问题**
+            // （读不到、没扫完、没扫全），回 503 让调用方知道这不是答案；
+            // no-bucket / bad-project 是**关于这个项目的答案**，回 200。
+            const envProblem = where.reason === "no-sessions-dir"
+              || where.reason === "unreadable"
+              || where.reason === "budget-exceeded"
+              || where.reason === "bucket-limit";
+            sendJson(res, envProblem ? 503 : 200, {
+              error: envProblem
+                ? (where.reason === "budget-exceeded"
+                    ? "nudge-attribution-budget-exceeded"
+                    : where.reason === "bucket-limit"
+                      ? "nudge-attribution-bucket-limit"
+                      : "nudge-sessions-unreadable")
+                : undefined,
+              contract: "mneme.nudge/v1",
+              attribution: where,
+              skipped: true,
+              skippedReason: "no-session-attribution",
+              counts: { candidates: 0, buckets: 0, sessionsWithCandidates: 0, savedProposals: 0, draftsWritten: 0 },
+              available: [],
+              drafts: [],
+              boundaries: NUDGE_BOUNDARIES
+            });
+            return;
+          }
+          const memoryDir = (config && typeof config.memoryDir === "string" && config.memoryDir.trim())
+            ? config.memoryDir
+            : "~/.dsh/memory";
+          const doc = nudgeForProject({
+            projectRoot: project,
+            // 上面已经解析过并判过 400/503，这里传进来，别再扫一遍桶。
+            attribution: where,
+            // now 传起算时刻：nudgeForProject 内部按 now+budgetMs 重新算截止点，这样
+            // 两处算出来是同一条线（传 Date.now() 会让挖掘白拿一段已经花掉的预算）。
+            now: startedAt,
+            memoryDir,
+            // GET 只预览：不落提议、不落草稿。写动作只认 POST/PUT——PATCH/DELETE 已在
+            // 入口回 405，否则它们会落进这个「不是 GET/HEAD 就算写」的分支。
+            persistProposals: method !== "GET" && method !== "HEAD",
+            // 落草稿是「往仓库里塞文件」，必须显式要（body.materialize），默认不落。
+            materialize: body && body.materialize === true,
+            // 与归属解析共用同一条预算线：宁可少看几份并如实标 budgetExceeded，
+            // 也不能让一次面板刷新把宿主主线程按住十几秒。
+            budgetMs
+          });
+          sendJson(res, 200, doc);
+        } catch (error) {
+          sendJson(res, 500, {
+            error: "nudge-failed",
+            detail: String((error && error.message) || error)
+          });
+        }
+      };
+      if (method === "PUT" || method === "POST") {
+        readBody(req, res).then((text) => {
+          // readBody 已经回过 413：null 就是「别再往下走」。
+          if (text === null) return;
+          run(parseBody(text));
+        });
+        return;
+      }
+      run(null);
+    }
+  });
+
   return {
     routes: countRoutes(),
     dispose: () => {

package/src/capabilities.js

@@ -1,5 +1,5 @@
 /**
- * M.O.（Modus Operandi · 手法）能力清单的**读侧**。
+ * M.O.（Modus Operandi）能力清单的**读侧**。
  *
  * 能力清单 = 「这台机器上、这个项目里，agent 能拿到哪些外部增强」的一份可复核投影。
  * 三类：技能（注入文本指令）／MCP（注册可执行工具）／插件（加载单元）。三者在 DSH 里

package/src/config.js

@@ -880,7 +880,7 @@ export const Config = z.object({
     enforce: z.boolean().default(false)
   }).default({}),
 
-  // --- v0.9.0 M.O.（Modus Operandi · 手法，beta）--------------------------
+  // --- v0.9.0 M.O.（Modus Operandi，beta）--------------------------
   // 命名：M.O. = Modus Operandi，拉丁语「一个人一贯的做事方式」，缩写 M.O.；
   // 也正是 org 词根 modus（modusensus）。界面主显示 M.O.，设置项 hint 第一句
   // 给全名——缩写不靠注释解释，靠用户第一眼能看见全名。
@@ -902,6 +902,20 @@ export const Config = z.object({
   // 所以轻量档要关掉：`LIGHT_MODE_OFF` 里有它。
   actionRunEnabled: z.boolean().default(false),
 
+  // M.O. 自动沉淀（v0.9.0 第三批）：会话跑完一轮后，把这个项目自己的会话日志挖一遍，
+  // 把「反复出现的同一段能力序列」落成提议（memoryDir 下），可选再落一份 draft 草稿。
+  //
+  // 与上面两个键三件事分开：actionPipelineEnabled 管「看图的座位」，actionRunEnabled
+  // 管「往账本里写」，这个管「从日志里长出候选」。三个都是独立能力，混成一个键会让
+  // 「只想看图」的人顺手获得写盘能力。
+  //
+  // 默认关（beta 必须 opt-in），并且进 LIGHT_MODE_OFF：它挂在 session/event 热路径上，
+  // 且解压会话日志是**同步**的（本机 118 份实测 16.2s），轻量档最不该背这条路径。
+  // 触发侧另有 10 分钟/项目的冷却与 budgetMs 上限（见 src/pipeline-nudge.js 的
+  // NUDGE_AUTO_MIN_INTERVAL_MS 与 src/index.js 的装配注释）——旗标只是总闸。
+  // （冷却值以常量为准：早前这里写「30 分钟」，与实际 10 分钟不符。）
+  actionNudgeEnabled: z.boolean().default(false),
+
   // --- 人格定义页（beta）---------------------------------------------------
   // 注入器渲染人格段的顶层总闸（双闸门的 config 半边；user_settings "persona"
   // 键内的 persona.enabled 是 per-agent 半边，两闸同真才渲染）。API 的 effective
@@ -962,7 +976,11 @@ const LIGHT_MODE_OFF = [
   // M.O. 执行记账：它挂在**热路径**上（每个会话事件都过一次监听）。轻量档的取向
   // 是「小模型 / 小上下文 / 少常驻路径」，这与一个每事件都过一遍的监听器相冲突。
   // 默认关，这里只是轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同上面两条）。
-  "actionRunEnabled"
+  "actionRunEnabled",
+  // M.O. 自动沉淀：同样挂在 session/event 热路径上，而且解压会话日志是同步 I/O。
+  // 轻量档的取向（小模型 / 小上下文 / 少常驻路径）与它直接冲突，预设里关掉；
+  // 用户显式勾选仍然赢（合并顺序同上面几条）。
+  "actionNudgeEnabled"
 ];
 
 /**

package/src/index.js

@@ -24,6 +24,9 @@ import { createSettings } from "./settings.js";
 import { createCommandManager } from "./commands.js";
 import { createExecutionRecorder } from "./pipeline-runner.js";
 import { registerMoRunCommand } from "./pipeline-command.js";
+// M.O. 自动沉淀的触发侧（冷却 / 排队 / 兜底）。挖掘与落盘在 pipeline-nudge.js，
+// 这里只管「什么时候跑」。两者分开的理由见 src/pipeline-nudge-auto.js 文件头。
+import { createNudgeAutoRun } from "./pipeline-nudge-auto.js";
 import { createVectorIndex } from "./vector-index.js";
 // semantic(embedder/reranker/boot 回填)纯搬移至 src/semantic.js(PR2):宿主与
 // daemon(dsh-mneme-serve,#363)共用同一套装配,原文件保留 barrel 出口。
@@ -590,6 +593,18 @@ export const apply = (ctx, config) => {
     disposers.push(api.dispose);
   }
 
+  // M.O. 自动沉淀（v0.9.3）：项目里重复走的那套动作，自动变成 memoryDir 里的一条
+  // 「提议」，等人确认后才可能进仓库。默认关（actionNudgeEnabled）。
+  //
+  // 为什么位置在这里而不是和 M.O. 记账同段：`disposers` 声明在 :532，而记账块在它
+  // 之前（TDZ）——照抄过去会在插件加载时直接抛 ReferenceError。这里已在其后。
+  //
+  // 为什么挂 session/event 却又要进轻量档黑名单：它读的是 zstd 会话日志（同步解压），
+  // 是本插件里最重的一条后台路径；且它只产「提议」，关掉不影响记忆本身的正确性。
+  if (cfg.actionNudgeEnabled === true) {
+    disposers.push(createNudgeAutoRun({ ctx, memoryDir, logger: ctx.logger }));
+  }
+
   // Standalone external API (v0.7.12): plain node:http server for ecosystem
   // integrations outside the DSH host. Persisted external_api settings win
   // over the bundle config (enabled/port); the Bearer token lives in the same

package/src/pipeline-nudge-auto.js

@@ -0,0 +1,126 @@
+/**
+ * M.O. 自动沉淀的**触发侧**：让「这个项目又重复走了一遍同一套动作」变成自动发生的观察，
+ * 而不是等人想起来去点一下。
+ *
+ * 为什么单独一个文件：pipeline-nudge.js 是纯函数式的挖掘 / 落盘层（不碰宿主上下文，
+ * 测试可以直接驱动）；触发时机、冷却、去重、错误兜底是**宿主接线**问题，混进那一层会
+ * 让它不再纯粹。
+ *
+ * 三条执行侧边界（口径与 pipeline-nudge.js 的 NUDGE_BOUNDARIES 一致）：
+ * - 只产 draft，且**自动跑一律不落草稿**（materialize 恒 false）——往别人仓库里塞文件
+ *   必须是人的显式动作；
+ * - 落进 memoryDir 的只是「提议」（proposal），升格成工作流仍然要人批；
+ * - 一次跑不完就带着已读到的部分收工并如实标 budgetExceeded，**不重试、不排队补跑**：
+ *   沉淀是锦上添花，卡住宿主是事故。
+ */
+import { projectRootOf } from "./pipeline-runner.js";
+import { nudgeForProject, NUDGE_AUTO_BUDGET_MS, NUDGE_AUTO_MIN_INTERVAL_MS } from "./pipeline-nudge.js";
+
+/**
+ * 冷却不是防重复写盘（saveProposal 同 id 覆盖，本来就幂等），而是**观测新鲜度**：
+ * 同一个项目的会话日志十分钟内不会长出新的重复模式，重跑只是把同样的解压开销再付一次。
+ */
+export function createNudgeAutoRun({
+  ctx = null,
+  memoryDir = null,
+  logger = null,
+  now = () => Date.now(),
+  runNudge = nudgeForProject,
+  minIntervalMs = NUDGE_AUTO_MIN_INTERVAL_MS,
+  budgetMs = NUDGE_AUTO_BUDGET_MS,
+  maxFiles = null
+} = {}) {
+  const log = logger || (ctx && ctx.logger) || null;
+  let disposed = false;
+  let timer = null;
+  // 每个项目一条冷却记录；键是归一化后的项目根。
+  const lastRunAt = new Map();
+  // 已排队但还没跑的项目：同一个项目连来十个 turn/end，只跑最后一次。
+  const pending = new Set();
+
+  const normalize = (p) => {
+    let s = String(p).replace(/\\/g, "/").replace(/\/+$/, "");
+    if (/^[a-zA-Z]:\//.test(s)) s = s.toLowerCase();
+    return s;
+  };
+
+  const runOne = (projectRoot) => {
+    pending.delete(projectRoot);
+    if (disposed) return null;
+    lastRunAt.set(normalize(projectRoot), now());
+    try {
+      const doc = runNudge({
+        projectRoot,
+        memoryDir,
+        // 自动跑：永不落草稿。它只在记忆库的 proposals 分桶里留提议。
+        materialize: false,
+        persistProposals: true,
+        budgetMs,
+        ...(maxFiles ? { maxFiles } : {})
+      });
+      // 静默是默认，但不许无声无息：只有真挖到东西时才说一句。
+      if (doc && doc.counts && doc.counts.savedProposals > 0) {
+        log?.info?.("[dsh-mneme] M.O. 自动沉淀：" + projectRoot + " 记录到 " + doc.counts.savedProposals + " 条重复模式（待人工确认）");
+      }
+      return doc;
+    } catch (error) {
+      // 自动跑的失败绝不能冒泡到 session/event——那条链上还挂着摘要与续期。
+      log?.warn?.("[dsh-mneme] M.O. 自动沉淀失败（" + projectRoot + "）：" + String((error && error.message) || error));
+      return null;
+    }
+  };
+
+  // 队列里一个一个推进：一次 setTimeout 里连跑多个项目会把一帧拉长。
+  const flush = () => {
+    timer = null;
+    if (disposed) return;
+    const first = pending.values().next();
+    if (first.done) return;
+    runOne(first.value);
+    if (pending.size > 0 && !disposed) defer();
+  };
+
+  const defer = () => {
+    if (disposed || timer) return;
+    // 解压会话日志是同步 I/O（本机 118 份实测 16.2s）。绝不在这里直接跑：当前这一帧
+    // 是宿主的 turn/end 处理链，占住它等于让整个回合收尾卡住。setTimeout(0) 把它挪到
+    // 下一个宏任务，宿主先收尾。
+    timer = setTimeout(flush, 0);
+    if (typeof timer.unref === "function") timer.unref();
+  };
+
+  const schedule = (projectRoot) => {
+    const key = normalize(projectRoot);
+    const last = lastRunAt.get(key);
+    if (last !== undefined && now() - last < minIntervalMs) return;
+    if (pending.has(projectRoot)) return;
+    pending.add(projectRoot);
+    defer();
+  };
+
+  const onSessionEvent = (session, event) => {
+    if (disposed) return;
+    // 只认 turn/end：一轮结束才算一个观测窗口，中途记的是半截。
+    if (!event || event.type !== "turn/end") return;
+    const projectRoot = projectRootOf(session);
+    if (!projectRoot) return;
+    schedule(projectRoot);
+  };
+
+  const unsubscribe = ctx && typeof ctx.on === "function" ? ctx.on("session/event", onSessionEvent) : null;
+
+  const dispose = () => {
+    disposed = true;
+    pending.clear();
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (typeof unsubscribe === "function") unsubscribe();
+  };
+  // 手动入口与测试都要能直接驱动一次（不起 timer、不走冷却）。
+  dispose.runNow = (projectRoot) => (disposed || !projectRoot ? null : runOne(projectRoot));
+  dispose.pendingCount = () => pending.size;
+  dispose.lastRunAt = (projectRoot) => lastRunAt.get(normalize(projectRoot));
+  return dispose;
+}