@modusensus/dsh-mneme 0.12.0 → 0.13.0

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/image-memory.test.js

@@ -0,0 +1,171 @@
+// Issue #611：图片记忆端到端——一张图真的走进蒸馏转录。
+//
+// 单元用例（attachment-text.test.js）只证明「块 → 文本」这一步是对的。这一份锁的是
+// 另一半：**collectMessages 真的会把它拼进发给模型的那条消息里**，并且这个数会落进
+// 审计 metadata。改动前三处 textOf 都返回空串，图-only 消息连一行都不会产出——所以
+// 这条用例在旧代码上必然红，这是它存在的理由。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSummarizer } from "../src/summarize.js";
+
+function setup(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const events = [];
+  const calls = [];
+  const ctx = {
+    on(name, fn) {
+      events.push({ name, fn });
+      return () => {};
+    },
+    llm: {
+      stream(options) {
+        calls.push(options);
+        const json = JSON.stringify([
+          { type: "history", title: "看过一张截图", content: "用户发了一张 1543x983 的截图并问数据对比", importance: 3 }
+        ]);
+        return (async function* () {
+          yield { type: "block-start", block: { type: "text" } };
+          yield { type: "text-delta", delta: json };
+          yield { type: "block-end", block: { type: "text" } };
+          yield { type: "finish", kind: "ok" };
+        })();
+      }
+    }
+  };
+  const config = { autoSummarize: true, distillRateLimitIntervalMs: 0, ...over };
+  const summarizer = createSummarizer(ctx, service, config, {});
+  return { store, service, events, calls, summarizer };
+}
+
+function imageMessage(seq, text) {
+  const content = [];
+  if (text) content.push({ type: "text", text });
+  content.push({
+    type: "image",
+    attachment: {
+      attachmentId: "sha256:abc123",
+      mediaType: "image/png",
+      width: 1543,
+      height: 983,
+      name: "屏幕截图 2026-10-19 072000.png"
+    }
+  });
+  return { seq, type: "user/message", data: { source: { kind: "user" }, content } };
+}
+
+
+test("#611 图+文消息：蒸馏转录里同时有文字与图片占位", async () => {
+  const { events, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s611-mixed",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      imageMessage(1, "能有那种数据对比吗"),
+      { seq: 2, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(calls.length, 1, "这一窗应当发起一次蒸馏");
+  const transcript = calls[0].messages.find((m) => m.role === "user").content[0].text;
+  assert.ok(transcript.includes("能有那种数据对比吗"), "文字照旧进转录");
+  assert.ok(transcript.includes("[图:"), "图片必须留下占位，而不是消失");
+  assert.ok(transcript.includes("屏幕截图 2026-10-19 072000.png"), "文件名要能对上原始附件");
+  assert.ok(transcript.includes("1543x983"), "尺寸要留下");
+});
+
+test("#611 图-only 消息不再被整条丢弃（改动前窗口里一行都没有）", async () => {
+  const { events, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s611-image-only",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [imageMessage(1, null), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(calls.length, 1, "图-only 窗口现在也要蒸馏——旧版这里直接 noop");
+  const transcript = calls[0].messages.find((m) => m.role === "user").content[0].text;
+  assert.ok(transcript.includes("[图:"), "占位就是这一窗的全部可提炼内容");
+});
+
+test("#611 图片张数落进审计 metadata，off 档与静默丢弃可区分", async () => {
+  const { events, service } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s611-audit",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      imageMessage(1, "第一张"),
+      imageMessage(2, "第二张"),
+      { seq: 3, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 3, type: "turn/end" });
+
+  const row = service.listLlmAudits().find((r) => r.status === "success");
+  assert.ok(row, "成功行要存在");
+  assert.equal(row.metadata?.imageCount, 2, "两张图必须被数出来");
+});
+
+test("#611 没有图时不写 imageCount（零行为变化）", async () => {
+  const { events, service } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s611-no-image",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      { seq: 1, type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "只有文字" }] } },
+      { seq: 2, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+
+  const row = service.listLlmAudits().find((r) => r.status === "success");
+  assert.ok(row);
+  assert.equal(row.metadata?.imageCount, undefined, "没图就别写这个键，老档位逐字节不变");
+});
+test("#611 被挡掉的注入消息里的图不计入（CodeRabbit 2026-11-08 指出）", async () => {
+  // 计量的口径必须是「真正进了转录的图」，不是「窗口事件里出现过几张图」。
+  // 这条用例造一条带图的插件注入消息：它会被 publicTranscriptParts 整条挡掉
+  // （转录里没有它），所以 imageCount 不该把它算进去——否则审计会报「这窗有 1 张图」
+  // 而模型根本没看到这张图。
+  const { events, service, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const injected = {
+    seq: 1,
+    type: "user/message",
+    data: {
+      source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" },
+      content: [
+        { type: "text", text: "插件注入的机器内容" },
+        {
+          type: "image",
+          attachment: { attachmentId: "sha256:zzz", mediaType: "image/png", width: 10, height: 10, name: "不该被数.png" }
+        }
+      ]
+    }
+  };
+  const session = {
+    id: "s611-injected",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      injected,
+      { seq: 2, type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "真人的一句" }] } },
+      { seq: 3, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 3, type: "turn/end" });
+
+  assert.equal(calls.length, 1, "窗口里有真人文本，照常蒸馏");
+  const transcript = calls[0].messages.find((m) => m.role === "user").content[0].text;
+  assert.ok(transcript.includes("真人的一句"));
+  assert.ok(!transcript.includes("插件注入的机器内容"), "注入消息本来就不进转录");
+  const row = service.listLlmAudits().find((r) => r.status === "success");
+  assert.ok(row);
+  assert.equal(row.metadata?.imageCount, undefined, "被挡掉的注入消息里的图不该被数进去");
+});