@modusensus/dsh-mneme 0.12.0 → 0.14.0-beta.1

package/test/dsh-go-panel.test.js

@@ -0,0 +1,251 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildView } from "../src/dsh-go/views/root.js";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(HERE, "..");
+
+// 这组守的是**视图契约**，不是像素：dsh-go 只认 JSON，越界（节点数 / 层数 / 字节）
+// 是会在用户手机上直接报错的硬失败，所以每加一屏都要过一遍预算。
+// 取数（src/dsh-go/host.js）与动作（src/dsh-go/panel.js）需要真宿主，端到端在
+// dsh-go-bridge 那一侧验证；这里只锁得到「视图能拼出来、拼得合规」。
+
+const LIMITS = { nodes: 120, depth: 8, bytes: 32768 };
+
+/**
+ * 与 bridge 的 viewStats 同口径：节点 = 带 `type` 的组件对象（bindings / options /
+ * actions 里的参数对象不算节点），层数 = 组件 children 的递归深度。
+ */
+function stats(node, depth = 1) {
+  if (node === null || typeof node !== "object") return { nodes: 0, depth };
+  if (Array.isArray(node)) {
+    let nodes = 0;
+    let deepest = depth;
+    for (const child of node) {
+      const s = stats(child, depth);
+      nodes += s.nodes;
+      deepest = Math.max(deepest, s.depth);
+    }
+    return { nodes, depth: deepest };
+  }
+  const isComponent = typeof node.type === "string";
+  let nodes = isComponent ? 1 : 0;
+  let deepest = isComponent ? depth : depth;
+  for (const value of Object.values(node)) {
+    if (value === null || typeof value !== "object") continue;
+    const s = stats(value, isComponent ? depth + 1 : depth);
+    nodes += s.nodes;
+    deepest = Math.max(deepest, s.depth);
+  }
+  return { nodes, depth: deepest };
+}
+
+/** 面板状态的默认形状（与 src/dsh-go/panel.js 的 state 对齐，覆盖视图读到的每个字段）。 */
+function state(over = {}) {
+  return {
+    page: "list",
+    flagGroup: "basic",
+    settingsView: "settings",
+    sPanel: "menu",
+    profileTab: "profile",
+    q: "",
+    type: "all",
+    range: "all",
+    minImportance: 0,
+    scope: "all",
+    semantic: false,
+    viewMode: "flat",
+    heatSort: false,
+    filtersOpen: false,
+    offset: 0,
+    size: 20,
+    current: null,
+    form: {},
+    entityTotal: 12,
+    entityQuery: "",
+    entityName: "",
+    entityDepth: 1,
+    entityRelationCount: 0,
+    entityMemoryCount: 0,
+    flags: {},
+    flagOverrides: {},
+    pendingRestart: [],
+    pendingConflicts: 0,
+    pendingIds: new Set(),
+    rowsCount: 0,
+    monthGroups: [],
+    detailEntities: [],
+    detailEntityCount: 0,
+    detailConflict: false,
+    provenanceText: "",
+    conflictCount: 0,
+    conflictId: "",
+    conflictPick: "",
+    conflictA: null,
+    conflictB: null,
+    conflictReady: false,
+    wbKv: [],
+    wbDeposited: [],
+    wbArchived: [],
+    commands: [],
+    cmdCount: 0,
+    sCmdPick: "",
+    sCmdName: "",
+    sCmdDesc: "",
+    sCmdIns: "",
+    vector: { enabled: false, baseUrl: "", model: "" },
+    external: { enabled: false, port: 8790, host: "127.0.0.1" },
+    versionNote: "",
+    extractText: "",
+    injectPreviewText: "",
+    tokenCategories: [],
+    tokenSeries: [],
+    tokenKv: [],
+    heatSeries: [],
+    heatNote: "",
+    reclaimText: "",
+    reclaimConfirm: false,
+    notice: "",
+    noticeTone: "ok",
+    err: "",
+    ...over,
+  };
+}
+
+const SCREENS = [
+  ["记忆列表", state()],
+  ["记忆列表·月视图", state({ viewMode: "month", monthGroups: [{ label: "2026-11", rows: [] }] })],
+  ["记忆详情", state({ page: "detail", current: { id: "m1", archived: false } })],
+  ["记忆编辑", state({ page: "editor", form: { id: "m1", type: "project" } })],
+  ["记忆新建", state({ page: "editor", form: {} })],
+  ["冲突队列", state({ page: "conflict" })],
+  ["冲突对照", state({ page: "conflict", conflictReady: true, conflictPick: "a", conflictCount: 1 })],
+  ["实体", state({ entityTotal: 0 })],
+  ["实体详情", state({ page: "entity" })],
+  ["设置首页", state()],
+  ["状态", state({ settingsView: "status" })],
+  ["画像", state({ page: "profile" })],
+  ["人格", state({ page: "profile", profileTab: "persona" })],
+  ["规则", state({ page: "profile", profileTab: "rules" })],
+  ["工作动态", state({ sPanel: "workbench" })],
+  ["自定义指令", state({ sPanel: "commands", cmdCount: 1, commands: [{ id: "c1", name: "x" }], sCmdPick: "c1" })],
+  ["向量检索", state({ sPanel: "vector" })],
+  ["外部访问", state({ sPanel: "external" })],
+  ["关于", state({ sPanel: "help" })],
+  ["Agent 眼中的你", state({ sPanel: "facts" })],
+  ["代码库地志", state({ sPanel: "choro" })],
+];
+
+for (const [name, fixture] of SCREENS) {
+  test(`dsh-go 视图在预算内：${name}`, () => {
+    const view = buildView(fixture);
+    assert.equal(view.v, 2);
+    const s = stats(view);
+    assert.ok(s.nodes <= LIMITS.nodes, `${name} 节点 ${s.nodes} > ${LIMITS.nodes}`);
+    assert.ok(s.depth <= LIMITS.depth, `${name} 层 ${s.depth} > ${LIMITS.depth}`);
+    const bytes = Buffer.byteLength(JSON.stringify(view), "utf8");
+    assert.ok(bytes <= LIMITS.bytes, `${name} 体积 ${bytes} > ${LIMITS.bytes}`);
+  });
+}
+
+test("dsh-go 顶层是三个原生页签（App 页签条每格 80dp，第四格会折行）", () => {
+  const view = buildView(state());
+  const tabs = view.children.find((node) => node.type === "tabs");
+  assert.ok(tabs, "顶层没有 tabs");
+  assert.deepEqual(
+    tabs.items.map((item) => item.label),
+    ["记忆", "实体", "设置"],
+  );
+});
+
+test("功能开关铺在设置页正文里，不是子页面（#dsh-go 对齐电脑端分组）", () => {
+  const view = buildView(state());
+  const flat = JSON.stringify(view);
+  assert.ok(flat.includes("功能开关"), "缺少功能开关标题");
+  assert.ok(!flat.includes("功能开关（分组）"), "标题仍带着「（分组）」");
+  assert.ok(flat.includes('"bind":"data.flagGroup"'), "分组选择器没有绑定");
+  assert.ok(/"bind":"data\.flags\./.test(flat), "没有开关绑定到 data.flags.*");
+  assert.ok(!flat.includes('"k":"flags"'), "还有指向 flags 子页面的入口");
+});
+
+function walk(node, out = []) {
+  if (node === null || typeof node !== "object") return out;
+  if (Array.isArray(node)) {
+    for (const child of node) walk(child, out);
+    return out;
+  }
+  out.push(node);
+  for (const value of Object.values(node)) walk(value, out);
+  return out;
+}
+
+test("设置页里不再出现自造的解释性小字（只留 mneme 原文案）", () => {
+  const flat = JSON.stringify(buildView(state()));
+  const invented = [
+    "38 项开关",
+    "写成斜杠命令，随时调用",
+    "跨会话记住你是谁",
+    "接口地址、模型、重建索引",
+    "版本检测与数据来源",
+    "轻量模式少做后台整理",
+    "沉淀 =",
+  ];
+  for (const phrase of invented) assert.ok(!flat.includes(phrase), `自造文案还在：${phrase}`);
+  assert.ok(flat.includes("控制插件在后台做哪些事"), "缺少 mneme 原文案（features.desc）");
+  assert.ok(flat.includes("轻量模式只保留核心能力"), "缺少 mneme 原文案（mode.desc）");
+});
+
+test("dsh-go 清单合法：一个面板、placement 只落 session.tab / features", () => {
+  const pkg = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
+  const manifest = pkg.dshGo;
+  assert.equal(manifest.v, 1);
+  const panels = manifest.contributes.panels;
+  assert.equal(panels.length, 1);
+  const [panel] = panels;
+  assert.equal(panel.id, "mneme");
+  assert.ok(["session.tab", "features"].includes(panel.placement[0]));
+  // 面板里不出现密钥 / 令牌字样：清单是 App 侧可读的静态文件
+  assert.ok(!JSON.stringify(manifest).includes("token"));
+});
+
+test("记忆页与实体页的树不随数据变：首屏和拿到数据后是同一棵树", () => {
+  // 面板的 view() 在 data() 之前就要交出整棵树，所以按数据决定「要不要这块」
+  // 的地方，首屏会先按默认值定形，之后数据推来了也只是填绑定——空状态块就会
+  // 和有数据的列表同时挂在屏幕上。这里把两棵树直接比对，锁住结构稳定。
+  const empty = JSON.stringify(buildView(state({ rowsCount: 0, entityTotal: 0 })));
+  const filled = JSON.stringify(buildView(state({ rowsCount: 20, entityTotal: 12 })));
+  assert.equal(empty, filled, "视图结构仍然跟着数据走，首屏会留下残影");
+  assert.ok(!empty.includes('"type":"emptyState"'), "记忆 / 实体页不再用数据决定空状态块");
+});
+
+test("翻页是 App 原生的两段 segmented：一行铺满，不折行也不叠按钮", () => {
+  const nodes = walk(buildView(state()));
+  const pager = nodes.find((node) => node.type === "segmented" && node.bind === "data.pagePick");
+  assert.ok(pager, "缺少翻页 segmented");
+  assert.deepEqual(
+    pager.options.map((option) => option.label),
+    ["上一页", "下一页"],
+  );
+  assert.deepEqual(
+    pager.options.map((option) => option.value),
+    ["prev", "next"],
+  );
+  assert.equal(pager.onChange.id, "page");
+  // 页码文案挂在 label 上（必绘），不再单独占一行。
+  assert.deepEqual(pager.label, { $: "data.pageText" });
+
+  // 回归：曾经用两个 stack + chips 做左右对齐，右列在真机上渲染失败
+  // （App 显示「这部分无法显示」），所以翻页只能是单个节点。
+  assert.equal(
+    nodes.filter((node) => node.type === "chips" && node.bind === "data.pagePick").length,
+    0,
+    "翻页又回到了 chips 方案",
+  );
+  const folded = nodes.filter(
+    (node) => node.type === "actions" && (node.items ?? []).some((item) => item.action?.id === "page"),
+  );
+  assert.equal(folded.length, 0, "翻页按钮还在 actions 里：窄屏会被折成上下两行");
+});

package/test/embedding-ready.test.js

@@ -159,10 +159,12 @@ test("reindexMissing: 逐行回填并统计 indexed/skipped，有成功才记模
 test("reindexMissing: 未启用时直接返回 0/0，不碰 store", async () => {
   const { embedder } = make({ ...FULL, enabled: false });
   const result = await embedder.reindexMissing(50);
-  assert.deepEqual(result, { indexed: 0, skipped: 0 });
+  assert.deepEqual(result, { indexed: 0, failed: 0, skipped: 0 });
 });
 
-test("reindexMissing: 嵌入失败的行走 skipped，不算 indexed", async () => {
+test("reindexMissing: 嵌入失败的行走 failed，不算 indexed、也不算 skipped", async () => {
+  // #604：`skipped = rows.length - indexed` 把「试过没拿到向量」和「压根没碰」
+  // 混成一个数。每一行都被尝试过，所以 skipped 必须是 0，失败单列。
   const writes = [];
   const embedder = createEmbedder({
     store: {
@@ -174,7 +176,35 @@ test("reindexMissing: 嵌入失败的行走 skipped，不算 indexed", async ()
   await withFetch(async () => ({ ok: false }), async () => {
     const result = await embedder.reindexMissing(50);
     assert.equal(result.indexed, 0);
-    assert.equal(result.skipped, 1, "嵌入失败的行走 skipped，不算 indexed");
+    assert.equal(result.failed, 1, "试过但没拿到向量 → failed");
+    assert.equal(result.skipped, 0, "选择器选中了它，所以它没有被跳过");
+  });
+});
+
+test("reindexMissing: 一行写入抛错不中断其余行，且计入 failed", async () => {
+  // 注意：这里抛错的不能是 embedding 请求 —— embedTextDetailed 把网络错误吞成
+  // request-failed:network，永远不抛。真正会让这个 catch 跑起来的是写库失败
+  // （约束冲突、磁盘满），所以用 setEmbedding 抛。
+  const writes = [];
+  const embedder = createEmbedder({
+    store: {
+      setEmbedding: (id, v) => {
+        if (id === "m1") throw new Error("SQLITE_CONSTRAINT");
+        writes.push({ id, v });
+      },
+      needsEmbedding: () => [
+        { id: "m1", title: "t1", content: "a" },
+        { id: "m2", title: "t2", content: "b" }
+      ]
+    },
+    settings: { getVectorConfig: () => FULL },
+    logger: { info() {}, warn() {} }
+  });
+  await withFetch(async () => okResponse([1, 0]), async () => {
+    const result = await embedder.reindexMissing(50);
+    assert.equal(result.failed, 1, "写库失败的那行算 failed");
+    assert.equal(result.indexed, 1, "后面那行仍然被处理，循环没有中断");
+    assert.equal(writes.length, 1);
   });
 });
 

package/test/entities.test.js

@@ -296,6 +296,79 @@ test("extractor writes entities, attrs and relations from mock LLM output", asyn
   store.close();
 });
 
+test("extractor refuses to write affective_context, which belongs to the sleep phase", async () => {
+  // #619：affective_context 只有一个写入者——sleep 的 affective 相位。实体抽取发生
+  // 在写入当下，手里没有会话边界，判不了「一次场合」和「反复出现的特质」，写进去的
+  // 只会是一条没有 emotion/attribution/sessionCount 的半成品边，同一张表两种 schema。
+  // 所以抽取器把它当未知类型拒收，而不是当一等公民放行。
+  const store = openStore();
+  const memory = store.save({ type: "history", title: "答辩前一晚", content: "答辩前一晚他很焦虑", importance: 3 });
+  const warnings = [];
+  const logger = { warn: (msg) => warnings.push(String(msg)), info: () => {} };
+  const callLLM = jsonLLM({
+    entities: [
+      { name: "他", type: "person", attrs: [] },
+      { name: "答辩", type: "concept", attrs: [] }
+    ],
+    relations: [{ from: "他", to: "答辩", type: "affective_context" }]
+  });
+  const result = await extractEntities(memory, { store, config: {}, callLLM, logger });
+  assert.equal(result.ok, true);
+  assert.equal(result.relations.length, 0);
+  assert.deepEqual(result.rejectedRelationTypes, ["affective_context"]);
+  assert.equal(warnings.length, 1);
+  assert.match(warnings[0], /affective_context/);
+  assert.equal(store.getRelations(store.findEntityByName("他").id).length, 0);
+  store.close();
+});
+
+test("extractor rejects unknown relation types instead of silently downgrading to related_to", async () => {
+  // 变异自证：把 sanitizeRelationType 改回 `return "related_to"` 兜底，这条必红
+  // ——既会多落一条假边，rejectedRelationTypes 也会变空、warn 不再触发。
+  const store = openStore();
+  const memory = store.save({ type: "project", title: "混入未知类型", content: "A 对 B 有种奇怪的关系", importance: 3 });
+  const warnings = [];
+  const logger = { warn: (msg) => warnings.push(String(msg)), info: () => {} };
+  const callLLM = jsonLLM({
+    entities: [
+      { name: "A", type: "concept", attrs: [] },
+      { name: "B", type: "concept", attrs: [] }
+    ],
+    relations: [
+      { from: "A", to: "B", type: "feels_weird_about" },
+      { from: "A", to: "B", type: "related_to" }
+    ]
+  });
+  const result = await extractEntities(memory, { store, config: {}, callLLM, logger });
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.rejectedRelationTypes, ["feels_weird_about"]);
+  assert.equal(warnings.length, 1);
+  assert.match(warnings[0], /feels_weird_about/);
+  const rels = store.getRelations(store.findEntityByName("A").id);
+  assert.equal(rels.length, 1, "only the legitimate relation lands");
+  assert.equal(rels[0].relation_type, "related_to");
+  store.close();
+});
+
+test("extractor drops a relation whose type is not even a string", async () => {
+  const store = openStore();
+  const memory = store.save({ type: "project", title: "空类型", content: "A 和 B 有联系", importance: 3 });
+  const callLLM = jsonLLM({
+    entities: [
+      { name: "A", type: "concept", attrs: [] },
+      { name: "B", type: "concept", attrs: [] }
+    ],
+    relations: [{ from: "A", to: "B" }]
+  });
+  const result = await extractEntities(memory, { store, config: {}, callLLM });
+  assert.equal(result.ok, true);
+  assert.equal(result.relations.length, 0);
+  assert.deepEqual(result.rejectedRelationTypes, ["undefined"]);
+  assert.deepEqual(store.getRelations(store.findEntityByName("A").id), []);
+  store.close();
+});
+
+
 test("resolveEntity dedups: re-extracting the same name bumps mention_count", async () => {
   const store = openStore();
   const memory = store.save({ type: "preference", title: "工具", content: "用 Vite", importance: 3 });

package/test/forget-corrections.test.js

@@ -0,0 +1,70 @@
+// #532 选择性遗忘 × 事实更正的结构性回归锁。
+//
+// 现象（议题主楼）：更正两个事实 → 只忘一个 → 保留的那个答回更正前的旧值。
+// 根因是三段契约的接缝（docs/FORGET.md §1）：更正由蒸馏落成新行（三元组去重不
+// 命中、dream 冲突裁决阈值门控未运行）→ 旧行与新行之间没有持久失效关系 →
+// memory_forget 按行抑制，合流在同一行里的其他事实连带退出可见面，旧值行成了
+// 唯一幸存载体。
+//
+// 本文件锁两件事：
+//   ① 存储层合成轨迹（零 LLM）：两行并存、遗忘新行、旧行原样幸存——这是现象的
+//     存储层等价物。**机制修复落地时 ⑤ 的断言应当翻转**：更正行写入后旧行要么
+//     被记上失效关系、要么退出活跃面；注释里写明翻转条件，防止它被当成「永远
+//     该绿」的现状锁读。
+//   ② memory_forget 的工具描述必须带行粒度警示：模型无从得知「请求的语义粒度
+//     （一个事实）」与「工具的能力粒度（一行）」之间的落差，除非描述告诉它。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+
+test("#532 合成轨迹：更正落新行、遗忘新行、旧行原样幸存（机制修复落地时 ⑤ 翻转）", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  try {
+    // ① 原始陈述（对话 A 的蒸馏产物：颜色 + 时间合流一行）
+    const r1 = service.saveWithDedupe({
+      type: "preference", title: "纸模工具的收纳与整理",
+      content: "纸模工具放在雾蓝色收纳盒，每周三晚上八点整理一次", importance: 3
+    });
+    // ② 更正（对话 B：蒸馏器另起标题 → (type,title,scope) 三元组不命中 → 新行）
+    const r2 = service.saveWithDedupe({
+      type: "preference", title: "收纳盒颜色与整理时间的更正",
+      content: "收纳盒换成浅橙色，整理时间改为每周六上午九点", importance: 3
+    });
+    assert.notEqual(r1.memory.id, r2.memory.id, "标题不同 → 去重不命中，更正落成新行");
+    // ③ 结构断言：两行同时活跃，二者之间没有任何失效链接（本车道基线未含 #275
+    //   的 capacityStats，直接查列）
+    const activeCount = () => store.db.prepare("SELECT COUNT(*) AS n FROM memories WHERE forgotten = 0 AND archived = 0").get().n;
+    assert.equal(activeCount(), 2, "更正不淘汰旧行（dream 未运行的阈值下无失效关系）");
+    // ④ 「忘掉颜色」＝按行遗忘新值行（模型在可见行里看到的颜色载体）
+    service.setForget(r2.memory.id, true);
+    // ⑤ 现象复现：新值行退出可见面后，旧值行仍是唯一幸存载体——这正是 #532
+    //    「保留的更正事实答回旧值」的存储层等价物。机制修复（写侧更正失效关系 /
+    //    dream 触发前移，见 docs/FORGET.md §3）落地时翻转：旧行应被记上失效关系
+    //    或退出活跃面，断言改为不存在「幸存的旧值行」。
+    assert.equal(store.getById(r1.memory.id).forgotten, false, "旧行从未被任何机制波及（toRow 把列归一成 boolean）");
+    assert.match(store.getById(r1.memory.id).content, /每周三晚上八点/, "旧值仍在召回面");
+    // 被抑制的行可恢复（接口契约：行粒度遗忘不是删除）——恢复后两行回到并存
+    // 状态：失效关系的缺位不因遗忘/恢复而改变。
+    service.setForget(r2.memory.id, false);
+    assert.equal(activeCount(), 2);
+  } finally {
+    store.close();
+  }
+});
+
+test("memory_forget 的工具描述必须带行粒度警示（#532 对话 5 的模型误用直接对策）", () => {
+  const registered = [];
+  const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
+  createTools(ctx, { getById: () => undefined }, {}, undefined);
+  const forget = registered.find((d) => d.name === "memory_forget");
+  assert.ok(forget, "memory_forget 必须注册");
+  // 锁「语义」不锁逐字：描述必须让模型知道抑制按行、合流事实连带退出、
+  // 请求只针对一个事实时先看行内容或拆分。防的回归是有人把描述改回
+  // 「只说单条抑制」，模型在「忘掉 X」请求下重新对合流行整条下手。
+  const desc = String(forget.description || "");
+  assert.match(desc, /per ROW/i, "描述必须写明抑制粒度是行");
+  assert.match(desc, /memory_update|inspect|say in your reply/i, "描述必须给出合流行下的替代动作");
+});

package/test/graph-api.test.js

@@ -207,3 +207,127 @@ test("ego 2-hop traversal work is bounded by limit, not by graph size (#409)", a
   // 250ms（≈4× 实测最坏值）只为兜住数量级级别的性能崩塌（#409）。
   assert.ok(ms < 250, `2-hop query took ${ms.toFixed(1)}ms — the work bound above is the lock; 250ms is only an outlier guard`);
 });
+
+// #619 可见化 B：情感边的 metadata 必须原样出 API。
+// 这条边上的全部信息量（情绪 / 谁对谁 / 几个场合 / 几条证据）都只存在 metadata 里，
+// 上一版这里只映射 id/from/to/relation_type/memory_id/created_at/weight/source，于是
+// 数据在库里有、在 store.toRelation 里也有，却在最后一跳被丢掉——面板上看起来就是
+// 「这个功能没做」。所以这里钉的不是「字段存在」，而是「一个不认识的字段也能穿过去」。
+test("#619 ego edges carry relation metadata through untouched", async () => {
+  const { routes, service } = setup();
+  const person = service.createEntity({ name: "桉桉", type: "person" });
+  const target = service.createEntity({ name: "答辩", type: "concept" });
+  const meta = {
+    emotion: "焦虑",
+    attribution: "occasion",
+    why: "答辩前一晚睡不着",
+    evidence: ["m-1", "m-2"],
+    sessionCount: 2,
+    model: "mock:affective-model",
+    runId: "run-1",
+    // 故意塞一个现在没人认识的字段：API 层不许按白名单裁剪，否则下一个新字段
+    // 又会「写进去了但看不见」，这正是这一轮要修的那类静默。
+    futureField: { nested: [1, 2, 3] }
+  };
+  service.saveRelation({
+    from_entity: person.id,
+    to_entity: target.id,
+    relation_type: "affective_context",
+    memory_id: "m-1",
+    source: "llm",
+    metadata: meta
+  });
+
+  const res = new FakeRes();
+  await graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego")
+    .handler(req("/api/dsh-mneme/semantic/graph/ego?entity=桉桉&depth=1"), res);
+  assert.equal(res.statusCode, 200);
+  const edge = JSON.parse(res.body).edges.find((e) => e.relation_type === "affective_context");
+  assert.ok(edge, "the affective edge is on the ego graph");
+  assert.deepEqual(edge.metadata, meta, "metadata passes through field for field, including unknown ones");
+});
+
+// 反方向同样要钉：没有 metadata 的边给 null，不给 {}。
+// 前端要靠这个区分「老边本来就没有情绪」和「有 metadata 但情绪字段丢了」——
+// 给空对象会让两种情形在界面上长得一模一样。
+test("#619 ego edges without metadata report null, not an empty object", async () => {
+  const { routes, service } = setup();
+  const map = buildChain(service, ["A", "B"]);
+  assert.ok(map.size === 2);
+  const res = new FakeRes();
+  await graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego")
+    .handler(req("/api/dsh-mneme/semantic/graph/ego?entity=A&depth=1"), res);
+  assert.equal(res.statusCode, 200);
+  const edge = JSON.parse(res.body).edges[0];
+  assert.equal(edge.metadata, null, "absent metadata is null so the UI can tell it apart from a populated one");
+});
+
+// #619 可见化 C：情绪归因一览。ego 只能从某个实体往外看，回答不了「库里有
+// 哪些情绪」。这条路由是全局的反向视角，三条断言各自钉一件会骗人的事。
+test("#619 affective overview groups by person, target, emotion and keeps occasion apart from trait", async () => {
+  const { routes, service } = setup();
+  const person = service.createEntity({ name: "桉桉", type: "person" });
+  const defense = service.createEntity({ name: "答辩", type: "concept" });
+  const interview = service.createEntity({ name: "面试", type: "concept" });
+  // 同一情绪、两个对象、两个归属档：四组，不能被合掉任何一组。
+  service.saveRelation({
+    from_entity: person.id, to_entity: defense.id, relation_type: "affective_context",
+    memory_id: "m-1", source: "llm",
+    metadata: { emotion: "焦虑", attribution: "occasion", sessionCount: 1, evidence: ["m-1"] }
+  });
+  service.saveRelation({
+    from_entity: person.id, to_entity: interview.id, relation_type: "affective_context",
+    memory_id: "m-2", source: "llm",
+    metadata: { emotion: "焦虑", attribution: "occasion", sessionCount: 1, evidence: ["m-2"] }
+  });
+  service.saveRelation({
+    from_entity: person.id, to_entity: defense.id, relation_type: "affective_context",
+    memory_id: "m-3", source: "llm",
+    metadata: {
+      emotion: "焦虑", attribution: "trait", sessionCount: 1, traitSessionCount: 3,
+      promotedToTrait: true, evidence: ["m-1", "m-3", "m-4"]
+    }
+  });
+  // 没有情绪名的边：不进聚合，但要被计入 skippedEdges 而不是消失。
+  service.saveRelation({
+    from_entity: person.id, to_entity: defense.id, relation_type: "affective_context",
+    memory_id: "m-5", source: "llm", metadata: { attribution: "occasion" }
+  });
+  // 别的类型不受影响。
+  service.saveRelation({ from_entity: person.id, to_entity: defense.id, relation_type: "uses" });
+
+  const res = new FakeRes();
+  await graphRoute(routes, "/api/dsh-mneme/semantic/graph/affective")
+    .handler(req("/api/dsh-mneme/semantic/graph/affective"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.items.length, 3, "两个对象 × occasion + 一个 trait = 三组");
+  assert.equal(data.skippedEdges, 1, "没有情绪名的边要单独计数，不能静默消失");
+
+  const trait = data.items.find((i) => i.attribution === "trait");
+  assert.ok(trait, "trait 组必须存在");
+  assert.equal(trait.person, "桉桉");
+  assert.equal(trait.target, "答辩");
+  assert.equal(trait.traitSessionCount, 3, "trait 要能说出跨了几个独立会话");
+  assert.equal(trait.promotedToTrait, true);
+  assert.equal(data.items[0].attribution, "trait", "trait 排在 occasion 前面");
+
+  const occasions = data.items.filter((i) => i.attribution === "occasion");
+  assert.equal(occasions.length, 2);
+  assert.deepEqual(occasions.map((o) => o.target).sort(), ["答辩", "面试"],
+    "同一情绪对不同对象是两组，不能被合并");
+});
+
+// 读不到的时候必须是 500，不能给空列表——空列表在面板上跟「你从没记过情绪」
+// 长得一模一样，而这两件事对用户的含义正好相反。
+test("#619 affective overview reports 500 when the store cannot answer", async () => {
+  const { routes, service } = setup();
+  const original = service.relationsByType;
+  service.relationsByType = undefined;
+  const res = new FakeRes();
+  await graphRoute(routes, "/api/dsh-mneme/semantic/graph/affective")
+    .handler(req("/api/dsh-mneme/semantic/graph/affective"), res);
+  assert.equal(res.statusCode, 500, "取不到就是取不到，不能假装是空的");
+  assert.equal(JSON.parse(res.body).error, "unavailable");
+  service.relationsByType = original;
+});

package/test/hot-memory.test.js

@@ -209,3 +209,51 @@ test("roundsFromEvents with an empty surface yields no rounds (model sees nothin
   const events = [userEvent(1, "问题"), assistantEvent(2, "回答")];
   assert.equal(roundsFromEvents(events, 5, new Set()).length, 0);
 });
+
+// --- Issue #637：omitPendingRound —— 注入侧不回放「正在组装的这一轮」 ---
+
+test("omitPendingRound drops the trailing in-flight round (the #637 empty-A churn source)", () => {
+  // 本轮刚开了头（提问已落日志、回答还没来）：默认行为渲染空 A: 行——
+  // 宿主「文本变了就追加快照」的契机会让回答落地后这一行抖成正文、再多追一份。
+  const events = [userEvent(1, "第一问"), assistantEvent(2, "第一答"), userEvent(3, "第二问")];
+  const rounds = roundsFromEvents(events, 5, null, { omitPendingRound: true });
+  assert.equal(rounds.length, 1, "the in-flight round is not replayed");
+  assert.equal(rounds[0].query, "第一问");
+  assert.ok(!JSON.stringify(rounds).includes("第二问"), "the current turn's query never reaches hot memory");
+});
+
+test("omitPendingRound keeps a closed round — the block changes exactly once per turn", () => {
+  // 回答落地（轮闭合）是热块在一轮内唯一该变化的时刻：此前所有组装看到同一份
+  // 文本，此刻变成「历史轮 + 刚闭合的轮」→ 宿主恰好追一份快照。
+  const open = [userEvent(1, "第一问"), assistantEvent(2, "第一答"), userEvent(3, "第二问")];
+  const closed = [userEvent(1, "第一问"), assistantEvent(2, "第一答"), userEvent(3, "第二问"), assistantEvent(4, "第二答")];
+  const before = roundsFromEvents(open, 5, null, { omitPendingRound: true });
+  const after = roundsFromEvents(closed, 5, null, { omitPendingRound: true });
+  assert.equal(before.length, 1);
+  assert.equal(after.length, 2);
+  assert.deepEqual(after[1], { query: "第二问", response: "第二答" });
+  // 轮与轮之间（下一轮开头的组装）块不再变：第三轮的提问此刻是 pending，被省略。
+  const nextTurn = roundsFromEvents([...closed, userEvent(5, "第三问")], 5, null, { omitPendingRound: true });
+  assert.deepEqual(nextTurn, after, "the block is stable across the turn boundary — no extra snapshot");
+});
+
+test("omitPendingRound only touches the tail — mid-log abandoned rounds still render empty A", () => {
+  // 双发消息（第二问把第一问顶掉）：第一问是已被放弃的历史提问，渲染成空 A:
+  // 是既有语义，不属于「正在组装的这一轮」。
+  const events = [userEvent(1, "被顶掉的问题"), userEvent(2, "第二轮的问题"), assistantEvent(3, "第二轮的回答"), userEvent(4, "第三问")];
+  const rounds = roundsFromEvents(events, 5, null, { omitPendingRound: true });
+  assert.deepEqual(rounds, [
+    { query: "被顶掉的问题", response: "" },
+    { query: "第二轮的问题", response: "第二轮的回答" }
+  ]);
+});
+
+test("omitPendingRound works with the surface projection (rewind-shadowed tail not special)", () => {
+  // 撤回遮蔽过的事件不参与配对，也不影响「尾部 pending」的判定：可见面上最后
+  // 一条 user/message 是第二问，它才是本轮。
+  const events = [userEvent(1, "已被撤回的问题"), assistantEvent(2, "已被撤回的回答"), userEvent(3, "第一问"), assistantEvent(4, "第一答"), userEvent(5, "第二问")];
+  const visible = new Set([3, 4, 5]);
+  const rounds = roundsFromEvents(events, 5, visible, { omitPendingRound: true });
+  assert.deepEqual(rounds, [{ query: "第一问", response: "第一答" }]);
+});
+