@modusensus/dsh-mneme 0.11.0 → 0.13.0

package/src/dream.js

@@ -164,6 +164,17 @@ export function buildOutcome(decisions) {
       byId[d.loser] = "superseded-archived";
     } else if (d.action === "differentiate") {
       for (const id of d.ids ?? []) byId[id] = "differentiated";
+    } else if (d.action === "create") {
+      // #619：create 铸出新行——记下「这一条是这一轮新生的」。它此前特意不派
+      // disposition，好让 receipt_chain 不为它产行（新行的改动无处可记，只有
+      // memory_mints 记出生）。这里补上的是审计面能读懂的那句话，不改 receipt_chain。
+      if (d.id) byId[d.id] = "created";
+    } else if (d.action === "create_merged") {
+      // #619 / Ephor 第七轮 ②：create 撞上同题活跃行时走原地刷新，没有新条目。
+      // 这条动作原本在 if 链里缺席，`outcome.byId` 就是空对象——一个只刷新不铸造
+      // 的轮，审计行看不出任何目标被处置过（#126 review 在 supersede 上踩过同一个
+      // 坑）。刷新有自己的名字，不冒充 created。
+      if (d.id) byId[d.id] = "created-refreshed";
     }
   }
   return { byId };
@@ -1172,6 +1183,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // manual review instead of auto-adjudicated. Read once up front so the
     // prompt hint and the apply-split agree on the same gate.
     const freezeEnabled = config.conflictFreezeEnabled === true;
+    // reflectionUpdateEnabled（默认 true，「关」= 旧记忆永不被自动改写）。同样先读
+    // 一次，prompt 后缀与校验器选项用同一个值，避免两处各读一次 cfg 后彼此不一致。
+    const updateEnabled = config.reflectionUpdateEnabled !== false;
     // Every exit (success or failure) funnels through `finish`, which writes
     // the audit row + receipt. A record failure is logged, never thrown —
     // auditing must not break the consolidation path. Failed runs still
@@ -1222,14 +1236,16 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           // input can be rebuilt offline from the audit row alone — the
           // digest + decisions + outcome triple makes silent errors locatable
           // even after the store has moved on.
-          input: [...snapshot.values()].map((m) => ({
-            id: m.id,
-            type: m.type,
-            title: m.title,
-            content: m.content,
-            importance: m.importance,
-            updated_at: m.updated_at
-          })),
+          // #557（dreamInputSummaryEnabled，opt-in 默认关）：瘦身只动这里的落库
+          // 副本——LLM 输入在下方由内存快照现算、snapshot_hash 在内存里对含
+          // content 的快照计算，两者都不经过这行，prompt 与 receipt 完整性不受
+          // 影响。organize 轮的重放载荷走 organize.js 自己的 saveDreamRun，
+          // 不经过这里，与 reclaim 的 run_type != 'organize' 同一条边界。
+          input: [...snapshot.values()].map((m) => (
+            config.dreamInputSummaryEnabled === true
+              ? { id: m.id, type: m.type, title: m.title, importance: m.importance, updated_at: m.updated_at }
+              : { id: m.id, type: m.type, title: m.title, content: m.content, importance: m.importance, updated_at: m.updated_at }
+          )),
           decisions: result.decisions,
           outcome: result.outcome,
           applied,
@@ -1264,6 +1280,12 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     }
 
     let listText;
+    // Issue #603 第 2 层：把预分组阶段算出的向量相似度留下来，供停车入队时落列。
+    // 这是**本进程内唯一**真实的相似度来源——LLM 裁决给出的只有理由文本，从文本
+    // 里回收数字是猜测。键与 conflict_pending 的对序归一化一致（sort 后的 id 对）。
+    // 拿不到（无向量、跨进程重放、模型自由裁决）就写 NULL，排序按「未知」处理。
+    const pairSimilarity = new Map();
+    const similarityKey = (x, y) => (x < y ? `${x}\u0000${y}` : `${y}\u0000${x}`);
     if (semantic?.embedder && semantic?.vectorIndex) {
       try {
         const vectors = await collectVectors(memories, semantic);
@@ -1272,6 +1294,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           const clusters = clusterMemories(memories, vectors, k);
           const conflicts = findPotentialConflicts(memories, vectors, 0.85);
           const conflictIds = new Set(conflicts.flatMap((c) => [c.a.id, c.b.id]));
+          for (const c of conflicts) pairSimilarity.set(similarityKey(c.a.id, c.b.id), c.similarity);
           const parts = [];
           clusters.forEach((cluster, ci) => {
             parts.push(STR.clusterHeader[language](ci + 1));
@@ -1301,6 +1324,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     const consolidationPrompt = freezeEnabled
       ? STR.prompts.consolidation[language] + STR.prompts.freezeSuffix[language]
       : STR.prompts.consolidation[language];
+    // 两个后缀可以叠加：冻结管冲突怎么处理，关闭改写管 update 能不能用，互不相干。
+    const promptWithUpdateGate = updateEnabled
+      ? consolidationPrompt
+      : consolidationPrompt + STR.prompts.noUpdateSuffix[language];
     let decisionText;
     // 加固（v0.8.1）：配置的 reasoningEffort 被 provider 拒收时回退重试一次
     // （不带该字段），避免 thinking 模型配置 low/medium 直接整单失败。解析放
@@ -1335,7 +1362,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       maxTokens: tokens,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+        { role: "system", content: [{ type: "text", text: promptWithUpdateGate }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
         { role: "user", content: [{ type: "text", text: fenceListBody(language, listText) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
@@ -1371,6 +1398,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     }
     const { ok, errors, skipped, resolvedShortIds, coverageShortfall } = validateDecisions(decisions, snapshot, {
       maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
+      // reflectionUpdateEnabled=false 时校验器单条跳过所有 update（不是整单拒绝）。
+      allowUpdate: updateEnabled,
       // Issue #104 方向 2：archive 批量上限（全局闸门，超限整单拒绝）。
       maxArchivePerRun: config.dreamMaxArchivePerRun,
       // #135 成本审计派生：merge 批量上限（merge 是唯一回吐正文的动作，同款全局闸门）。
@@ -1488,8 +1517,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
             try {
               // 返回 undefined = 该对已被人工裁决且两侧内容未变（issue #170 复核
               // 项 4：内容变了才重新入队）——不算停车、不进 frozenIds。
-              const parked = service.saveConflictPending({ run_id: runId, memory_a: d.winner, memory_b: d.loser, reason: d.reason });
-              if (parked == null) continue;
+              const parked = service.saveConflictPending({ run_id: runId, memory_a: d.winner, memory_b: d.loser, reason: d.reason, similarity: pairSimilarity.get(similarityKey(d.winner, d.loser)) });
+              // 只有真的新插了一行才算停车：这一对已在队列里时返回的是旧行
+              // （fresh=false），旧代码把它也算进 frozen，虚报由此而来（#603）。
+              if (parked?.fresh !== true) continue;
               frozenCount++;
               frozenIds.push(d.winner, d.loser);
             } catch (error) {
@@ -1510,9 +1541,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
             run_id: runId,
             memory_a: d.winner,
             memory_b: d.loser,
-            reason: STR.scopeConflictParkReason[language](d.reason)
+            reason: STR.scopeConflictParkReason[language](d.reason),
+            similarity: pairSimilarity.get(similarityKey(d.winner, d.loser))
           });
-          if (parked != null) {
+          if (parked?.fresh === true) {
             frozenCount++;
             frozenIds.push(d.winner, d.loser);
           }

package/src/dsh-go/host.js

@@ -0,0 +1,162 @@
+// In-process call into the mneme HTTP API.
+//
+// The panel runs inside the engine process, exactly where mneme registered its
+// routes. Going through real HTTP would hit the dsh-go bridge guard (401 unless
+// the request carries the process launch token, which is never written to disk),
+// so we dispatch the registered route handler directly and never leave the
+// process. Everything stays on the local web server table: no sockets.
+//
+// Auth is not skipped: mneme's route registrar wraps every route with a policy
+// check, so a write route answers 401 unless the request carries the configured
+// apiToken. We forward it as the x-dsh-mneme-token header (one of the two the
+// registrar accepts) instead of weakening the policy for in-process callers.
+import { EventEmitter } from "node:events";
+
+const PREFIX = "/api/dsh-mneme";
+const DEFAULT_TIMEOUT = 5000;
+
+function makeRequest(url, method, body, apiToken) {
+  const req = new EventEmitter();
+  req.url = url;
+  req.method = method;
+  req.headers = {
+    host: "127.0.0.1",
+    "content-type": "application/json",
+    "content-length": String(body === undefined ? 0 : Buffer.byteLength(body)),
+  };
+  if (typeof apiToken === "string" && apiToken.length > 0) {
+    req.headers["x-dsh-mneme-token"] = apiToken;
+  }
+  req.socket = { remoteAddress: "127.0.0.1", encrypted: false };
+  req.resume = () => {};
+  req.pause = () => {};
+  req.setEncoding = () => {};
+  // The handler attaches its body listeners synchronously when invoked, so the
+  // body is only released afterwards by flushRequest(); emitting during
+  // construction would fire 'data'/'end' with no listener attached and the
+  // handler's readBody() would wait forever.
+  req.flush = () => {
+    queueMicrotask(() => {
+      if (body !== undefined) req.emit("data", Buffer.from(body));
+      req.emit("end");
+    });
+  };
+  return req;
+}
+
+function makeResponse() {
+  const chunks = [];
+  let settled;
+  const done = new Promise((resolve) => {
+    settled = resolve;
+  });
+  const headers = {};
+  const res = {
+    statusCode: 200,
+    headersSent: false,
+    done,
+    writeHead(status, extra) {
+      res.statusCode = status;
+      res.headersSent = true;
+      if (extra !== undefined && extra !== null) {
+        for (const key of Object.keys(extra)) headers[key.toLowerCase()] = extra[key];
+      }
+      return res;
+    },
+    setHeader(key, value) {
+      headers[key.toLowerCase()] = value;
+      return res;
+    },
+    getHeader(key) {
+      return headers[key.toLowerCase()];
+    },
+    removeHeader(key) {
+      delete headers[key.toLowerCase()];
+    },
+    write(chunk) {
+      if (chunk !== undefined && chunk !== null && typeof chunk !== "function") {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      }
+      return true;
+    },
+    end(chunk) {
+      if (chunk !== undefined && chunk !== null && typeof chunk !== "function") {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      }
+      settled();
+      return res;
+    },
+    flushHeaders() {},
+  };
+  res.text = () => Buffer.concat(chunks).toString("utf8");
+  res.bytes = () => Buffer.concat(chunks);
+  return res;
+}
+
+// 超时定时器不能被 unref()：handler 永不响应时，它是唯一还挂在事件循环上的
+// 东西；unref 之后 node 22 的 test runner 会判定循环已空，把用例记成 cancelled
+// （CI 的 node22 两腿就是这么红的）。改成显式 cancel —— 成功路径也不白挂 5 秒。
+function timeout(ms) {
+  let timer;
+  const promise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error("mneme 接口超时")), ms);
+  });
+  return { promise, cancel: () => clearTimeout(timer) };
+}
+
+/**
+ * Resolve the mneme route handler and run it in-process.
+ * @param {object} ctx - the plugin context (must expose get()).
+ * @param {{apiToken?: string}} [options] - the host's configured API token; the
+ *   route registrar requires it for every token / token-write route.
+ */
+export function createHostCall(ctx, options = {}) {
+  const apiToken = options.apiToken;
+  return async function callMneme(path, options = {}) {
+    const method = (options.method ?? "GET").toUpperCase();
+    const body = options.body === undefined ? undefined : JSON.stringify(options.body);
+    const url = new URL(PREFIX + path, "http://127.0.0.1");
+    const webServer = ctx.get?.("webServer") ?? ctx.reflect?.get?.("webServer");
+    if (webServer === undefined || typeof webServer.match !== "function") {
+      throw new Error("宿主 webServer 不可用");
+    }
+    const route = webServer.match(url.pathname);
+    if (route === undefined || route === null) throw new Error(`mneme 未注册 ${url.pathname}`);
+    const req = makeRequest(url.pathname + url.search, method, body, apiToken);
+    const res = makeResponse();
+    let run;
+    try {
+      run = Promise.resolve(route.handler(req, res));
+    } finally {
+      req.flush();
+    }
+    // Wait for both: most routes return a promise and end the response inside it,
+    // but a few (version-check) return undefined and end later from a callback.
+    // Racing the three would return the moment the synchronous call returns and
+    // hand an empty body to the caller, which then looks like a failed fetch.
+    const guard = timeout(options.timeoutMs ?? DEFAULT_TIMEOUT);
+    try {
+      await Promise.race([
+        Promise.all([run, res.done]).then(() => undefined),
+        guard.promise,
+      ]);
+    } finally {
+      guard.cancel();
+    }
+    const text = res.text();
+    if (res.statusCode >= 400) {
+      const detail = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+      const error = new Error(`mneme ${method} ${path} → ${res.statusCode} ${detail}`);
+      error.status = res.statusCode;
+      error.body = text;
+      throw error;
+    }
+    if (options.raw === true) return text;
+    if (text === "") return {};
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { text };
+    }
+  };
+}