@modusensus/dsh-mneme 0.12.0 → 0.13.0

package/test/sleep.test.js

@@ -5,6 +5,7 @@ import { Config } from "../src/config.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createVectorIndex } from "../src/vector-index.js";
+import { parseReceipt } from "../src/dream.js";
 
 // Mock embedder: every query maps to [1,0,0] so vectors are identical unless a
 // test pre-seeds a custom vector via vectorIndex.saveEmbedding.
@@ -818,3 +819,600 @@ test("issue#536 review ⑤: a batch that throws does not take the rest of the ru
   assert.equal(result.phases.conflicts.batches, 2, "抛错的批次不吞掉轮次的形状");
   store.close();
 });
+
+// ------------------------------------------------------------ affective (#619)
+
+// Only the affective phase gets a real answer; every other LLM phase says "[]"
+// so this file keeps testing one thing at a time.
+function affectiveCtx(payload) {
+  return {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "affective-model" }) },
+    llm: {
+      async *stream(options) {
+        const reply = options.purpose === "sleep-affective"
+          ? JSON.stringify(payload)
+          : "[]";
+        yield { type: "text-delta", index: 0, text: reply };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+function affectiveConfig(overrides = {}) {
+  return baseConfig({ sleepAffectiveEnabled: true, sleepPatternMinMemories: 10, ...overrides });
+}
+
+function linkSession(service, memoryId, sessionId) {
+  service.saveMemoryProvenance({ memoryId, sessionId, seqStart: 1, seqEnd: 2, createdAt: new Date().toISOString() });
+}
+
+test("sleep: affective phase stays off unless explicitly enabled", async () => {
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  makeMemory(service, "答辩前一晚", "答辩前一晚他很焦虑");
+  const ctx = affectiveCtx([]);
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(result.phases.affective.status, "skipped");
+  assert.equal(result.phases.affective.reason, "disabled");
+  store.close();
+});
+
+test("sleep: a one-session emotion lands as affective_context, and a trait claim is downgraded", async () => {
+  // 这条是整个 #619 的主 claim：模型说这是「稳定特质」，但证据只覆盖一个会话
+  // ⇒ 必须降级成场合边，绝不能铸出「他是焦虑的人」。
+  const { service, store } = setup();
+  const person = service.createEntity({ name: "桉桉", type: "person" });
+  const target = service.createEntity({ name: "答辩", type: "concept" });
+  const mem = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  linkSession(service, mem.id, "session-A");
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "trait", evidence: [mem.id], why: "提到答辩就焦虑" }
+  ]);
+  const result = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  const phase = result.phases.affective;
+  assert.equal(phase.status, "ok");
+  assert.equal(phase.downgraded, 1, "trait claim on one session must be counted as downgraded");
+  assert.equal(phase.traits, 0, "no trait pattern minted");
+  assert.equal(service.all().filter((m) => m.type === "pattern").length, 0, "nothing minted as a trait");
+  const rels = service.getRelations(person.id).filter((r) => r.relation_type === "affective_context");
+  assert.equal(rels.length, 1, "emotion landed as a relation instead");
+  assert.equal(rels[0].to_entity, target.id);
+  assert.equal(rels[0].source, "llm");
+  assert.equal(rels[0].metadata.attribution, "occasion");
+  assert.equal(rels[0].metadata.downgradedFrom, "trait");
+  store.close();
+});
+
+test("sleep: an emotion backed by enough independent sessions mints a trait pattern", async () => {
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const ids = [];
+  for (const session of ["s1", "s2", "s3"]) {
+    const mem = makeMemory(service, `答辩-${session}`, `第 ${session} 次答辩前都失眠`);
+    linkSession(service, mem.id, session);
+    ids.push(mem.id);
+  }
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "trait", evidence: ids, why: "三次独立答辩前都这样" }
+  ]);
+  const result = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  const phase = result.phases.affective;
+  assert.equal(phase.downgraded, 0, "three independent sessions is a real trait");
+  assert.equal(phase.traits, 1);
+  assert.equal(phase.applied, 1, "trait went through applyDecisions");
+  const patterns = service.all().filter((m) => m.type === "pattern");
+  assert.equal(patterns.length, 1, "one trait pattern minted");
+  assert.match(patterns[0].title, /稳定倾向/);
+  assert.match(patterns[0].title, /答辩/, "标题必须带对象，否则人对什么焦虑都看不出来");
+  assert.match(patterns[0].content, /3 个相互独立/);
+  store.close();
+});
+
+test("sleep: two different targets mint two patterns instead of one swallowing the other", async () => {
+  // #619 / Ephor 第 5 轮：标题原本不含 target，而 applyCreate 走
+  // saveWithDedupe，按 (type, title) 找同题行。于是「对答辩长期焦虑」与
+  // 「对面试长期焦虑」共用同一个标题，第二条被判为重复——不报错、不进
+  // failures、applied 还如实显示写入了。一条真实结论就这样静默消失，
+  // 正好落在本相位「降级不丢弃」这条原则的反面。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  service.createEntity({ name: "面试", type: "concept" });
+  const ids = { 答辩: [], 面试: [] };
+  for (const target of ["答辩", "面试"]) {
+    for (const session of ["s1", "s2", "s3"]) {
+      const mem = makeMemory(service, `${target}-${session}`, `第 ${session} 次${target}前都失眠`);
+      linkSession(service, mem.id, `${target}-${session}`);
+      ids[target].push(mem.id);
+    }
+  }
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "trait", evidence: ids.答辩, why: "三次答辩前都这样" },
+    { person: "桉桉", target: "面试", emotion: "焦虑", attribution: "trait", evidence: ids.面试, why: "三次面试前都这样" }
+  ]);
+  const result = await runSleep(ctx, service, affectiveConfig({ sleepMaxPatternPerRun: 2 }), ctx.logger, { embedder, vectorIndex: null }, null);
+  const phase = result.phases.affective;
+  assert.equal(phase.traits, 2, "两条 trait 候选");
+  assert.equal(phase.failures.length, 0, "没有失败");
+  assert.equal(phase.applied, 2, "两条都真的落库了");
+  const patterns = service.all().filter((m) => m.type === "pattern");
+  assert.equal(patterns.length, 2, "两个对象各一条，第二条不许被静默合并掉");
+  const titles = patterns.map((m) => m.title).sort();
+  assert.ok(titles.some((t) => t.includes("答辩")), "答辩那条在");
+  assert.ok(titles.some((t) => t.includes("面试")), "面试那条也在 —— 这条以前会消失");
+  assert.notEqual(titles[0], titles[1], "标题必须不同，否则去重键仍会撞");
+  store.close();
+});
+
+test("sleep: an occasion edge is marked when the same emotion is later confirmed as a trait", async () => {
+  // #619 / Ephor 第 5 轮 C：先有 occasion 边，后来证据够了判成 trait。
+  // 边不改（它表示「这次场合观察到过」，这句仍然是真的），但要标上
+  // promotedToTrait——否则同一件事实在图上是「一次性」、在 pattern 里是
+  // 「长期」，读归因覆盖率的人拿到两份互相矛盾的记录，而这不会自愈。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const mem0 = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  linkSession(service, mem0.id, "s0");
+  const ctxOccasion = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [mem0.id] }
+  ]);
+  const first = await runSleep(ctxOccasion, service, affectiveConfig(), ctxOccasion.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(first.phases.affective.relations, 1, "先落一条 occasion 边");
+  const ids = [];
+  for (const session of ["s1", "s2", "s3"]) {
+    const mem = makeMemory(service, `答辩-${session}`, `第 ${session} 次答辩前都失眠`);
+    linkSession(service, mem.id, session);
+    ids.push(mem.id);
+  }
+  const ctxTrait = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "trait", evidence: ids, why: "三次独立答辩前都这样" }
+  ]);
+  const second = await runSleep(ctxTrait, service, affectiveConfig(), ctxTrait.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(second.phases.affective.traits, 1, "够格铸 trait");
+  const person = service.findEntityByName("桉桉");
+  const edges = service.getRelations(person.id).filter((r) => r.relation_type === "affective_context");
+  assert.equal(edges.length, 1, "仍然是同一条边");
+  assert.equal(edges[0].metadata.sessionCount, 1, "边的场合数不因后来升格而改写");
+  assert.equal(edges[0].metadata.promotedToTrait, true, "但必须标上升格过，否则两份记录互相打脸");
+  store.close();
+});
+
+test("sleep: unknown entities and fabricated evidence are reported in dropped, not silently discarded", async () => {
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const mem = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  linkSession(service, mem.id, "session-A");
+  const ctx = affectiveCtx([
+    { person: "不存在的人", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [mem.id] },
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: ["fake-zzz"] },
+    { person: "桉桉", target: "答辩", emotion: "", attribution: "occasion", evidence: [mem.id] }
+  ]);
+  const result = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  const phase = result.phases.affective;
+  assert.equal(phase.relations, 0, "nothing landed");
+  assert.equal(phase.dropped.length, 3, "every rejection is accounted for");
+  const reasons = phase.dropped.map((d) => d.reason).sort();
+  assert.deepEqual(reasons, ["no emotion", "no real evidence", "unknown entity"]);
+  store.close();
+});
+
+test("sleep: the affective phase never adds a related_to edge", async () => {
+  // 变异自证的反面：如果情感边走的是 related_to（旧兜底行为），这条会挂。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const mem = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  linkSession(service, mem.id, "session-A");
+  const before = service.all().map((m) => m.id).length;
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [mem.id] }
+  ]);
+  await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  const person = service.findEntityByName("桉桉");
+  const rels = service.getRelations(person.id);
+  assert.equal(rels.filter((r) => r.relation_type === "related_to").length, 0, "no related_to smuggled in");
+  assert.equal(rels.filter((r) => r.relation_type === "affective_context").length, 1);
+  assert.equal(service.all().length, before, "no memory minted for a single-occasion emotion");
+  store.close();
+});
+
+test("sleep: replaying the same segment merges into the existing edge instead of stacking", async () => {
+  // #619 / Ephor 第 2 条：entity_relations 没有 UNIQUE，saveRelation 每次新插。
+  // 探针拿同一批段反复回放时，重复边会把 sessionCount 抬高、主指标失真。
+  // 而判重不能只「丢弃」：同一场合后来又看到更多证据时，那条边上的
+  // sessionCount 会永远停在第一次，将来读归因覆盖率会一直读到 1。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const mem = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  linkSession(service, mem.id, "session-A");
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [mem.id] }
+  ]);
+  const first = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(first.phases.affective.relations, 1, "第一轮写了一条");
+  const second = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(second.phases.affective.relations, 0, "第二轮不再新插边");
+  assert.ok(second.phases.affective.merged >= 1, "第二轮认出了同一场合，走合并而不是丢弃");
+  const person = service.findEntityByName("桉桉");
+  const edges = service.getRelations(person.id).filter((r) => r.relation_type === "affective_context");
+  assert.equal(edges.length, 1, "库里仍只有一条边");
+  assert.equal(edges[0].metadata.sessionCount, 1, "同一会话不会把场合数吹大");
+  assert.deepEqual(edges[0].metadata.evidence, [mem.id], "证据不变");
+  store.close();
+});
+
+test("sleep: two memories from one session merge into one edge, not two", async () => {
+  // 同一会话里的两条记忆各说一句「他很焦虑」，证据天然不相交，但它们是
+  // 同一个场合。按 evidence 交集判会各写一条，把边数与场合数一起吹大。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const m1 = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  const m2 = makeMemory(service, "答辩前一晚", "越想越慌，睡不着");
+  linkSession(service, m1.id, "session-A");
+  linkSession(service, m2.id, "session-A");
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [m1.id] },
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [m2.id] }
+  ]);
+  const result = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(result.phases.affective.relations, 1, "同一会话只该有一条边");
+  assert.ok(result.phases.affective.merged >= 1, "第二条按同场合合并进来");
+  const person = service.findEntityByName("桉桉");
+  const edges = service.getRelations(person.id).filter((r) => r.relation_type === "affective_context");
+  assert.equal(edges.length, 1);
+  assert.equal(edges[0].metadata.sessionCount, 1, "两条记忆都在同一会话，场合数仍是 1");
+  assert.deepEqual([...edges[0].metadata.evidence].sort(), [m1.id, m2.id].sort(), "证据取并集");
+  store.close();
+});
+
+test("sleep: a later occasion extends the existing edge instead of being dropped", async () => {
+  // 第一轮 1 个会话写边，第二轮攒到 2 个会话（含新会话）。如果判成重复丢掉，
+  // 边上的 sessionCount 会冻结在 1；将来用它算归因覆盖率就一直读到 1。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const m1 = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  const m2 = makeMemory(service, "第二次答辩前", "又要答辩了，还是焦虑");
+  linkSession(service, m1.id, "session-A");
+  linkSession(service, m2.id, "session-B");
+  const first = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [m1.id] }
+  ]);
+  const r1 = await runSleep(first, service, affectiveConfig(), first.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(r1.phases.affective.relations, 1);
+  const second = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [m1.id, m2.id] }
+  ]);
+  const r2 = await runSleep(second, service, affectiveConfig(), second.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(r2.phases.affective.relations, 0, "不是新边");
+  assert.ok(r2.phases.affective.merged >= 1, "是合并");
+  const person = service.findEntityByName("桉桉");
+  const edges = service.getRelations(person.id).filter((r) => r.relation_type === "affective_context");
+  assert.equal(edges.length, 1);
+  assert.equal(edges[0].metadata.sessionCount, 2, "场合数跟着证据涨到 2");
+  assert.deepEqual([...edges[0].metadata.evidence].sort(), [m1.id, m2.id].sort());
+  store.close();
+});
+
+test("sleep: reordering the evidence list does not smuggle in a second edge", async () => {
+  // 判重键如果只看 evidence[0]，模型把 [m1, m2] 写成 [m2, m1] 就会再插一条。
+  // LLM 给 evidence 的顺序本来就不稳定，parseJsonArray 也不排序——同一条边
+  // 换个顺序就重复写，sessionCount 会被抬得比真实场合数高，正好毁掉主指标。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const m1 = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  const m2 = makeMemory(service, "答辩前一晚", "越想越慌，睡不着");
+  linkSession(service, m1.id, "session-A");
+  linkSession(service, m2.id, "session-A");
+  const forward = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [m1.id, m2.id] }
+  ]);
+  const first = await runSleep(forward, service, affectiveConfig(), forward.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(first.phases.affective.relations, 1, "第一轮写了一条");
+  const reversed = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [m2.id, m1.id] }
+  ]);
+  const second = await runSleep(reversed, service, affectiveConfig(), reversed.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(second.phases.affective.relations, 0, "只换了证据顺序，不能再写一条");
+  assert.ok(second.phases.affective.merged >= 1, "认成同一场合，走合并");
+  const person = service.findEntityByName("桉桉");
+  const edges = service.getRelations(person.id).filter((r) => r.relation_type === "affective_context");
+  assert.equal(edges.length, 1, "库里仍只有一条边");
+  assert.equal(edges[0].metadata.sessionCount, 1, "同一会话，场合数仍是 1");
+  assert.deepEqual([...edges[0].metadata.evidence].sort(), [m1.id, m2.id].sort(), "并集后证据不多不少");
+  store.close();
+});
+
+test("sleep: two emotions in the same memory are two edges, not a duplicate", async () => {
+  // 判重键如果不带情绪，「答辩前又焦虑又期待」里的第二条会被当成重复丢掉，
+  // dropped 里还写着 duplicate edge——读起来像「本来就重复」，实际是丢了一条
+  // 真信息。本相位的承诺是降级不丢弃，重复和丢弃不能混成一个理由。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const mem = makeMemory(service, "答辩前一天", "明天答辩，他又焦虑又有点期待");
+  linkSession(service, mem.id, "session-A");
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [mem.id] },
+    { person: "桉桉", target: "答辩", emotion: "期待", attribution: "occasion", evidence: [mem.id] }
+  ]);
+  const result = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(result.phases.affective.relations, 2, "两种情绪各写一条");
+  assert.equal(result.phases.affective.dropped.filter((d) => d.reason === "duplicate edge").length, 0, "不许把第二种情绪当重复");
+  const person = service.findEntityByName("桉桉");
+  const edges = service.getRelations(person.id).filter((r) => r.relation_type === "affective_context");
+  assert.deepEqual(edges.map((r) => r.metadata.emotion).sort(), ["期待", "焦虑"], "两条边各带自己的情绪词");
+  store.close();
+});
+
+test("sleep: an edge write shows up in the receipt instead of reading as zero", async () => {
+  // #619 / Ephor: receipt 的倒数第二位是 applied，而 affective 相位写边走
+  // saveRelation、不进 applied。不改的话，一轮明明写了边，审计行却是 `:0`——
+  // 「跑了但什么都没做」，探针会把有写入的轮次记成空轮。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const mem = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  linkSession(service, mem.id, "session-A");
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [mem.id] }
+  ]);
+  const result = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(result.phases.affective.relations, 1, "恰好一条边落地，否则这条用例没在验东西");
+  assert.equal(result.phases.affective.applied, 0, "边不是 decision，applied 仍是 0");
+  const parts = result.receipt.split(":");
+  assert.equal(parts.length, 8, "receipt 仍是八段");
+  // 段序：dsh-mneme / run / runId / status / snapshotHash / inputCount / applied / summaryFlag
+  assert.equal(parts[6], "1", "写入计数必须非零，读成 0 等于谎报本轮没做过事");
+  store.close();
+});
+
+test("sleep: a merge-only run also shows up in the receipt", async () => {
+  // #619 / Ephor 第 4 轮：只合并的那一轮 relations 与 edgeWrites 都是 0，
+  // 但它确实改了库（证据并集、sessionCount 重算）。receipt 若读成 `:0`，
+  // 就是上一处修过的同一个谎——只是换了个形状。合并也算写。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const mem = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  linkSession(service, mem.id, "session-A");
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [mem.id] }
+  ]);
+  const first = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(first.receipt.split(":")[6], "1", "第一轮新写边，计数 1");
+  const second = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(second.phases.affective.relations, 0, "第二轮没有新边");
+  assert.equal(second.phases.affective.edgeWrites, 0, "第二轮没有新写");
+  assert.equal(second.phases.affective.merged, 1, "第二轮走的是合并");
+  assert.equal(second.phases.affective.status, "ok", "合并过就是 ok，不是 noop");
+  const parts = second.receipt.split(":");
+  assert.equal(parts.length, 8, "receipt 仍是八段");
+  assert.equal(parts[6], "1", "只合并的一轮同样改了库，必须非零");
+  store.close();
+});
+
+test("sleep: an aborted affective phase reports aborted, not ok", async () => {
+  // 中途被打断且已经写了边，既不能报 ok（没跑完），也不能报 noop（确实写了）。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const mem = makeMemory(service, "答辩前一天", "明天答辩，他很焦虑");
+  linkSession(service, mem.id, "session-A");
+  const controller = new AbortController();
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [mem.id] }
+  ]);
+  const realStream = ctx.llm.stream;
+  ctx.llm.stream = async function* (options) {
+    yield* realStream.call(this, options);
+    // 模型答完、写边之前用户回到电脑前
+    if (options.purpose === "sleep-affective") controller.abort();
+  };
+  const result = await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, controller.signal);
+  const phase = result.phases.affective;
+  assert.equal(phase.status, "aborted", "打断不是 ok");
+  assert.equal(phase.reason, "user activity");
+  assert.ok(phase.edgeWrites >= 0, "打断也把已写的条数报出来");
+  // 明细字段在每条返回路径上都得在。只有正常的返回带 mergedList 的话，
+  // 消费方在 aborted/failed 两条路径上读明细会静默拿到 undefined，不报错。
+  assert.ok(Array.isArray(phase.mergedList), "aborted 分支也要带 mergedList，缺了是静默失明");
+  store.close();
+});
+
+test("sleep: a trait that clears the threshold mints exactly one pattern and counts it", async () => {
+  // 这条与上一条配对：同样的三会话证据，上一条说「够格就铸」，这条看「铸了几个、
+  // 计数是否如实」。Ephor 第 4 条的 `if (ok)` 缺 else 已补成 failed 分支，但那条
+  // 分支在合法决策下不可达（决策是我们按合法形状拼的），不写假用例假装测过它。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const ids = [];
+  for (const session of ["s1", "s2", "s3"]) {
+    const mem = makeMemory(service, `答辩-${session}`, `第 ${session} 次答辩前都失眠`);
+    linkSession(service, mem.id, session);
+    ids.push(mem.id);
+  }
+  const ctx = affectiveCtx([
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "trait", evidence: ids, why: "三次都一样" }
+  ]);
+  const result = await runSleep(ctx, service, affectiveConfig({ sleepMaxPatternPerRun: 1 }), ctx.logger, { embedder, vectorIndex: null }, null);
+  const phase = result.phases.affective;
+  assert.equal(phase.status, "ok");
+  assert.equal(phase.traits, 1, "识别出一个 trait");
+  assert.equal(phase.applied, 1, "它真的被铸出来了");
+  store.close();
+});
+
+test("sleep: replaying the same trait rewrites the pattern instead of growing it", async () => {
+  // #619 / Ephor 第 6 轮：trait 标题由模板拼成，同一 (人, 对象, 情绪) 天然同题。
+  // applyCreate 走 saveWithDedupe，命中同题活跃行时默认 appendContent——把同一段
+  // 结论再粘一遍。pattern 是注入面消费的东西，重放三轮正文就从 161 字涨到 549 字，
+  // 还带一串重复的 [证据: …] 尾巴。修法：pattern 走 `_overwrite`，原地刷新。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const ids = [];
+  for (const session of ["s1", "s2", "s3"]) {
+    const mem = makeMemory(service, `答辩-${session}`, `第 ${session} 次答辩前都失眠`);
+    linkSession(service, mem.id, session);
+    ids.push(mem.id);
+  }
+  const payload = (ctx) => ctx;
+  const lengths = [];
+  for (let round = 0; round < 3; round += 1) {
+    const ctx = affectiveCtx([
+      { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "trait", evidence: ids, why: "三次都一样" }
+    ]);
+    void payload(ctx);
+    await runSleep(ctx, service, affectiveConfig({ sleepMaxPatternPerRun: 1 }), ctx.logger, { embedder, vectorIndex: null }, null);
+    const patterns = service.all().filter((m) => m.type === "pattern");
+    assert.equal(patterns.length, 1, `round ${round}: 仍然只有一行 pattern`);
+    lengths.push(patterns[0].content.length);
+  }
+  assert.equal(lengths[1], lengths[0], "第二轮不许把正文再粘一遍");
+  assert.equal(lengths[2], lengths[0], "第三轮同样");
+  const pattern = service.all().find((m) => m.type === "pattern");
+  assert.ok(!pattern.content.includes("---"), "没有 appendContent 的分隔符");
+  assert.equal((pattern.content.match(/\[证据/g) ?? []).length, 1, "证据尾巴只有一条");
+  store.close();
+});
+
+test("sleep: a refresh-only trait run reports refreshed, not ok with zero mints", async () => {
+  // 同一批证据重放：第二轮没铸新行，只是把既有 pattern 原地刷新。这时若报
+  // status:"ok" + applied:0，读审计的人会以为「说明这一轮没东西」，而实际上是
+  // 一次真实写入；若报 noop，又等于说整池看过了什么都没有。给它自己的名字。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  const ids = [];
+  for (const session of ["s1", "s2", "s3"]) {
+    const mem = makeMemory(service, `答辩-${session}`, `第 ${session} 次答辩前都失眠`);
+    linkSession(service, mem.id, session);
+    ids.push(mem.id);
+  }
+  const payload = [
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "trait", evidence: ids, why: "三次都一样" }
+  ];
+  const first = await (async () => {
+    const ctx = affectiveCtx(payload);
+    return runSleep(ctx, service, affectiveConfig({ sleepMaxPatternPerRun: 1 }), ctx.logger, { embedder, vectorIndex: null }, null);
+  })();
+  assert.equal(first.phases.affective.status, "ok", "第一轮真的铸了");
+  assert.equal(first.phases.affective.applied, 1);
+  const second = await (async () => {
+    const ctx = affectiveCtx(payload);
+    return runSleep(ctx, service, affectiveConfig({ sleepMaxPatternPerRun: 1 }), ctx.logger, { embedder, vectorIndex: null }, null);
+  })();
+  const phase = second.phases.affective;
+  assert.equal(phase.applied, 0, "第二轮没有新铸");
+  assert.equal(phase.refreshedTraits, 1, "刷新了一条");
+  assert.equal(phase.status, "refreshed", "刷新不是 noop，也不是一次新铸");
+  assert.equal(second.status, "ok", "整轮仍算有产出");
+  // #619 / Ephor 第七轮 ①：相位说「改了」，整轮 receipt 也必须说「改了」。此前
+  // totalApplied 只加 applied + edgeWrites + merged，refreshedTraits 不在表里，
+  // 于是这一轮 receipt 第 7 段是 0——「改了库读成 0」，正是上一轮刚修掉的形态。
+  const parsed = parseReceipt(second.receipt);
+  assert.ok(parsed, `receipt 必须可解析（实测 ${second.receipt}）`);
+  assert.equal(parsed.applied, 1, "刷新一条要算一次真实写入，不能被读成 0");
+  // ③ 同一个场景：刷新不是出生，不该再往 memory_mints 添一行。
+  const pattern = service.all().find((m) => m.type === "pattern");
+  assert.equal(store.mintsFor(pattern.id).length, 1, "两轮下来只有一条出生记录");
+  store.close();
+});
+
+test("sleep: the affective prompt does not corrupt JSON while filling the threshold", async () => {
+  // 占位符原来是一个裸的 `N`，而 prompt 正文里还写着「只输出 JSON 数组」。
+  // replaceAll("N", …) 于是把 JSON 换成了 JSO3——模型收到的是「只输出 JSO3 数组」，
+  // 而这一相位的唯一出口就是那个数组。这不是理论风险：zh 与 en 两版都中。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  service.createEntity({ name: "答辩", type: "concept" });
+  makeMemory(service, "答辩前一晚", "答辩前一晚他很焦虑");
+  const seen = [];
+  const ctx = {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "affective-model" }) },
+    llm: {
+      async *stream(options) {
+        if (options.purpose === "sleep-affective") {
+          const system = options.messages.find((m) => m.role === "system")?.content?.[0]?.text ?? "";
+          seen.push(system);
+        }
+        yield { type: "text-delta", index: 0, text: "[]" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  await runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  assert.equal(seen.length, 1, "情感相位确实调了一次模型");
+  const system = seen[0];
+  assert.ok(!system.includes("JSO3"), `prompt 里的 JSON 被阈值替换吃掉了：${system.slice(0, 200)}`);
+  assert.ok(system.includes("JSON"), "「只输出 JSON 数组」这句必须原样到达模型");
+  assert.ok(!system.includes("{{MIN_SESSIONS}}"), "占位符必须被填掉，不能把字面量发给模型");
+  assert.ok(system.includes("3"), "阈值默认 3 要出现在 prompt 里");
+  store.close();
+});
+
+test("sleep: evidence without provenance still counts as the same occasion", async () => {
+  // memory_save 写下的记忆没有 provenance，sessionsFor 返回空集。纯会话判据在
+  // 这种情况下永远判不出「同一场合」，同一批证据会在每一轮 sleep 里再写一条边，
+  // 把 sessionCount 抬得比真实场合数高。落不着会话键时退回 evidence 交集。
+  const { service, store } = setup();
+  const person = service.createEntity({ name: "桉桉", type: "person" });
+  const target = service.createEntity({ name: "答辩", type: "concept" });
+  const mem = makeMemory(service, "答辩前一晚", "答辩前一晚他很焦虑");
+  const payload = [
+    { person: "桉桉", target: "答辩", emotion: "焦虑", attribution: "occasion", evidence: [mem.id], why: "就这一次" }
+  ];
+  const run = () => {
+    const ctx = affectiveCtx(payload);
+    return runSleep(ctx, service, affectiveConfig(), ctx.logger, { embedder, vectorIndex: null }, null);
+  };
+  const first = await run();
+  assert.equal(first.phases.affective.relations, 1, "第一轮写了一条边");
+  const second = await run();
+  assert.equal(second.phases.affective.relations, 0, "第二轮不许再写一条");
+  assert.equal(second.phases.affective.merged, 1, "认成同一场合，合并进既有边");
+  const rels = service.getRelations(person.id).filter((r) => r.relation_type === "affective_context");
+  assert.equal(rels.length, 1, "库里仍只有一条");
+  assert.equal(rels[0].to_entity, target.id);
+  store.close();
+});
+
+test("sleep: trait candidates pushed out by the cap are recorded as dropped", async () => {
+  // traits.slice(0, maxTraits) 把超出的候选截掉，它们既不铸、也不降级、也不进
+  // dropped，而 traits 仍把它们算进候选数——读者会以为都处理过了。与边的
+  // `relation cap` 同一口径记一笔。
+  const { service, store } = setup();
+  service.createEntity({ name: "桉桉", type: "person" });
+  const payload = [];
+  for (const [i, target] of ["答辩", "面试", "汇报", "截止日期"].entries()) {
+    service.createEntity({ name: target, type: "concept" });
+    const ids = [];
+    for (const session of ["s1", "s2", "s3"]) {
+      const mem = makeMemory(service, `${target}-${session}-${i}`, `第 ${session} 次${target}前都失眠`);
+      linkSession(service, mem.id, `${target}-${session}`);
+      ids.push(mem.id);
+    }
+    payload.push({ person: "桉桉", target, emotion: "焦虑", attribution: "trait", evidence: ids, why: `三次${target}前都这样` });
+  }
+  const ctx = affectiveCtx(payload);
+  const result = await runSleep(ctx, service, affectiveConfig({ sleepMaxPatternPerRun: 2, sleepPatternMinMemories: 20 }), ctx.logger, { embedder, vectorIndex: null }, null);
+  const phase = result.phases.affective;
+  assert.equal(phase.traits, 4, "四条 trait 候选都被识别出来");
+  assert.equal(phase.applied, 2, "上限内两条落库");
+  const capped = phase.dropped.filter((d) => d.reason === "trait cap");
+  assert.equal(capped.length, 2, "被上限截掉的两条必须记账，不能静默消失");
+  assert.ok(capped.every((d) => typeof d.target === "string" && d.target), "每条都要能看出是哪条结论被截");
+  store.close();
+});

package/test/standalone-api.test.js

@@ -531,6 +531,30 @@ test("GET /memories supports include_archived and the occurred_at window", async
   }
 });
 
+test("GET /memories carries typeCounts: the full distribution without the type filter (#597)", async () => {
+  const { base, auth, service, close } = await setup();
+  try {
+    service.saveWithDedupe({ type: "preference", title: "p", content: "c" });
+    service.saveWithDedupe({ type: "project", title: "j1", content: "c" });
+    service.saveWithDedupe({ type: "project", title: "j2", content: "c" });
+
+    // total 跟着 type 筛；typeCounts 是同一份筛选、**不带 type** 的分布——
+    // 选中一类时其它类的数字仍在（面板分类栏不再塌剩两枚）。
+    const filtered = await (await fetch(`${base}/memories?type=project`, { headers: auth })).json();
+    assert.equal(filtered.total, 2, "total honors the type filter");
+    assert.deepEqual(filtered.typeCounts, { preference: 1, project: 2 }, "distribution ignores the type filter");
+
+    const all = await (await fetch(`${base}/memories`, { headers: auth })).json();
+    assert.equal(
+      Object.keys(all.typeCounts).reduce((n, k) => n + all.typeCounts[k], 0),
+      all.total,
+      "distribution sums to the unfiltered total"
+    );
+  } finally {
+    close();
+  }
+});
+
 test("GET /search honors the occurred_at window", async () => {
   const { base, auth, close } = await setup();
   try {