@modusensus/dsh-mneme 0.7.32 → 0.8.1

package/lib/version-check.js

@@ -0,0 +1,122 @@
+// 版本自检（issue #174 后续，2026-09-15 拍板）：独立插件不把「用户在用哪个
+// 版本」托付给插件市场——市场收录有 ~26h 年龄闸门 + 30min 缓存，且安装时
+// 精确指定过版本的 profile 会被 pnpm 钉子挡住（update 尊重既有 semver 范围，
+// 永不跨 minor/major，#174 的报障者正是这样用着 0.7.32 的行为模型来报 bug）。
+//
+// 本模块只做三件事：
+//   1. 向 npm registry 查 @modusensus/dsh-mneme 的 latest dist-tag（带 TTL
+//      缓存 + 超时 + 全失败静默——离线/被墙/registry 异常都返回 null，调用方
+//      据 null 渲染「未知」，前端不打扰）；
+//   2. 与运行版本做纯函数比对（classify）；
+//   3. 对外暴露 registry URL 白名单校验（validateRegistryUrl）——发请求前
+//      强制 https + 精确 host，构造上排除本机与内网地址。
+import { readFileSync } from "node:fs";
+
+// 运行版本：src/ 与 lib/ 都在插件根下一层，相对 import.meta.url 解析一致；
+// 读取失败（打包/受限环境）降级 "unknown"，横幅随之静默。
+const PACKAGE_VERSION = (() => {
+  try {
+    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+})();
+
+// registry 查询地址是模块常量而非用户输入；validateRegistryUrl 仍作为发请求
+// 前的强制闸（构造上即排除非 https 与非白名单 host，双保险且可单测）。
+const REGISTRY_URL = "https://registry.npmjs.org/@modusensus%2Fdsh-mneme/latest";
+const REGISTRY_HOST = "registry.npmjs.org";
+// 市场收录本身有 ~1 天年龄闸门，1h 的 registry 缓存远低于该粒度，足够新鲜。
+const CACHE_TTL_MS = 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 5000;
+
+// 精确 host 白名单：协议必须 https，且 host 逐字等于 registry.npmjs.org。
+// 这一条即构造性排除本机回环、私有网段与保留地址——不做任何
+// 「看起来像公网」的宽松判断，将来换源必须显式改这里的常量。
+export function validateRegistryUrl(candidate) {
+  let url;
+  try {
+    url = new URL(candidate);
+  } catch {
+    return false;
+  }
+  return url.protocol === "https:" && url.hostname === REGISTRY_HOST;
+}
+
+/** 解析 `x.y.z` / `x.y.z-后缀` 为可比较结构；解析失败返回 null。 */
+function parseVersion(text) {
+  if (typeof text !== "string") return null;
+  const match = text.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    // 有 prerelease 后缀的同号版本视为更旧（0.9.0-rc.1 < 0.9.0）。
+    prerelease: match[4] !== undefined
+  };
+}
+
+/**
+ * 三元组语义化比较：a<b → -1，a>b → 1，无法比较 → null（调用方归入 unknown）。
+ * 仅比较数字部分；数字相等时，带 prerelease 的一方更旧（0.9.0-rc.1 < 0.9.0），
+ * 两侧都带则视为同版——横幅只关心「是否落后于 latest」，不追求完整 semver 序。
+ */
+export function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return null;
+  for (const key of ["major", "minor", "patch"]) {
+    if (va[key] !== vb[key]) return va[key] < vb[key] ? -1 : 1;
+  }
+  if (va.prerelease !== vb.prerelease) return va.prerelease ? -1 : 1;
+  return 0;
+}
+
+/**
+ * 运行版本 vs registry latest 的展示归类。latest 为 null（查询失败/离线）
+ * 或任一侧解析失败时归 unknown——前端对 unknown 完全静默。
+ */
+export function classify(version, latest) {
+  const cmp = compareVersions(version, latest);
+  if (cmp === null) return "unknown";
+  if (cmp < 0) return "outdated";
+  if (cmp > 0) return "ahead";
+  return "up-to-date";
+}
+
+// 模块级缓存：面板可能多处/多次拉取，TTL 内一律复用，不重复打 registry。
+// at 用 -Infinity 作「从未拉取」哨兵：任何时钟下 now-at 都是正无穷，首轮
+// 必然真实请求（测试的假时钟从 0 起也不会被误判成新鲜缓存）。
+let cache = { at: -Infinity, latest: null };
+
+/**
+ * 查询 registry latest。TTL 内直接命中缓存；任何失败（网络/超时/非 2xx/
+ * 响应形状不对/URL 校验不过）都静默返回 null——版本提示是锦上添花，绝不
+ * 让它成为新的故障面。失败不写缓存：TTL 起点保持旧值，下次调用立刻重试。
+ */
+export async function fetchLatestVersion({ fetchImpl = typeof fetch === "function" ? fetch : () => Promise.reject(new Error("no fetch")), now = Date.now } = {}) {
+  if (now() - cache.at < CACHE_TTL_MS) return cache.latest;
+  if (!validateRegistryUrl(REGISTRY_URL)) return null;
+  let manifest;
+  try {
+    const response = await fetchImpl(REGISTRY_URL, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) return null;
+    manifest = await response.json();
+  } catch {
+    return null;
+  }
+  const latest = typeof manifest?.version === "string" && manifest.version ? manifest.version : null;
+  cache = { at: now(), latest };
+  return latest;
+}
+
+/** 仅供测试：清空模块级缓存与时间戳。 */
+export function resetCacheForTest() {
+  cache = { at: -Infinity, latest: null };
+}
+
+export { PACKAGE_VERSION, REGISTRY_URL, CACHE_TTL_MS };

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, 7 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.7.32",
+  "version": "0.8.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/api.js

@@ -1,5 +1,4 @@
 import { URL } from "node:url";
-import { readFileSync } from "node:fs";
 import { timingSafeEqual, randomBytes } from "node:crypto";
 import { FEATURE_FLAG_SPEC } from "./settings.js";
 import { TYPE_FILE, renderMirrorText, parseHumanEdits } from "./mirror.js";
@@ -8,6 +7,7 @@ import { computeHeat } from "./heat.js";
 import { describeStreamFailure, resolveRoute } from "./dream.js";
 import { describeLocalRuntime, publicRuntimeStatus } from "./runtime/loader.js";
 import { hostModulesDir, provisionRuntime } from "./runtime/provision.js";
+import { classify, fetchLatestVersion, PACKAGE_VERSION } from "./version-check.js";
 
 // headers：少数端点（/export 附件下载）需要追加 Content-Disposition 等响应头。
 function sendJson(res, status, payload, headers = {}) {
@@ -24,16 +24,8 @@ function sendAttachment(res, status, contentType, filename, body) {
   res.end(body);
 }
 
-// 导出 JSON 的 version 字段：读插件根的 package.json（src/ 与 lib/ 都在根下
-// 一层，相对 import.meta.url 解析一致）。读取失败（打包/受限环境）降级为
-// "unknown"，导出本身仍然可用。
-const PACKAGE_VERSION = (() => {
-  try {
-    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-})();
+// 版本号统一从 version-check.js 取（同一份读 package.json 逻辑，读取失败
+// 同样降级 "unknown"）——/info 与 /version-check 两个路由共用，不再各写一份。
 
 // Defaults for the standalone external API — keep in step with the schema
 // defaults in config.js (externalApiPort / externalApiHost).
@@ -175,6 +167,29 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // 版本自检（#174 后续）：运行版本 vs npm registry latest。只读，宿主围栏
+  // 统一鉴权（与 dream-status 同款，面板 apiFetch 直接可用）。registry 查询
+  // 全失败时 latest=null、status=unknown——前端对 unknown 完全静默，版本提示
+  // 是锦上添花，绝不因它新增故障面。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/version-check",
+    handler(req, res) {
+      if (req.method !== "GET") {
+        sendJson(res, 404, { error: "not-found" });
+        return;
+      }
+      fetchLatestVersion()
+        .then((latest) => sendJson(res, 200, {
+          version: PACKAGE_VERSION,
+          latest,
+          status: classify(PACKAGE_VERSION, latest),
+          checkedAt: new Date().toISOString()
+        }))
+        .catch(() => sendJson(res, 200, { version: PACKAGE_VERSION, latest: null, status: "unknown" }));
+    }
+  });
+
   register({
     kind: "exact",
     path: "/api/dsh-mneme/list",
@@ -480,6 +495,19 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
             }
             patch.tags = body.tags;
           }
+          // v0.8.1 底座（issue #170）：显式 scope 修正。null=放宽到全局，
+          // 字符串=收窄/改标；归一化（"global"/"*"/空白→NULL + explicit 章 +
+          // 审计行）在 service.updateMemory 内做，路由只做形状校验。
+          if (body.agent_scope !== undefined && body.agent_scope !== null && typeof body.agent_scope !== "string") {
+            sendJson(res, 400, { error: "invalid-agent-scope" });
+            return;
+          }
+          if (body.workspace_scope !== undefined && body.workspace_scope !== null && typeof body.workspace_scope !== "string") {
+            sendJson(res, 400, { error: "invalid-workspace-scope" });
+            return;
+          }
+          if (body.agent_scope !== undefined) patch.agent_scope = body.agent_scope;
+          if (body.workspace_scope !== undefined) patch.workspace_scope = body.workspace_scope;
           if (body.archived !== undefined && typeof body.archived !== "boolean") {
             sendJson(res, 400, { error: "invalid-archived" });
             return;
@@ -501,7 +529,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
               ...history
             ].slice(0, 20);
           }
-          if (Object.keys(patch).length) service.update(id, patch);
+          if (Object.keys(patch).length) service.update(id, patch, { actor: "panel" });
           if (body.archived !== undefined) service.setArchived(id, body.archived);
           sendJson(res, 200, { memory: service.getById(id) });
         });
@@ -1014,6 +1042,66 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- 冲突集中处理（v0.8.0）：队列 + 人工确认 --------------------------------
+  // GET /conflicts：未解决冲突 + 双方当前内容（此前面板只有计数与徽章，
+  // resolveConflictPending 在存储层躺着没有任何调用方）。POST /conflicts/resolve：
+  // {id, winner: "a"|"b"|null, apply}——盖章审计，apply 时按 dream 非冻结
+  // conflict 路径同款处置（service.resolveConflictPending 内部复用
+  // applyDecisions：CAS + 事务 + 注记 + 幂等）。认证与其他写路由一致。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/conflicts",
+    handler(req, res) {
+      try {
+        if (req.method !== "GET") {
+          sendJson(res, 404, { error: "not-found" });
+          return;
+        }
+        if (!requireAuth(req, res, apiToken)) return;
+        const url = new URL(req.url, "http://localhost");
+        const limit = Math.min(200, Math.max(1, Number(url.searchParams.get("limit") ?? 50) || 50));
+        const offset = Math.max(0, Number(url.searchParams.get("offset") ?? 0) || 0);
+        const items = service.listConflictQueue({ limit, offset });
+        sendJson(res, 200, { items, total: service.countConflictPending?.() ?? items.length });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/conflicts/resolve",
+    handler(req, res) {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 404, { error: "not-found" });
+          return;
+        }
+        if (!requireAuth(req, res, apiToken)) return;
+        return readBody(req).then((text) => {
+          let body = {};
+          try { body = JSON.parse(text || "{}"); } catch { /* 坏 JSON → 走缺参分支 */ }
+          const id = typeof body.id === "string" ? body.id.trim() : "";
+          if (!id) {
+            sendJson(res, 400, { error: "missing-id" });
+            return;
+          }
+          const winner = body.winner === "a" || body.winner === "b" ? body.winner : null;
+          const apply = body.apply !== false;
+          const result = service.resolveConflictPending(id, { winner, apply });
+          if (!result) {
+            sendJson(res, 404, { error: "not-found" });
+            return;
+          }
+          sendJson(res, 200, { ok: true, conflict: result });
+        }).catch(() => sendJson(res, 500, { error: "internal" }));
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- health: mirror sync state (F-NEW-03 / v0.3.6) ---
   // Auth-gated; only returns a sanitized error code (never raw last_error which
   // may leak paths/token-like strings/internal hosts). On state read failure it

package/src/commands.js

@@ -1,11 +1,16 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { STR } from "./lang.js";
 
 // Custom slash-command manager: keeps the DSH command registry in sync with
 // user-defined commands persisted in SQLite. Commands are registered on boot
 // and (re)registered on add/remove through the API.
 //
-// Each custom command's handler returns the user-authored instruction as a
-// success result; the DSH UI surfaces it as a model-directed instruction.
+// Per the DSH command contract, a handler's CommandResult text is only a UI
+// settlement notice and never reaches the model. To actually drive the agent,
+// the handler submits the user-authored instruction itself as a user followup
+// message on the receiving agent (same pattern as the official /goal command).
+// The notice just acknowledges the submission; an optional rawInput suffix
+// typed after the command is appended for the model.
 
 export function createCommandManager({ ctx, settings, logger, language = "zh" }) {
   const registered = new Map(); // name -> disposer
@@ -18,7 +23,8 @@ export function createCommandManager({ ctx, settings, logger, language = "zh" })
         name: command.name,
         // 缺省描述随实例语言（命令描述进命令注册表，对 LLM 可见）。
         description: command.description || STR.commandFallbackDesc[language](command.name),
-        handler: () => ({ kind: "success", text: command.instruction })
+        input: { hint: STR.commandInputHint[language] },
+        handler: (invocation) => submit(command, invocation)
       });
     } catch (error) {
       logger?.warn?.(`dsh-mneme: failed to register command /${command.name}: ${String(error)}`);
@@ -27,6 +33,27 @@ export function createCommandManager({ ctx, settings, logger, language = "zh" })
     registered.set(command.name, dispose);
   }
 
+  /** Submit the instruction (plus optional rawInput suffix) to the receiving agent. */
+  function submit(command, invocation) {
+    const suffix = typeof invocation?.rawInput === "string" ? invocation.rawInput.trim() : "";
+    const text = suffix ? `${command.instruction}\n\n${suffix}` : command.instruction;
+    const agent = invocation?.agent;
+    if (typeof agent?.followup !== "function") {
+      // 兜底：宿主未提供接收 agent 时退回旧行为，至少把指令展示在 notice 里。
+      return { kind: "success", text };
+    }
+    try {
+      agent.followup(createUserMessage({
+        content: [{ type: "text", text }],
+        source: { kind: "user" }
+      }));
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme: failed to submit /${command.name} to agent: ${String(error)}`);
+      return { kind: "error", text: STR.commandSubmitFailed[language](command.name) };
+    }
+    return { kind: "success", text: STR.commandSubmitted[language](command.name) };
+  }
+
   function unregisterOne(name) {
     const dispose = registered.get(name);
     if (dispose) {

package/src/config.js

@@ -58,6 +58,11 @@ export const Config = z.object({
   // 编码记忆注入加权系数：编码任务时对 rejected_solution/pitfall/constraint
   // 记忆的 importance 乘以该系数排序，让编码记忆在编码场景更靠前。
   codingBoostFactor: z.number().min(1).max(5).default(2),
+  // 注入边界花括号转义（issue #162，v0.7.4 曾修后被 v0.7.11 重构误删）：默认开启，
+  // 在 memory / 短期上下文 / 用户设置三处注入出口对连续 2+ 个花括号插 `\`
+  // （`{{a}}`→`{\{a\}\}`），让 DSH 的 interpolate() 不再扫到非法变量名而 throw。
+  // 关闭时按原样透传。
+  escapePromptVariables: z.boolean().default(true),
   autoDream: z.boolean().default(true),
   dreamThresholdCount: z.natural().min(1).max(1000).default(10),
   dreamThresholdChars: z.natural().min(100).max(100000).default(5000),
@@ -438,6 +443,22 @@ export const Config = z.object({
   recallRecordDefault: z.boolean().default(true),
   // recall_runs 滚动清理保留天数。
   recallRetentionDays: z.natural().min(1).max(3650).default(90),
+
+  // --- scope: v0.8.0 A1 存储层（issue #17）--------------------------------
+  // 总开关默认关：关闭时写入不标注 scope、去重维持 (type, title) 现状，行为
+  // 逐字节不变。开启后 memory_save 写入 agent_scope（session header 的
+  // agentPreset）与 workspace_scope（registry 反查 canonical path，header.cwd
+  // 兜底，取不到 NULL——解析绝不阻塞写入），去重键扩展为 (type, title,
+  // agent_scope, workspace_scope, sensitivity)。检索侧加权/过滤在 A2/A3 落地。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  scopeEnabled: z.boolean().default(false),
+  // strictScope（A3）：硬过滤模式。关闭=A2 软隔离（他 scope 降权保留可见）；
+  // 开启后检索/注入/list/get 按 issue #17 四象限可见性公式硬过滤——带他 scope
+  // 的记忆完全不可见，未标注（NULL）恒可见；当前会话某维度解析不到时该维度
+  // 带标注的记忆一律不可见（fail-closed：身份不明只见全局）。依赖 scopeEnabled
+  // 打开才有意义（没有写入标注就无可过滤维度），但独立成键：可先开标注积累
+  // 数据、观察 A2 加权质量后再切硬过滤。
+  strictScope: z.boolean().default(false),
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here

package/src/dream/sleep.js

@@ -4,6 +4,8 @@ import { STR, langOf } from "../lang.js";
 //   1. conflict resolution — high-similarity same-type pairs are either parked
 //      for review (freeze mode) or adjudicated by the LLM (winner kept / loser
 //      archived), reusing the dream conflict machinery. Strictness-graded.
+//      v0.8.1 (issue #170): cross-scope pairs are ALWAYS parked for human
+//      ownership review with a dedicated reason — never auto-adjudicated.
 //   2. archival demotion — memories unreferenced past sleepArchiveDays shrink
 //      to a one-line summary with the full body moved to _full_content; past
 //      sleepCompressDays they are archived outright.
@@ -18,6 +20,7 @@ import { STR, langOf } from "../lang.js";
 import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions, ACTIONS } from "./decisions.js";
 import { findPotentialConflicts, cosineSimilarity } from "./clustering.js";
+import { scopeKeyOf } from "../scope.js";
 import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, maintainIndexAfterDream } from "../dream.js";
 import { computeHeat } from "../heat.js";
 
@@ -169,29 +172,57 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     selected.push(p);
   }
 
-  // Freeze mode: park pairs for manual review, no LLM required.
+  // v0.8.1（issue #170 第 2 步）：跨 scope 相似对分流。同一内容落在两个归属下
+  // （任一维标注键不等即算，NULL=未标注=全局也参与比较——「全局副本 + 专属副本
+  // 并存」正是收窄/提升裁决的典型候选）不能自动裁决：归档败者可能销毁该内容在
+  // 某个归属下的唯一副本，LLM 也无从替用户决定归属。一律停车到冲突待确认队列
+  // （专属 reason），同 scope 对维持既有路径（freeze 停车 / LLM 裁决）。
+  const isCrossScopePair = (p) =>
+    scopeKeyOf(p.a.agent_scope) !== scopeKeyOf(p.b.agent_scope)
+    || scopeKeyOf(p.a.workspace_scope) !== scopeKeyOf(p.b.workspace_scope);
+  const crossPairs = selected.filter(isCrossScopePair);
+  const samePairs = selected.filter((p) => !isCrossScopePair(p));
+  const parkPair = (p, reason) => {
+    try {
+      // 返回 undefined = 该对已被人工裁决且两侧内容未变（复核项 4）——不算停车。
+      return service.saveConflictPending({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, reason }) != null;
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme sleep: failed to park conflict ${p.a.id}/${p.b.id}: ${String(error)}`);
+      return false;
+    }
+  };
+  const scopeReason = (p) => STR.scopeCandidateReason[language](p.similarity.toFixed(2));
+  const simReason = (p) => STR.similarityReason[language](p.similarity.toFixed(2));
+
+  // Freeze mode: park pairs for manual review, no LLM required. Cross-scope
+  // pairs carry the dedicated scope-candidate reason so the queue reads them
+  // as ownership decisions rather than plain duplicates.
   if (config.conflictFreezeEnabled === true) {
     let frozen = 0;
     for (const p of selected) {
-      try {
-        service.saveConflictPending({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, reason: STR.similarityReason[language](p.similarity.toFixed(2)) });
-        frozen++;
-      } catch (error) {
-        logger?.warn?.(`dsh-mneme sleep: failed to freeze conflict ${p.a.id}/${p.b.id}: ${String(error)}`);
-      }
+      if (parkPair(p, isCrossScopePair(p) ? scopeReason(p) : simReason(p))) frozen++;
     }
-    return { status: frozen > 0 ? "ok" : "noop", frozen, pairs: selected.length };
+    return { status: frozen > 0 ? "ok" : "noop", frozen, scopeCandidates: crossPairs.length, pairs: selected.length };
   }
 
-  // LLM adjudication.
+  // 非 freeze：跨 scope 对先停车（绝不进 LLM 裁决），同 scope 对照常走 LLM。
+  let scopeParked = 0;
+  for (const p of crossPairs) {
+    if (parkPair(p, scopeReason(p))) scopeParked++;
+  }
+  if (samePairs.length === 0) {
+    return { status: scopeParked > 0 ? "ok" : "noop", frozen: 0, scopeCandidates: scopeParked, pairs: selected.length };
+  }
+
+  // LLM adjudication（仅同 scope 对）。
   const route = resolveSleepRoute(ctx, config, logger);
-  if (!route) return { status: "skipped", reason: "no llm route" };
+  if (!route) return { status: "skipped", reason: "no llm route", scopeCandidates: scopeParked, pairs: selected.length };
   const snapshot = new Map();
-  for (const p of selected) {
+  for (const p of samePairs) {
     snapshot.set(p.a.id, p.a);
     snapshot.set(p.b.id, p.b);
   }
-  const listText = selected.map((p) =>
+  const listText = samePairs.map((p) =>
     STR.candidateConflicts[language](p)
   ).join("\n\n");
   const sleepEffort = await resolveDreamEffort(ctx, route, config.sleepReasoningEffort, logger);

package/src/dream.js

@@ -1,5 +1,6 @@
 import { validateDecisions, applyDecisions } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts, cosineSimilarity } from "./dream/clustering.js";
+import { scopeKeyOf } from "./scope.js";
 import { createHash, randomUUID } from "node:crypto";
 import { STR, langOf } from "./lang.js";
 export { validateDecisions, applyDecisions, withEffortFallback, describeStreamFailure, resolveDreamEffort, resolveRoute };
@@ -989,7 +990,21 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // bounds the review queue; overflow is skipped with a warning.
     let frozenCount = 0;
     const frozenIds = [];
-    const applyList = freezeEnabled ? decisions.filter((d) => d.action !== "conflict") : decisions;
+    // v0.8.1（issue #170 复核项 3）：跨 scope 的 conflict 决策两种模式都一律
+    // 停车人工裁决、绝不自动归档——否则普通 dream 的 LLM 能归档别的 scope 的
+    // 唯一副本，sleep 路径（scope-candidate-queue）的保护在这里缺位。同 scope
+    // 的 conflict 决策照旧：freeze 停车 / 非 freeze 自动裁决。
+    const isCrossScopeDecision = (d) => {
+      const a = snapshot.get(d.winner);
+      const b = snapshot.get(d.loser);
+      return !!a && !!b && (
+        scopeKeyOf(a.agent_scope) !== scopeKeyOf(b.agent_scope)
+        || scopeKeyOf(a.workspace_scope) !== scopeKeyOf(b.workspace_scope)
+      );
+    };
+    const applyList = freezeEnabled
+      ? decisions.filter((d) => d.action !== "conflict")
+      : decisions.filter((d) => d.action !== "conflict" || !isCrossScopeDecision(d));
     if (freezeEnabled) {
       const conflictsToFreeze = decisions.filter((d) => d.action === "conflict");
       if (conflictsToFreeze.length > 0) {
@@ -1003,7 +1018,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           }
           for (const d of toFreeze) {
             try {
-              service.saveConflictPending({ run_id: runId, memory_a: d.winner, memory_b: d.loser, reason: d.reason });
+              // 返回 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;
               frozenCount++;
               frozenIds.push(d.winner, d.loser);
             } catch (error) {
@@ -1014,6 +1032,29 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           logger?.warn?.(`dsh-mneme dream: conflict freeze lookup failed: ${String(error)}`);
         }
       }
+    } else {
+      // 非 freeze：跨 scope conflict 停车（绝不进 applyDecisions）。带专属
+      // reason + 模型给出的裁决理由，队列里读起来是「归属裁决」而非重复项。
+      const crossScope = decisions.filter((d) => d.action === "conflict" && isCrossScopeDecision(d));
+      for (const d of crossScope) {
+        try {
+          const parked = service.saveConflictPending({
+            run_id: runId,
+            memory_a: d.winner,
+            memory_b: d.loser,
+            reason: STR.scopeConflictParkReason[language](d.reason)
+          });
+          if (parked != null) {
+            frozenCount++;
+            frozenIds.push(d.winner, d.loser);
+          }
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme dream: failed to park cross-scope conflict ${d.winner}/${d.loser}: ${String(error)}`);
+        }
+      }
+      if (crossScope.length > 0) {
+        logger?.info?.(`[dsh-mneme] dream: parked ${crossScope.length} cross-scope conflict(s) for human ownership review`);
+      }
     }
 
     // CAS-guarded, per-decision-transactional apply against the run snapshot:

package/src/inject.js

@@ -1,3 +1,4 @@
+import { createScopeResolver } from "./scope.js";
 import { createHotMemory } from "./hot-memory.js";
 import { STR, langOf } from "./lang.js";
 
@@ -51,8 +52,16 @@ function extractRounds(ctx, maxRounds) {
       // 这里用 ?? 兜底而不是直接改成 data.message.content：user 消息与旧的扁平形状都照旧可用。
       const parts = event?.data?.content ?? event?.data?.message?.content;
       if (!Array.isArray(parts)) return "";
+      // 只取正文 part（type === "text" 或字符串），跳过 reasoning（issue #162）：
+      // reasoning 里出现 Go template / Vue / Handlebars / 正则 / 日志原文的概率远高于
+      // 正文，把它带进 hot memory 会让 `{{...}}` 模板片段注入 prompt。旧的扁平形状
+      // （字符串 part）照旧取用，无 type 字段的兜底视为正文。
       return parts
-        .map((p) => (typeof p === "string" ? p : p?.text ?? ""))
+        .map((p) => {
+          if (typeof p === "string") return p;
+          if (p?.type && p.type !== "text") return "";
+          return p?.text ?? "";
+        })
         .filter(Boolean)
         .join("\n")
         .trim();
@@ -85,6 +94,10 @@ export function createInjector(ctx, service, settings, config) {
   const language = langOf(config);
   const maxItems = config.maxInjectedItems ?? 5;
   const threshold = config.importanceThreshold ?? 3;
+  // v0.8.0 A3（issue #17）：注入路径的会话 scope 解析——strictScope 硬过滤
+  // 需要。渲染 ctx 与工具 exec 同形（agent.session），解析器直接复用。
+  // logger 透传：registry 反查失败时 warnOnce 才有出口。
+  const resolveSessionScope = createScopeResolver({ ctx, config, logger: ctx.logger });
 
   // Bug6: bound the injected memory block. Each entry's content is truncated to
   // MAX_CONTENT chars (trailing `…`); the whole block gets a MAX_BLOCK budget
@@ -103,6 +116,24 @@ export function createInjector(ctx, service, settings, config) {
     return text.length <= maxLength ? text : `${text.slice(0, maxLength)}…`;
   }
 
+  // Prompt-variable brace escaping (issue #162, restored from v0.7.4 #40):
+  // DSH's interpolate() scans every injected section for `{{...}}` and throws
+  // unless the variable name matches /^[a-z][a-z0-9_]*$/ — memory/profile
+  // content carrying legal template syntax (docker `--format "{{.Server.Version}}"`,
+  // Obsidian-style `{{hl|}}`, `{{挖空}}`, `{{关键词}}`) would hit an illegal
+  // variable name and throw, crashing the whole turn. At the injection boundary
+  // we escape every run of 2+ consecutive braces, inserting a `\` between each
+  // pair, so no `{{`/`}}` substring survives into the prompt: `{{a}}` → `{\{a\}\}`,
+  // and odd runs like `{{{a}}}` (which pair-wise escaping would leave with a
+  // literal `{{`) are handled too. The text keeps its readable template form,
+  // the transform is idempotent (escaped braces are single + `\`, never two
+  // adjacent), and single braces pass through untouched — interpolate only
+  // scans `{{`. Off via config.escapePromptVariables=false (default true).
+  function escapePromptVars(text) {
+    if (config.escapePromptVariables === false) return String(text);
+    return String(text).replace(/[{}]{2,}/g, (run) => run.split("").join("\\"));
+  }
+
   // Hot memory (v0.5.0 1.3): the latest rounds of THIS session, rebuilt from
   // the materialized event log on every render — stateless, so it survives
   // session switches and never persists anywhere.
@@ -119,7 +150,7 @@ export function createInjector(ctx, service, settings, config) {
     for (const r of rounds) hot.add(r);
     const body = hot.getContext();
     if (!body) return "";
-    return STR.hotHeader[language](rounds.length, body);
+    return escapePromptVars(STR.hotHeader[language](rounds.length, body));
   }
 
   function render(candidates) {
@@ -143,7 +174,7 @@ export function createInjector(ctx, service, settings, config) {
         lines.push(`- [${m.type}] ${verified}${title}`);
       }
     }
-    return lines.join("\n");
+    return escapePromptVars(lines.join("\n"));
   }
 
   // Bug4: the system-prompt render is synchronous, so the semantic query vector
@@ -177,7 +208,7 @@ export function createInjector(ctx, service, settings, config) {
     const lines = [STR.userSettingsHeader[language]];
     if (profile) lines.push(STR.profileLine[language](profile));
     for (const rule of rules) lines.push(STR.ruleLine[language](rule));
-    return lines.join("\n");
+    return escapePromptVars(lines.join("\n"));
   }
 
   const disposers = [
@@ -192,7 +223,10 @@ export function createInjector(ctx, service, settings, config) {
         const query = lastUserQuery(ctx);
         if (query) prefetchQueryVector(query);
         const queryVector = queryVectorCache.get(query);
-        const candidates = service.injectCandidates({ query, queryVector, maxItems, threshold });
+        // v0.8.0 A3：scope 随请求解析（strict 开启时 injectCandidates 内硬过滤；
+        // flag 关闭时解析器返回 null，注入行为不变）。
+        const scope = resolveSessionScope(ctx);
+        const candidates = service.injectCandidates({ query, queryVector, maxItems, threshold, scope });
         // Hot memory (v0.5.0 1.3) leads the single memory block: the agent
         // sees the short-term rounds first, then the cross-session recall —
         // the documented injection order 1→2. Folding it here (instead of a