@modusensus/dsh-mneme 0.7.32 → 0.8.1

package/src/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/test/api.test.js

@@ -649,11 +649,12 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // dreamMaxTokens、睡眠路由 sleepProvider/sleepModel、PR1 新增的
   // recallFusion/signalTransparency、issue #109 新增的实体抽取路由
   // entityExtractionProvider/entityExtractionModel/entityExtractionReasoning、
-  // issue #127 新增的 summarize 五键、issue #126 新增的 sleepActionSet，以及
-  // issue #125 新增的候选集三键），未覆盖时取 bundle 配置的解析默认值；
+  // issue #127 新增的 summarize 五键、issue #126 新增的 sleepActionSet，
+  // 以及 issue #125 新增的候选集三键、issue #17（v0.8.0 A1/A3）新增的
+  // scopeEnabled/strictScope），未覆盖时取 bundle 配置的解析默认值；
   // dreamProvider/dreamModel 无 schema 默认值（Config({}) 解析为 undefined），
-  // 不编造给前端 → 51 - 2 = 49
-  assert.equal(Object.keys(data.effective).length, 49);
+  // 不编造给前端 → 53 - 2 = 51
+  assert.equal(Object.keys(data.effective).length, 51);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMinIntervalMinutes, 0);
@@ -1068,6 +1069,91 @@ test("GET /api/dsh-mneme/dream-status returns runs and pending conflict ids", as
   assert.deepEqual(afterData.pendingMemoryIds, []);
 });
 
+// v0.8.0 冲突集中处理：GET /conflicts 队列联表 + POST /conflicts/resolve 人工确认。
+test("GET /api/dsh-mneme/conflicts joins both sides of unresolved conflicts", async () => {
+  const { routes, service } = setup();
+  const a = service.saveWithDedupe({ type: "history", title: "界面暗色偏好", content: "用户当前使用暗色界面主题", importance: 3 }).memory;
+  const b = service.saveWithDedupe({ type: "history", title: "界面亮色切换", content: "用户界面亮色切换计划", importance: 3 }).memory;
+  service.saveConflictPending({ memory_a: a.id, memory_b: b.id, reason: "主题偏好前后矛盾" });
+
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/conflicts");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.items.length, 1);
+  assert.equal(data.total, 1);
+  assert.equal(data.items[0].reason, "主题偏好前后矛盾");
+  // saveConflictPending 会按 id 字典序归一 A/B 侧位——断言集合而非位置。
+  assert.deepEqual(
+    [data.items[0].memory_a.title, data.items[0].memory_b.title].sort(),
+    ["界面亮色切换", "界面暗色偏好"]
+  );
+  assert.equal(data.items[0].memory_a.archived, false);
+  assert.equal(data.items[0].memory_b.archived, false);
+  // 幽灵侧容忍缺失
+  service.saveConflictPending({ memory_a: a.id, memory_b: "ghost-id", reason: "对方已删" });
+  const res2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts"), res2);
+  const data2 = JSON.parse(res2.body);
+  assert.equal(data2.items.length, 2);
+  assert.equal(data2.items.find((x) => x.reason === "对方已删").memory_b.missing, true);
+});
+
+test("POST /api/dsh-mneme/conflicts/resolve stamps and applies the disposition", async () => {
+  const { store, routes, service } = setup();
+  const a = service.saveWithDedupe({ type: "history", title: "界面暗色偏好", content: "用户当前使用暗色界面主题", importance: 3 }).memory;
+  const b = service.saveWithDedupe({ type: "history", title: "界面亮色切换", content: "用户界面亮色切换计划", importance: 3 }).memory;
+  const pending = service.saveConflictPending({ memory_a: a.id, memory_b: b.id, reason: "主题偏好前后矛盾" });
+
+  // store 会把 pair 按 id 字典序归一——从队列行反查「界面亮色切换」所在侧再选。
+  const queueRoute = routes.find((r) => r.path === "/api/dsh-mneme/conflicts");
+  const queueRes = new FakeRes();
+  await queueRoute.handler(req("/api/dsh-mneme/conflicts"), queueRes);
+  const queued = JSON.parse(queueRes.body).items.find((x) => x.id === pending.id);
+  const keepSide = queued.memory_a.id === b.id ? "a" : "b";
+  // loser 恒为 a（keeper 恒为「界面亮色切换」= b），与 A/B 侧位字母无关
+  const loserId = a.id;
+
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/conflicts/resolve");
+  // 保留「界面亮色切换」所在侧（apply 默认 true）→ 该侧保留，另一侧归档
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", { id: pending.id, winner: keepSide }), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.ok, true);
+  assert.equal(data.conflict.resolved_winner, b.id);
+  assert.equal(data.conflict.disposition.ok, true);
+  assert.equal(store.getById(b.id).archived, false, "winner kept");
+  assert.equal(store.getById(loserId).archived, true, "loser archived by apply");
+
+  // 处理过的 id 再 resolve → 幂等重盖（仍是 200；队列视图只列未解决行，
+  // 正常 UI 不会再发这个请求，但接口层保持幂等）
+  const res2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", { id: pending.id, winner: "a" }), res2);
+  assert.equal(res2.statusCode, 200);
+  assert.equal(JSON.parse(res2.body).ok, true);
+
+  // 未知 id → 404；缺 id → 400
+  const res3 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", { id: "nope", winner: "a" }), res3);
+  assert.equal(res3.statusCode, 404);
+  const res4 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", {}), res4);
+  assert.equal(res4.statusCode, 400);
+
+  // apply:false 只盖章不处置
+  const c = service.saveWithDedupe({ type: "decision", title: "丙", content: "内容丙" }).memory;
+  const d = service.saveWithDedupe({ type: "decision", title: "丁", content: "内容丁" }).memory;
+  const p2 = service.saveConflictPending({ memory_a: c.id, memory_b: d.id, reason: "r2" });
+  const res5 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", { id: p2.id, apply: false }), res5);
+  assert.equal(res5.statusCode, 200);
+  assert.equal(JSON.parse(res5.body).conflict.disposition, null);
+  assert.equal(store.getById(c.id).archived, false);
+  assert.equal(store.getById(d.id).archived, false);
+});
+
 test("parseHumanEdits is the pure core of readHumanEdits (CRLF tolerant)", () => {
   const digest = "0".repeat(64);
   const text = [

package/test/client.test.js

@@ -676,4 +676,62 @@ test("vector status card surfaces the configured/degraded split", () => {
     clientSource.includes('t("memory.status.vectorDegradedHint")'),
     "the degraded state must render its own caption (0 of {m} indexed)"
   );
+});
+
+// v0.8.0 A4（issue #17）：作用域隔离的面板面——设置卡新组（scopeEnabled /
+// strictScope 开关）+ 记忆条目的 scope provenance 展示。i18n 键必须中英双语
+// 齐全；徽章/详情行沿用 heat 徽章的「字段缺省即不渲染」模式，前端不感知开关。
+/**
+ * A4（issue #17）面板面回归：作用域隔离的设置卡分组、十个 i18n 键的中英双语
+ * 齐备（沿用 occurrences ≥ 2 模式），以及 ScopeBadge 组件与三处接线（cards
+ * 脚部 / timeline 行 / 详情抽屉 dmeta）的真实存在性——只做源码断言，不挂
+ * React 渲染环境，与文件内其他 clientSource 断言同一风格。
+ */
+test("scope isolation ships panel switches and provenance surfaces (A4)", () => {
+  assert.ok(
+    /key: "group\.scope", items: \["scopeEnabled", "strictScope"\]/.test(clientSource),
+    "FEATURE_GROUPS must carry a dedicated scope group"
+  );
+  for (const key of [
+    "memory.features.group.scope",
+    "memory.features.scopeEnabled",
+    "memory.features.scopeEnabled.hint",
+    "memory.features.strictScope",
+    "memory.features.strictScope.hint",
+    "memory.explorer.scopeBadge",
+    "memory.explorer.detail.agentScope",
+    "memory.explorer.detail.workspaceScope",
+    "memory.explorer.detail.sensitivity",
+    "memory.explorer.detail.occurred"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(/const ScopeBadge = \(\{ m, t \}\)/.test(clientSource), "ScopeBadge component must exist");
+  assert.ok(clientSource.includes("h(ScopeBadge, { m, t })"), "ScopeBadge must be wired into browse views");
+  assert.ok(clientSource.includes('t("memory.explorer.detail.agentScope")'), "drawer must render agent scope row");
+  assert.ok(clientSource.includes('t("memory.explorer.detail.occurred")'), "drawer must render occurred row");
+});
+
+// v0.8.0 冲突集中处理：状态页的待确认冲突队列（reason + 双方内容对比 +
+// 保留 A/B/仅标记动作），resolveConflictPending 的第一个前端出口。双语齐备。
+test("conflict queue ships a central review surface on the status tab", () => {
+  for (const key of [
+    "memory.status.conflictQueue.reason",
+    "memory.status.conflictQueue.sideA",
+    "memory.status.conflictQueue.sideB",
+    "memory.status.conflictQueue.keepA",
+    "memory.status.conflictQueue.keepB",
+    "memory.status.conflictQueue.markReviewed",
+    "memory.status.conflictQueue.applyHint",
+    "memory.status.conflictQueue.missing",
+    "memory.status.conflictQueue.refresh"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(/function ConflictsQueue\(\{ t \}\)/.test(clientSource), "ConflictsQueue component must exist");
+  assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts"'), "queue must fetch the conflicts endpoint");
+  assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts/resolve"'), "queue must call the resolve endpoint");
+  assert.ok(clientSource.includes("h(ConflictsQueue, { t })"), "status tab must render the queue");
 });

package/test/commands.test.js

@@ -40,14 +40,51 @@ test("add registers live; remove unregisters live", () => {
   store.close();
 });
 
-test("handler returns the instruction as success text", async () => {
+test("handler submits the instruction to the agent and returns a receipt", async () => {
   const { store, manager, registered } = setup();
   manager.add({ name: "fmt", description: "格式化", instruction: "请按项目的 lint 规则格式化当前文件" });
   const def = registered.get("fmt");
   assert.ok(def, "definition registered");
-  const result = await def.handler({ agent: {}, rawInput: "", signal: null });
+  assert.equal(def.input.hint, "可选：追加给模型的补充说明");
+  const submitted = [];
+  const agent = { followup: (message) => submitted.push(message) };
+  const result = await def.handler({ agent, rawInput: "", signal: null });
   assert.equal(result.kind, "success");
-  assert.equal(result.text, "请按项目的 lint 规则格式化当前文件");
+  assert.equal(result.text, "已提交指令：fmt");
+  assert.equal(submitted.length, 1);
+  assert.equal(submitted[0].role, "user");
+  assert.deepEqual(submitted[0].content, [{ type: "text", text: "请按项目的 lint 规则格式化当前文件" }]);
+  assert.deepEqual(submitted[0].source, { kind: "user" });
+  store.close();
+});
+
+test("rawInput suffix is appended for the model", async () => {
+  const { store, manager, registered } = setup();
+  manager.add({ name: "mneme", instruction: "以「小墨」的口吻自我介绍" });
+  const def = registered.get("mneme");
+  const submitted = [];
+  await def.handler({ agent: { followup: (m) => submitted.push(m) }, rawInput: "  顺便列出归档数量  " });
+  assert.equal(submitted[0].content[0].text, "以「小墨」的口吻自我介绍\n\n顺便列出归档数量");
+  store.close();
+});
+
+test("handler without a receiving agent falls back to surfacing the instruction", () => {
+  const { store, manager, registered } = setup();
+  manager.add({ name: "fmt", instruction: "legacy text" });
+  const def = registered.get("fmt");
+  const result = def.handler({ rawInput: "" });
+  assert.equal(result.kind, "success");
+  assert.equal(result.text, "legacy text");
+  store.close();
+});
+
+test("handler returns an error result when the agent rejects the submission", () => {
+  const { store, manager, registered } = setup();
+  manager.add({ name: "boom", instruction: "x" });
+  const def = registered.get("boom");
+  const result = def.handler({ agent: { followup: () => { throw new Error("nope"); } } });
+  assert.equal(result.kind, "error");
+  assert.match(result.text, /boom/);
   store.close();
 });
 

package/test/conflict-freeze.test.js

@@ -111,13 +111,23 @@ test("store: countConflictPending 只统计未决行", () => {
   store.close();
 });
 
-test("store: 已解决的同一对后续可再次 pending", () => {
+test("store: 已解决的同一对在内容变化后才可再次 pending（issue #170 复核项 4）", async () => {
   const store = openStore();
-  const p1 = store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "r" });
+  const a = store.save({ type: "project", title: "对A", content: "内容A" });
+  const b = store.save({ type: "project", title: "对B", content: "内容B" });
+  const p1 = store.saveConflictPending({ memory_a: a.id, memory_b: b.id, reason: "r" });
   store.resolveConflictPending(p1.id, { winner: "a" });
-  // 去重只看未决行 —— 已解决后再现同一对应产生新 pending
-  const p2 = store.saveConflictPending({ memory_a: "b", memory_b: "a", reason: "again" });
-  assert.notEqual(p2.id, p1.id, "已解决行不参与去重");
+  // 内容未变 → 已裁决对不重新入队：「保留双方」是有效决定，不是待办。
+  const suppressed = store.saveConflictPending({ memory_a: b.id, memory_b: a.id, reason: "again" });
+  assert.equal(suppressed, undefined, "未变化的已裁决对被抑制");
+  assert.equal(store.countConflictPending(), 0);
+  // 任一侧被改过（updated_at 晚于 resolved_at）→ 重新入队产生新 pending。
+  // 留真实时间间隔：updated_at/resolved_at 毫秒精度，同毫秒算未变。
+  await new Promise((resolve) => setTimeout(resolve, 5));
+  store.update(a.id, { content: "内容A（改）" });
+  const p2 = store.saveConflictPending({ memory_a: b.id, memory_b: a.id, reason: "changed" });
+  assert.ok(p2, "内容变化后的对重新入队");
+  assert.notEqual(p2.id, p1.id, "新 pending 是新行");
   assert.equal(p2.resolved_at, undefined);
   assert.equal(store.countConflictPending(), 1);
   store.close();

package/test/inject.test.js

@@ -154,3 +154,96 @@ test("Issue #129: 扁平的 data.content 形状仍被兼容", () => {
   assert.ok(text.includes("问题"), "query present");
   assert.ok(text.includes("扁平形状的回答"), "flat content shape still supported");
 });
+
+// ---- issue #162: 注入边界花括号转义(v0.7.4 #40 修复被 v0.7.11 误删后恢复) ----
+
+test("issue #162: {{...}} in memory content is escaped at the injection boundary", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "模板记忆", content: "{{hl|highlight}} 和 {{挖空}} {{关键词}}", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("模板记忆"), "memory still rendered by title");
+  assert.ok(text.includes("{\\{hl|highlight}\\}"), "ASCII template braces escaped");
+  assert.ok(text.includes("{\\{挖空}\\}"), "CJK template braces escaped");
+  assert.ok(!text.includes("{{"), "no raw {{ survives into the prompt");
+  assert.ok(!text.includes("}}"), "no raw }} survives into the prompt");
+});
+
+test("issue #162: odd brace runs like {{{a}}} are escaped too", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "三层模板", content: "{{{a}}} 和 }}} 结尾", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(!text.includes("{{"), "no raw {{ for odd brace runs");
+  assert.ok(!text.includes("}}"), "no raw }} for odd brace runs");
+});
+
+test("issue #162: {{...}} in user profile/rules is escaped", () => {
+  const { contexts, settings } = setup();
+  settings.setProfile("我叫{{名字}}，前端开发者");
+  settings.setRules(["回答时用 {{hl|term}}", "以 }} 结尾的规则"]);
+  const settingsCtx = contexts.find((c) => c.name === "user-settings");
+  const text = settingsCtx.text({});
+  assert.ok(text.includes("{\\{名字}\\}"), "profile braces escaped");
+  assert.ok(text.includes("{\\{hl|term}\\}"), "rule braces escaped");
+  assert.ok(!text.includes("{{"), "no raw {{ in user-settings block");
+  assert.ok(!text.includes("}}"), "no raw }} in user-settings block");
+});
+
+test("issue #162: hot-context rounds with {{...}} are escaped", () => {
+  const { contexts } = setup();
+  const text = contexts[0].text({
+    agent: {
+      session: {
+        id: "s1",
+        events: [
+          { type: "user/message", data: { source: { kind: "user" }, content: ["用 {{hl|你好}} 测试"] } },
+          { type: "assistant/message", data: { source: { kind: "assistant" }, content: ["返回 {{答案}}"] } }
+        ]
+      }
+    }
+  });
+  assert.ok(text.includes("[短期上下文]"), "hot context rendered");
+  assert.ok(!text.includes("{{"), "no raw {{ in hot context");
+  assert.ok(!text.includes("}}"), "no raw }} in hot context");
+});
+
+test("issue #162: reasoning parts are excluded from hot memory (docker --format case)", () => {
+  const { contexts } = setup();
+  // issue #162 的触发源：assistant 的 reasoning part 是 { type: "reasoning", text }
+  // 结构，内容里出现 docker --format "{{.Server.Version}}" 时，若被注入 hot memory
+  // 会让 DSH interpolate() 扫到非法变量名 throw → 整轮永久失败。textOf 必须跳过它。
+  const text = contexts[0].text({
+    agent: {
+      session: {
+        id: "s1",
+        events: [
+          { type: "user/message", data: { source: { kind: "user" }, content: ["检查 docker 版本"] } },
+          {
+            type: "assistant/message",
+            data: {
+              source: { kind: "assistant" },
+              content: [
+                { type: "reasoning", text: "运行 docker version --format \"{{.Server.Version}}\" 查看版本" },
+                { type: "text", text: "已检查，Docker 版本 27.1.1。" }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  });
+  // reasoning 不应进入 hot memory
+  assert.ok(!text.includes("Server.Version"), "reasoning text excluded from hot memory");
+  // 正文保留
+  assert.ok(text.includes("27.1.1"), "assistant text part still injected");
+  // 整个注入块没有任何原始 {{ (双保险：即使将来 reasoning 被引入，也会被转义)
+  assert.ok(!text.includes("{{"), "no raw {{ anywhere in injected context");
+  assert.ok(!text.includes("}}"), "no raw }} anywhere in injected context");
+});
+
+test("issue #162: escapePromptVariables=false passes {{...}} through verbatim", () => {
+  const { contexts, service } = setup({ escapePromptVariables: false });
+  service.saveWithDedupe({ type: "preference", title: "模板", content: "{{挖空}} 与 {{hl|term}}", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("{{挖空}}"), "raw braces preserved when escaping disabled");
+  assert.ok(text.includes("{{hl|term}}"), "raw ASCII braces preserved when escaping disabled");
+});