@modusensus/dsh-mneme 0.8.11 → 0.8.12

package/test/graph-passive-confirm.test.js

@@ -0,0 +1,92 @@
+// issue #24 块4 被动确认（graphPassiveConfirm）测试。
+// 覆盖：默认关=零行为变化 / 开启=命中记忆的关联边 bump / heat 关但 passive
+// 开仍 bump（独立闸门）/ bump 只加不减封顶 / 无关联边的记忆触达安全降级。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+function putMem(store, service, { title, content, importance = 3 }) {
+  return service.saveWithDedupe({ type: "project", title, content, importance }).memory;
+}
+
+function linkRelToMem(store, { fromName, toName, memoryId, source = "llm" }) {
+  const a = store.findEntityByName(fromName) ?? store.createEntity({ name: fromName, type: "technology" });
+  const b = store.findEntityByName(toName) ?? store.createEntity({ name: toName, type: "technology" });
+  return store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "uses", memory_id: memoryId, source });
+}
+
+/** 跑一次检索（内部 touchRecalled 触发触达），返回 rows。 */
+async function searchOnce(service, query) {
+  return service.searchMemories(query, { mode: "auto" });
+}
+
+test("graphPassiveConfirm=false (default): touched memory does NOT bump relation weight", async () => {
+  const { store, service } = setup();
+  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  const rel = linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
+  assert.equal(rel.weight, 0.4);
+  await searchOnce(service, "数据库迁移");
+  // 默认关：检索触达不 bump（weight 保持 0.4）。
+  assert.equal(store.getRelationsByMemory(mem.id)[0].weight, 0.4, "weight unchanged by default");
+  store.close();
+});
+
+test("graphPassiveConfirm=true: touched memory bumps its linked relation weight", async () => {
+  const { store, service } = setup({ graphWeightEnabled: true, graphPassiveConfirm: true, graphWeightDelta: 0.1 });
+  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  const rel = linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
+  assert.equal(rel.weight, 0.4);
+  const rows = await searchOnce(service, "数据库迁移");
+  assert.ok(rows.some((r) => r.id === mem.id), "memory surfaced");
+  assert.ok(store.getRelationsByMemory(mem.id)[0].weight > 0.4, "weight bumped after touch");
+  store.close();
+});
+
+test("heatEnabled=false does NOT gate passive confirm (independent gates)", async () => {
+  const { store, service } = setup({ heatEnabled: false, graphWeightEnabled: true, graphPassiveConfirm: true, graphWeightDelta: 0.1 });
+  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
+  await searchOnce(service, "数据库迁移");
+  assert.ok(store.getRelationsByMemory(mem.id)[0].weight > 0.4, "bumped even with heat off");
+  // 但 touchLastAccess 不写（heat 关的既有语义保留：last_accessed_at 仍为空）。
+  assert.equal(store.getById(mem.id).last_accessed_at, undefined);
+  store.close();
+});
+
+test("repeated touches cap at 1.0 (never exceeds)", () => {
+  const { store } = setup();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const rel = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm" }); // 0.4
+  for (let i = 0; i < 5; i++) {
+    store.bumpRelationWeight(rel.id, 0.3); // 0.4→0.7→1.0→1.0…
+  }
+  assert.equal(store.getRelations(a.id)[0].weight, 1.0, "capped at 1.0");
+  store.close();
+});
+
+// 总闸（块2 的 graphWeightEnabled）关着时被动确认不许生效——单开通道键就能演化
+// 边权的话，块2 立的「演化默认关」总闸形同虚设。
+test("graphWeightEnabled=false gates passive confirm (master switch)", async () => {
+  const { store, service } = setup({ graphPassiveConfirm: true, graphWeightDelta: 0.1 });
+  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
+  await searchOnce(service, "数据库迁移");
+  assert.equal(store.getRelationsByMemory(mem.id)[0].weight, 0.4, "master switch off → weight untouched");
+  store.close();
+});
+
+test("memory without relations survives touch (no crash)", async () => {
+  const { store, service } = setup({ graphPassiveConfirm: true });
+  const mem = putMem(store, service, { title: "孤立条", content: "无关联边" });
+  await searchOnce(service, "孤立条");
+  assert.ok(store.getById(mem.id), "memory still present");
+  store.close();
+});

package/test/graph-weight-evolution.test.js

@@ -0,0 +1,105 @@
+// issue #24 块2 权重演化（entity_relations weight + source + bump）测试。
+// 覆盖：来源→初值映射（manual/tag/llm）/ weight 显式优先 / toRelation 回读 /
+// bumpRelationWeight 只加不减封顶 / extractor 建 llm 边 / 四来源全映射落表。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore, RELATION_SOURCE_DEFAULTS } from "../src/store.js";
+
+function makeStore() {
+  return createStore(":memory:");
+}
+
+test("RELATION_SOURCE_DEFAULTS matches issue #24 mapping", () => {
+  assert.equal(RELATION_SOURCE_DEFAULTS.manual, 1.0);
+  assert.equal(RELATION_SOURCE_DEFAULTS.confirmed, 1.0);
+  assert.equal(RELATION_SOURCE_DEFAULTS.tag, 0.3);
+  assert.equal(RELATION_SOURCE_DEFAULTS.llm, 0.4);
+});
+
+test("saveRelation maps source to initial weight", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const manual = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "manual" });
+  const tag = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "y", source: "tag" });
+  const llm = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "z", source: "llm" });
+  assert.equal(manual.weight, 1.0);
+  assert.equal(manual.source, "manual");
+  assert.equal(tag.weight, 0.3);
+  assert.equal(tag.source, "tag");
+  assert.equal(llm.weight, 0.4);
+  assert.equal(llm.source, "llm");
+});
+
+test("explicit weight overrides source mapping", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm", weight: 0.7 });
+  assert.equal(r.weight, 0.7);
+});
+
+test("toRelation round-trips weight and source via getRelations", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "tag" });
+  const rels = store.getRelations(a.id);
+  assert.equal(rels.length, 1);
+  assert.equal(rels[0].weight, 0.3);
+  assert.equal(rels[0].source, "tag");
+});
+
+test("bumpRelationWeight raises weight, caps at 1.0, never lowers", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm" });
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);  // 0.4→0.6→0.8→1.0
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);
+  assert.equal(store.getRelations(a.id)[0].weight, 1.0, "capped");
+  // 不存在的关系：幂等 false
+  assert.equal(store.bumpRelationWeight("no-such-id"), false);
+});
+
+test("legacy relation rows migrate with manual weight default (no crash)", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  // 直接走底层 SQL 模拟旧库行（不带 weight/source 列 —— 但新 schema 已含列，
+  // 所以这条主要验证 migration 幂等路径不崩 + 默认映射成立）。
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x" });
+  assert.equal(r.weight, 1.0, "default source manual → weight 1.0");
+  assert.equal(r.source, "manual");
+});
+
+// ---- #24 复审回归（review findings 逐条落锁）--------------------------------
+
+// 「只加不减」是存储接口自己的契约：负/非法增量必须在存储边界被拒（false +
+// 权值不动），不能把下界托付给调用方的配置范围——旧写法 bumpRelationWeight(id,
+// -0.2) 能把 0.4 敲到 0.2。
+test("bumpRelationWeight rejects negative and non-finite increments (只加不减)", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm" });
+  for (const bad of [-0.2, -1, Number.NaN, Number.POSITIVE_INFINITY, "0.2"]) {
+    assert.equal(store.bumpRelationWeight(r.id, bad), false, `increment ${String(bad)} must be refused`);
+    assert.equal(store.getRelations(a.id)[0].weight, 0.4, `weight must not move on increment ${String(bad)}`);
+  }
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true, "a valid increment still lands");
+  assert.ok(Math.abs(store.getRelations(a.id)[0].weight - 0.6) < 1e-9, "0.4 + 0.2 lands at 0.6 (float-safe)");
+});
+
+// 来源查询只认映射表的自有键：src="constructor"/"toString" 会命中原型链上的函数，
+// 旧写法把它当权重绑进 SQL（函数不可绑定 → 整条写入抛错）而不是回退默认 1.0。
+test("an inherited source name falls back to the default weight", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "constructor" });
+  assert.equal(r.weight, 1.0, "prototype-chain names must fall back to 1.0, not a function");
+  assert.equal(r.source, "constructor", "source is recorded verbatim");
+});

package/test/scope-inject-soft.test.js

@@ -0,0 +1,106 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// issue #339 / E7 考卷补齐：A2 软加权（foreign ×0.5 / 命中 ×1.25）此前只作用于
+// searchMemories——E7 实测「explicit 标注 + 软档」的注入集与无标注逐条相同
+// （80/80），主泄露面上软档形同虚设。本文件锁注入通道的软加权语义：
+//   - softScope 激活（scopeEnabled + scope 至少一维可解析）→ foreign 行在层内
+//     数值积上 ×0.5，压不过同档自己行；未标注行同列吃 BOOST 不被压制；
+//   - flag 关 / scope 两维全空 → 注入序与改动前逐字节一致（锁平价）；
+//   - strictScope 硬过滤先行，被滤行不会被二次降权；
+//   - 加权后的序流入 pin 池选取（pin 拿到的是加权后次序）。
+
+function setup(config) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+const SCOPE_ME = { agent_scope: "me", workspace_scope: null };
+
+test("injectCandidates soft weight demotes explicit foreign rows below same-importance own rows", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: false });
+  // 同 importance 档（E7 的同档设计）：无软加权时全靠插入序，foreign 在前。
+  store.save({ type: "decision", title: "foreign-a", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "mine-a", content: "x", importance: 4, agent_scope: "me", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "foreign-b", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+
+  const injected = service.injectCandidates({ maxItems: 5, threshold: 3, scope: SCOPE_ME });
+  const titles = injected.map((m) => m.title);
+  // foreign ×0.5 = 2.0 < 自己 ×1.25 = 5.0：自己行第一；两条 foreign 同分，
+  // 相对序随 store.list 的同分序（updated_at），不锁。
+  assert.equal(titles[0], "mine-a");
+  assert.deepEqual(titles.slice(1).sort(), ["foreign-a", "foreign-b"]);
+});
+
+test("injectCandidates soft tier keeps unlabeled rows ranked with matches, not suppressed", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: false });
+  store.save({ type: "decision", title: "global", content: "x", importance: 4 });
+  store.save({ type: "decision", title: "foreign", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+
+  const injected = service.injectCandidates({ maxItems: 5, threshold: 3, scope: SCOPE_ME });
+  // 未标注 = 全局可见，与命中行同列（×1.25）而非被压到 foreign 之后。
+  assert.deepEqual(injected.map((m) => m.title), ["global", "foreign"]);
+});
+
+test("injectCandidates order is byte-identical when scopeEnabled is off or scope is anonymous", () => {
+  const seed = (store) => {
+    store.save({ type: "decision", title: "foreign-a", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+    store.save({ type: "decision", title: "mine-a", content: "x", importance: 4, agent_scope: "me", agent_scope_source: "explicit" });
+    store.save({ type: "decision", title: "global", content: "x", importance: 3 });
+  };
+  // flag 关：不传 scope（改动前后必须同序——锁平价）。
+  const off = setup({ scopeEnabled: false, strictScope: false });
+  seed(off.store);
+  // flag 开但身份两维全空：软加权门不激活，也不得改序。
+  const anon = setup({ scopeEnabled: true, strictScope: false });
+  seed(anon.store);
+
+  // 平价锁：两种情况的注入序必须一致（比较器与改动前逐字节相同）。
+  const baseline = off.service.injectCandidates({ maxItems: 5, threshold: 3 }).map((m) => m.title);
+  assert.deepEqual(
+    anon.service.injectCandidates({ maxItems: 5, threshold: 3, scope: { agent_scope: null, workspace_scope: null } }).map((m) => m.title),
+    baseline
+  );
+});
+
+test("strictScope hard filter runs before soft weighting: filtered rows are not double-demoted", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: true });
+  store.save({ type: "decision", title: "foreign", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "global", content: "x", importance: 3 });
+
+  const injected = service.injectCandidates({ maxItems: 5, threshold: 3, scope: SCOPE_ME });
+  // 硬墙先删 foreign；剩下的 global（未标注）吃 BOOST 保留——若软加权先跑会把
+  // foreign 压到后面再被删，成员虽同但语义不同；此处锁成员与顺序。
+  assert.deepEqual(injected.map((m) => m.title), ["global"]);
+});
+
+test("soft-weighted order feeds the pin pool (pin picks the weighted-first candidates)", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: false, pinnedInjectBudget: 1 });
+  // pin 池只收 constraint/preference——两条都用 preference，同档靠软加权分序。
+  store.save({ type: "preference", title: "foreign-pin", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "preference", title: "mine", content: "x", importance: 4, agent_scope: "me", agent_scope_source: "explicit" });
+
+  const pinnedStats = {};
+  const injected = service.injectCandidates({
+    maxItems: 5, threshold: 3, scope: SCOPE_ME, pinnedStats,
+  });
+  // 加权后 mine 在前：pin 池取的是加权后次序的第一条。
+  assert.equal(pinnedStats.shown, 1);
+  assert.equal(injected[0].title, "mine");
+});
+
+test("first-round BM25 fallback applies the soft weight (no query vector yet)", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: false });
+  // 同内容同长度（标题各 1 token 且不在查询词表）→ BM25 原始分相同；
+  // 未加权时同分序随 store.list（updated desc，foreign 后存先出）。
+  store.save({ type: "decision", title: "alpha", content: "plan the dinner party menu with care", importance: 4, agent_scope: "me", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "bravo", content: "plan the dinner party menu with care", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+
+  const injected = service.injectCandidates({
+    query: "dinner party menu", maxItems: 5, threshold: 3, scope: SCOPE_ME,
+  });
+  assert.equal(injected[0].title, "alpha", "BM25 hits are soft-weighted before the semantic-first merge");
+});

package/test/summarize.test.js

@@ -110,6 +110,25 @@ function toolResultEvent(text, isError, seq) {
   };
 }
 
+// DSH 0.2.x 内核对工具结果的实际投递形状：内核给的是 `role:"tool"` 消息本身，
+// content 里只有 `type:"text"` 块、isError 挂在消息上，不再有 tool-result 块。
+// 蒸馏曾只认旧块形状，于是真实会话里的工具输出与工具报错全部被静默丢弃。
+function toolRoleResultEvent(text, isError, seq) {
+  return {
+    seq,
+    type: "tool/result",
+    data: {
+      message: {
+        role: "tool",
+        source: { kind: "tool", callId: `call-${seq}` },
+        toolCallId: `call-${seq}`,
+        content: [{ type: "text", text }],
+        isError
+      }
+    }
+  };
+}
+
 function codeDispatchEvent(text, isError, seq) {
   return {
     seq,
@@ -143,6 +162,32 @@ test("parseSummaryJson extracts valid entries and skips malformed ones", () => {
   assert.equal(parsed[1].type, "preference");
 });
 
+// --- issue #339 / E8 考卷：JSON 崩溃窗口的 salvage（失败路径修复，默认开）-----
+// E8 实测 10-20% 的窗口输出了含约束的完整对象，只因中段一处语法错误被整窗
+// JSON.parse 拒收 → 生产行为 = 游标卡死 + 温度 0 重试同错 = 静默丢失。
+
+test("parseSummaryJson salvages complete objects from a malformed array (issue #339)", () => {
+  // E8 现场同款：闭合数组、中段对象含杂散引号（stray quote）。
+  const raw = `[
+    {"type":"constraint","title":"预算","content":"总额 $12,400","importance":4},
+    { " "type": "history", "title": "坏对象", "content": "语法错误" },
+    {"type":"preference","title":"硬件","content":"只要 brushed brass"}
+  ]`;
+  const parsed = parseSummaryJson(raw);
+  assert.equal(parsed.length, 2, "the broken middle object is dropped, both survivors kept");
+  assert.equal(parsed[0].content, "总额 $12,400");
+  assert.equal(parsed[1].title, "硬件");
+});
+
+test("parseSummaryJson salvage finding nothing stays a failure (no fake empty success)", () => {
+  // 只有一个语法坏掉的对象 → 救回 0 条：不得按「显式空数组」放行消费窗口。
+  const raw = `[
+    { " "type": "history", "title": "坏", "content": "语法错误" }
+  ]`;
+  const parsed = parseSummaryJson(raw);
+  assert.deepEqual(parsed, []);
+});
+
 test("subscribes to session/event when autoSummarize enabled", () => {
   const { events } = setup();
   assert.ok(events.some((e) => e.name === "session/event"));
@@ -673,6 +718,78 @@ test("invalid summary JSON leaves the seq window retryable", async () => {
   assert.equal(store.count(), 0, "the valid empty retry remains a no-op");
 });
 
+test("a JSON-crashed window with salvageable objects is recovered, consumed once, and audited (issue #339)", async (t) => {
+  const malformed = `[
+    {"type":"constraint","title":"预算","content":"总额 $12,400","importance":4},
+    { " "type": "history", "title": "坏对象", "content": "语法错误" },
+    {"type":"preference","title":"硬件","content":"只要 brushed brass"}
+  ]`;
+  const { events, service, store, calls, summarizer } = setup({ distillRateLimitIntervalMs: 0 }, {
+    stream() {
+      return (async function* () {
+        yield { type: "block-start", block: { type: "text" } };
+        yield { type: "text-delta", delta: malformed };
+        yield { type: "finish", kind: "ok" };
+      })();
+    }
+  });
+  t.after(() => { summarizer.dispose(); store.close(); });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-salvage",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("带语法错误的蒸馏窗口", 1), { seq: 2, type: "turn/end" }]
+  };
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(service.count(), 2, "the two intact objects are written, the broken one dropped");
+  const titles = service.list().map((m) => m.title).sort();
+  assert.deepEqual(titles, ["硬件", "预算"]);
+  assert.equal(calls.length, 1, "salvage consumed the window: no same-window retry");
+  const audit = service.listLlmAudits().find((r) => r.status === "success");
+  assert.ok(audit, "salvaged run is audited as a success");
+  assert.equal(audit.metadata?.json_salvaged, true, "salvage is observable in the audit trail");
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "the consumed window is not re-distilled");
+  assert.equal(service.count(), 2, "no duplicate writes on the second turn/end");
+});
+
+test("a JSON-crashed window with nothing salvageable stays retryable (issue #339)", async (t) => {
+  const hopeless = `[
+    { " "type": "history", "title": "坏", "content": "语法错误" }
+  ]`;
+  let attempt = 0;
+  const { events, service, store, calls, summarizer } = setup({ distillRateLimitIntervalMs: 0 }, {
+    stream() {
+      const output = attempt++ === 0 ? hopeless : `[
+        {"type":"history","title":"重试成功","content":"干净窗口","importance":3}
+      ]`;
+      return (async function* () {
+        yield { type: "block-start", block: { type: "text" } };
+        yield { type: "text-delta", delta: output };
+        yield { type: "finish", kind: "ok" };
+      })();
+    }
+  });
+  t.after(() => { summarizer.dispose(); store.close(); });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-salvage-none",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("救不回的窗口", 1), { seq: 2, type: "turn/end" }]
+  };
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(service.count(), 0, "zero salvage is not a fake success");
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 2, "the window stays retryable");
+  assert.equal(service.count(), 1);
+  assert.ok(service.listLlmAudits().some(
+    (r) => r.status === "error" && r.error_message === "invalid summary JSON"
+  ), "zero-salvage run keeps the error audit");
+});
+
 test("an all-invalid summary leaves the same window retryable until valid memories are saved", async (t) => {
   for (const invalid of [
     [{}],
@@ -960,6 +1077,47 @@ test("collects real tool result and code dispatch payloads with failure status",
   assert.match(transcript, /代码执行（成功）：代码执行结果/);
 });
 
+test("collects tool results delivered as role:tool messages, keeping the legacy block shape", async () => {
+  const { events, calls } = setup({ distillRateLimitIntervalMs: 0 });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-tool-role-shape",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      userMessage("检查工具结果两种形状", 1),
+      toolResultEvent("旧形状载荷", false, 2),
+      toolRoleResultEvent("新形状载荷", false, 3),
+      toolRoleResultEvent("TypeError: tool crashed", true, 4),
+      { seq: 5, type: "turn/end" }
+    ]
+  };
+
+  await handler(session, { seq: 5, type: "turn/end" });
+  const transcript = calls[0].messages.find((message) => message.role === "user").content[0].text;
+  assert.match(transcript, /工具结果（成功）：旧形状载荷/);
+  assert.match(transcript, /工具结果（成功）：新形状载荷/);
+  assert.match(transcript, /工具结果（失败）：TypeError: tool crashed/);
+});
+
+test("keeps prefix trimming for tool results delivered as role:tool messages", async () => {
+  const { events, calls } = setup({ distillRateLimitIntervalMs: 0 });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-tool-role-trim",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      userMessage("检查新形状截断", 1),
+      toolRoleResultEvent(`OUT_START ${"c".repeat(550)} OUT_END`, false, 2),
+      { seq: 3, type: "turn/end" }
+    ]
+  };
+
+  await handler(session, { seq: 3, type: "turn/end" });
+  const transcript = JSON.stringify(calls[0].messages);
+  assert.ok(transcript.includes("OUT_START"));
+  assert.ok(!transcript.includes("OUT_END"), "role:tool 结果同样走 500 字符前缀截断");
+});
+
 test("collects subagent delivery once across inbox and user-message views", async () => {
   const { events, calls } = setup({ distillRateLimitIntervalMs: 0 });
   const handler = events.find((e) => e.name === "session/event").fn;
@@ -1286,3 +1444,22 @@ test("issue#127: a dedupe lookup that yields nothing still lands the entry (neve
   assert.equal(store.count(), 1, "the entry is stored through the normal write path");
   assert.equal(store.all()[0].title, "必须落库");
 });
+
+test("parseSummaryJson salvage only takes direct children of the outer array (issue #339 review)", () => {
+  // 嵌套子数组里的对象不捞（模型没把它当顶层记忆产出），坏对象照旧丢弃。
+  const nested = `[[{"type":"history","title":"nested","content":"kept"}], { " "type":"history"}]`;
+  assert.deepEqual(parseSummaryJson(nested), []);
+});
+
+test("parseSummaryJson salvage does not turn string-embedded objects into memories (issue #339 review)", () => {
+  // 全数组解析失败（第二对象坏）+ 第一对象的 content 字符串里嵌着假记忆形状：
+  // 盲扫不得把属性值对象当独立记忆——外层对象整体才是直接子项。
+  const raw = `[
+    {"type":"history","title":"good","content":"note { \\"type\\": \\"history\\", \\"title\\": \\"fake\\" }"},
+    { " "type": "history", "title": "坏", "content": "x" }
+  ]`;
+  const parsed = parseSummaryJson(raw);
+  assert.equal(parsed.length, 1);
+  assert.equal(parsed[0].title, "good");
+  assert.match(parsed[0].content, /fake/);
+});

package/test/test-count-sync.test.js

@@ -0,0 +1,60 @@
+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 { applyTestCount, readTestCounts } from "../scripts/test-count-sync.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(HERE, "..");
+const REPO_ROOT = join(PKG_ROOT, "..");
+const READMES = [join(REPO_ROOT, "README.md"), join(PKG_ROOT, "README.md")];
+
+// 双 README 是发布门面，同一个数字在里面重复出现三到五次（一个 shields.io 徽章 +
+// 每条开发命令注释一处，root 是双语所以中英各一条）。它们必须永远同数——否则
+// 「这个项目有多少测试」取决于读者恰好看了哪一行。
+//
+// v0.8.11 实际漂移过：徽章 1437、四条注释留在 1431。本用例就是那次漂移的回归锁，
+// 跑在真实 README 上（不是 fixture），所以它能在发版前拦住同类漂移。
+test("双 README 的测试数处处一致（徽章与所有注释同数）", () => {
+  for (const f of READMES) {
+    const counts = readTestCounts(readFileSync(f, "utf8"));
+    const shapes = new Set(counts.map((c) => c.shape));
+    assert.ok(counts.length >= 2, `${f} 抽到的测试数出现处太少：${JSON.stringify(counts)}`);
+    assert.ok(shapes.has("badge"), `${f} 没抽到徽章：${JSON.stringify(counts)}`);
+    const values = [...new Set(counts.map((c) => c.value))];
+    assert.equal(values.length, 1, `${f} 测试数不一致：${JSON.stringify(counts)}`);
+  }
+});
+
+// v0.8.11 的真实漂移样本（徽章已 1437、注释仍 1431）。锁住「徽章 + 四种注释形状」
+// 全覆盖：少任何一种，就会有一处静默落后——release-prep.mjs 原先只覆盖徽章 URL，
+// 自动发版路径因此反倒成了漂移来源。
+test("applyTestCount 覆盖徽章与全部四种注释形状（真实漂移样本）", () => {
+  const drifted = [
+    '<img src="https://img.shields.io/badge/tests-1431%20passed-3E63DD?style=flat-square" alt="tests">',
+    "[![tests](https://img.shields.io/badge/tests-1431%20passed-success)](https://github.com/slow-stack/mneme)",
+    "npm test        # 1431 个测试",
+    "npm test           # 运行 1431 个测试",
+    "test/                 # 1431 个 node:test 测试（审计与三轴线压测不变量）",
+    "npm test        # 1431 tests"
+  ].join("\n");
+  const fixed = applyTestCount(drifted, 1437);
+  assert.ok(!/\b1431\b/.test(fixed), "仍有 1431 未被替换：\n" + fixed);
+  const counts = readTestCounts(fixed);
+  assert.equal(counts.length, 6, "六处出现都该被认出来：" + JSON.stringify(counts));
+  assert.deepEqual([...new Set(counts.map((c) => c.value))], [1437]);
+});
+
+test("applyTestCount 幂等：同一个数重复施加不再产生变化", () => {
+  const once = applyTestCount("tests-9%20passed-3E63DD\n# 9 个测试\n# 9 tests", 12);
+  assert.equal(applyTestCount(once, 12), once);
+});
+
+// 历史版本表里的「745 测试全绿」「790 通过」是各版本当时的真实记录（sync-test-badge
+// 的注释也写明了刻意不改它们）。替换规则只认徽章 URL 与 `#` 前缀注释两种形状，
+// 这条用例锁住那个边界，免得将来放宽正则把历史改写掉。
+test("applyTestCount 不碰历史版本表里的「N 测试全绿」", () => {
+  const history = "| **v0.8.0** | 745 测试全绿 |\n| **v0.7.9** | 790 通过 |\n| v0.2.7 | 263 |";
+  assert.equal(applyTestCount(history, 1437), history);
+});