recallnest 3.0.0 → 4.0.0

package/src/__tests__/synthesis-contract.test.ts

@@ -1,252 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  CLUSTER_INSIGHT_PROMPT,
-  CLUSTER_PATTERN_PROMPT,
-  PROMPT_ECHO_MARKERS,
-  SYNTHESIS_MAX_LEN,
-  allocateClusterBudget,
-  numberClusterTexts,
-  parseSynthesisJson,
-  validateSynthesis,
-} from "../synthesis-contract.js";
-
-// ---------------------------------------------------------------------------
-// 输入预算分配（R3：老路径 slice(0,2000) 让 64.2% 的簇被截，p10 只有 13.8% 的源进得了模型）
-// ---------------------------------------------------------------------------
-
-describe("allocateClusterBudget", () => {
-  it("总量不超预算", () => {
-    const texts = Array.from({ length: 20 }, () => "x".repeat(5000));
-    const out = allocateClusterBudget(texts, 1000);
-    expect(out.reduce((s, t) => s + t.length, 0)).toBeLessThanOrEqual(1000);
-  });
-
-  it("短成员整条保留，长成员才被截", () => {
-    const out = allocateClusterBudget(["短", "y".repeat(999)], 100);
-    expect(out[0]).toBe("短");
-    expect(out[1].length).toBeLessThan(999);
-  });
-
-  it("短成员用不完的份额让给长成员，而不是浪费掉", () => {
-    // 均分是 50/50；第一条只用 1 个字符，第二条应拿到远超 50 的份额。
-    const out = allocateClusterBudget(["短", "y".repeat(999)], 100);
-    expect(out[1].length).toBeGreaterThan(50);
-  });
-
-  it("靠后的成员不会被整条丢掉——这正是老 slice(0,2000) 的失效形态", () => {
-    // 老路径把 168 条拼成一条长文本再从头切，排在后面的成员一个字都进不了模型。
-    const texts = Array.from({ length: 50 }, (_, i) => `第${i}条`.repeat(200));
-    const out = allocateClusterBudget(texts, 2000);
-    expect(out.length).toBe(50);
-    expect(out.every(t => t.length > 0)).toBe(true);
-    // 最后一条必须真的携带自己的内容，而不是空壳
-    expect(out[49]).toContain("第49条");
-  });
-
-  it("空簇返回空数组", () => {
-    expect(allocateClusterBudget([], 100)).toEqual([]);
-  });
-});
-
-describe("numberClusterTexts", () => {
-  it("编号从 1 开始，与 evidence 的语义一致", () => {
-    expect(numberClusterTexts(["a", "b"])).toBe("[1] a\n[2] b");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// JSON 解析
-// ---------------------------------------------------------------------------
-
-describe("parseSynthesisJson", () => {
-  it("裸 JSON", () => {
-    expect(parseSynthesisJson('{"has":false}')).toEqual({ has: false });
-  });
-
-  it("markdown 围栏", () => {
-    expect(parseSynthesisJson('```json\n{"has":false}\n```')).toEqual({ has: false });
-  });
-
-  it("带前言的回复也能抠出对象", () => {
-    expect(parseSynthesisJson('好的，结果如下：\n{"has":false}\n以上。')).toEqual({ has: false });
-  });
-
-  it("拿不到 JSON 时返回 null 而不是抛异常", () => {
-    expect(parseSynthesisJson("完全不是 JSON")).toBeNull();
-    expect(parseSynthesisJson(null)).toBeNull();
-  });
-
-  it("顶层是数组不算合法（契约要的是对象）", () => {
-    expect(parseSynthesisJson("[1,2,3]")).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 写库前校验 —— 每条 reject 分支都要有一条测试撑着，
-// 因为这一层的全部意义就是「LLM 说了什么不算数」。
-// ---------------------------------------------------------------------------
-
-const base = { textField: "conclusion", memberCount: 5, minEvidence: 1 };
-
-describe("validateSynthesis", () => {
-  it("合格输出：去重 + 升序", () => {
-    const v = validateSynthesis({
-      ...base,
-      parsed: { has: true, conclusion: "必须先初始化再分派，否则读到的是初始化前的值", evidence: [3, 1, 3] },
-    });
-    expect(v.status).toBe("ok");
-    if (v.status === "ok") {
-      expect(v.output.evidence).toEqual([1, 3]);
-      expect(v.output.text).toContain("必须先初始化");
-    }
-  });
-
-  it("has:false 是弃权，不是失败——这条路径老 generateL0 根本没有", () => {
-    expect(validateSynthesis({ ...base, parsed: { has: false } }).status).toBe("abstained");
-  });
-
-  it("解析不出 JSON → unparsable", () => {
-    const v = validateSynthesis({ ...base, parsed: null });
-    expect(v).toEqual({ status: "rejected", reason: "unparsable" });
-  });
-
-  it("has 不是 boolean → 拒绝（不猜它的意图）", () => {
-    for (const has of ["true", 1, null, undefined]) {
-      const v = validateSynthesis({ ...base, parsed: { has, conclusion: "随便什么", evidence: [1] } });
-      expect(v).toEqual({ status: "rejected", reason: "flag-not-boolean" });
-    }
-  });
-
-  it("说有结论却没给正文 → empty-text", () => {
-    expect(validateSynthesis({ ...base, parsed: { has: true, evidence: [1] } }))
-      .toEqual({ status: "rejected", reason: "empty-text" });
-    expect(validateSynthesis({ ...base, parsed: { has: true, conclusion: "   ", evidence: [1] } }))
-      .toEqual({ status: "rejected", reason: "empty-text" });
-  });
-
-  it("长度越界两侧都拒", () => {
-    expect(validateSynthesis({ ...base, parsed: { has: true, conclusion: "太短", evidence: [1] } }))
-      .toEqual({ status: "rejected", reason: "too-short" });
-    expect(validateSynthesis({
-      ...base,
-      parsed: { has: true, conclusion: "长".repeat(SYNTHESIS_MAX_LEN + 1), evidence: [1] },
-    })).toEqual({ status: "rejected", reason: "too-long" });
-  });
-
-  it("evidence 缺失或不是数组 → evidence-missing", () => {
-    expect(validateSynthesis({ ...base, parsed: { has: true, conclusion: "一条长度足够越过下限的结论文本" } }))
-      .toEqual({ status: "rejected", reason: "evidence-missing" });
-    expect(validateSynthesis({ ...base, parsed: { has: true, conclusion: "一条长度足够越过下限的结论文本", evidence: "1,2" } }))
-      .toEqual({ status: "rejected", reason: "evidence-missing" });
-  });
-
-  it("编号全部越界 → evidence-out-of-range（模型在编号，不是证据不够）", () => {
-    const v = validateSynthesis({
-      ...base,
-      parsed: { has: true, conclusion: "一条长度足够越过下限的结论文本", evidence: [99, 0, -1] },
-    });
-    expect(v).toEqual({ status: "rejected", reason: "evidence-out-of-range" });
-  });
-
-  it("pattern 侧只给 1 个合法编号 → evidence-too-few（跨条目按定义要 2 条）", () => {
-    const v = validateSynthesis({
-      parsed: { has: true, pattern: "一条长度足够越过下限的跨条目结论文本", evidence: [2] },
-      textField: "pattern",
-      memberCount: 5,
-      minEvidence: 2,
-    });
-    expect(v).toEqual({ status: "rejected", reason: "evidence-too-few" });
-  });
-
-  it("重复编号不算两条证据（[2,2] 去重后只剩 1 个）", () => {
-    const v = validateSynthesis({
-      parsed: { has: true, pattern: "一条长度足够越过下限的跨条目结论文本", evidence: [2, 2] },
-      textField: "pattern",
-      memberCount: 5,
-      minEvidence: 2,
-    });
-    expect(v).toEqual({ status: "rejected", reason: "evidence-too-few" });
-  });
-
-  it("数字字符串编号可接受（模型常把编号写成字符串）", () => {
-    const v = validateSynthesis({
-      ...base,
-      parsed: { has: true, conclusion: "一条长度足够越过下限的结论文本", evidence: ["2", 3] },
-    });
-    expect(v.status).toBe("ok");
-    if (v.status === "ok") expect(v.output.evidence).toEqual([2, 3]);
-  });
-
-  it("非整数编号不算合法", () => {
-    const v = validateSynthesis({
-      ...base,
-      parsed: { has: true, conclusion: "一条长度足够越过下限的结论文本", evidence: [1.5, "abc"] },
-    });
-    expect(v).toEqual({ status: "rejected", reason: "evidence-out-of-range" });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 提示词回声 —— R4 的直接回归：库里曾有 28 条记忆的正文就是系统提示词原文
-// ---------------------------------------------------------------------------
-
-describe("提示词回声拦截（R4 回归）", () => {
-  it("拦下那 28 条真实泄漏的原文形态", () => {
-    const leaked = "保真规则：端口号/IP/URL/文件路径/API名称 → 原样保留；函数名/事件名/配置项 → 逐项保留不概括。";
-    const v = validateSynthesis({ ...base, parsed: { has: true, conclusion: leaked, evidence: [1, 2] } });
-    expect(v).toEqual({ status: "rejected", reason: "prompt-echo" });
-  });
-
-  it("新提示词自己的句子被回声也拦得住", () => {
-    const v = validateSynthesis({
-      ...base,
-      parsed: { has: true, conclusion: "提炼不出来就说没有。宁可不产出，也不要硬凑。", evidence: [1] },
-    });
-    expect(v).toEqual({ status: "rejected", reason: "prompt-echo" });
-  });
-
-  it("正常结论不被误杀（标记表宁可漏也不误杀真结论）", () => {
-    const normal = "批量删记忆要显式关掉 cascade，否则同 scope 内相似度高的条目会被连带降权。";
-    expect(validateSynthesis({ ...base, parsed: { has: true, conclusion: normal, evidence: [1] } }).status).toBe("ok");
-  });
-
-  it("标记全部真的出现在提示词里——否则这道闸是摆设", () => {
-    // 反向断言：防有人改提示词时把某条标记的原文改掉，闸门静默失效而测试照绿。
-    const corpus = CLUSTER_INSIGHT_PROMPT + "\n" + CLUSTER_PATTERN_PROMPT;
-    const legacyOnly = new Set(["保真规则", "端口号/IP/URL/文件路径", "记忆索引助手", "记忆模式发现助手"]);
-    for (const marker of PROMPT_ECHO_MARKERS) {
-      if (legacyOnly.has(marker)) continue; // 老提示词的标记，本仓已无原文，保留是为了拦历史形态
-      expect(corpus).toContain(marker);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 提示词本身的契约：三件必须写死的事
-// ---------------------------------------------------------------------------
-
-describe("提示词契约", () => {
-  it("两个提示词都必须给出弃权出口", () => {
-    for (const p of [CLUSTER_INSIGHT_PROMPT, CLUSTER_PATTERN_PROMPT]) {
-      expect(p).toContain('has": false');
-    }
-  });
-
-  it("两个提示词都必须显式禁掉性向归因措辞（56.1% 的直接来源）", () => {
-    for (const p of [CLUSTER_INSIGHT_PROMPT, CLUSTER_PATTERN_PROMPT]) {
-      expect(p).toContain("倾向于");
-      expect(p).toContain("性格");
-    }
-  });
-
-  it("两个提示词都必须要求 evidence 编号", () => {
-    for (const p of [CLUSTER_INSIGHT_PROMPT, CLUSTER_PATTERN_PROMPT]) {
-      expect(p).toContain("evidence");
-    }
-  });
-
-  it("pattern 侧必须写死 ≥2 条支撑（旧提示词写了但实现不校验，等于没写）", () => {
-    expect(CLUSTER_PATTERN_PROMPT).toContain("至少 2 条");
-  });
-});

package/src/__tests__/synthesis-promotion.test.ts

@@ -1,369 +0,0 @@
-/**
- * Evidence → durable promotion for dream-synthesized conclusions.
- *
- * The layering RecallNest works under is "evidence retained → current projection →
- * eligible for recall → ranked result", and until now a synthesized conclusion could only
- * ever occupy the first of those. `buildDerivedBoundary` stamps every cluster insight and
- * cross-memory pattern `layer: "evidence"` on purpose — a model re-reading its own
- * memories is a lead to its sources, not authority over them — but
- * `shouldUseStableMemoryResult` rejects the evidence layer outright, so there was no path
- * from a well-supported conclusion to anything downstream could lean on.
- *
- * These tests cover the road that closes that gap, and the guardrails on it: the synthesis
- * row is never touched, re-running revises instead of duplicating, and anything whose
- * support cannot be checked is abstained on rather than waved through.
- */
-
-import { describe, expect, it } from "bun:test";
-
-import {
-  DEFAULT_SYNTHESIS_PROMOTE_CONFIG,
-  MIN_PROMOTABLE_CONTRACT_VERSION,
-  formatSynthesisPromoteResult,
-  scanSynthesisPromotions,
-  type PromoteRequest,
-  type SynthesisPromoteScanDeps,
-} from "../memory-promotion.js";
-import { shouldUseStableMemoryResult } from "../memory-boundaries.js";
-import type { MemoryEntry } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Fixture
-// ---------------------------------------------------------------------------
-
-const SCOPE = "memory";
-
-interface RowSpec {
-  id: string;
-  text: string;
-  category?: string;
-  importance?: number;
-  /** Omit for a plain (non-synthesis) row. */
-  synthesis?: {
-    contract?: number | null;
-    evidenceMemories?: unknown;
-    originalCategory?: string;
-  };
-  status?: string;
-  promotedTo?: string;
-}
-
-function row(spec: RowSpec): MemoryEntry {
-  const metadata: Record<string, unknown> = {
-    evolution: { status: spec.status ?? "active", version: 1, accessCount: 0 },
-  };
-
-  if (spec.synthesis) {
-    metadata.boundary = {
-      layer: "evidence",
-      authority: "distillation",
-      conflictPolicy: "append-only",
-      originalCategory: spec.synthesis.originalCategory ?? "cases",
-      note: "Dream-synthesized derivative: a lead to its sources, never authority over them.",
-    };
-    if (spec.synthesis.contract !== null) {
-      metadata.synthesis_contract = spec.synthesis.contract ?? MIN_PROMOTABLE_CONTRACT_VERSION;
-    }
-    if (spec.synthesis.evidenceMemories !== undefined) {
-      metadata.evidenceMemories = spec.synthesis.evidenceMemories;
-    }
-  } else {
-    metadata.boundary = {
-      layer: "durable",
-      authority: "structured-memory",
-      conflictPolicy: "latest-wins",
-    };
-  }
-
-  if (spec.promotedTo) metadata.promotedTo = spec.promotedTo;
-
-  return {
-    id: spec.id,
-    text: spec.text,
-    vector: [],
-    category: (spec.category ?? "cases") as MemoryEntry["category"],
-    scope: SCOPE,
-    importance: spec.importance ?? 0.8,
-    timestamp: Date.parse("2026-08-20T00:00:00.000Z"),
-    metadata: JSON.stringify(metadata),
-  };
-}
-
-/** Two live evidence rows every well-formed synthesis in these tests points at. */
-const EVIDENCE = [
-  row({ id: "ev-alpha", text: "第一次踩坑：换机没 push，第二天分叉" }),
-  row({ id: "ev-beta", text: "第二次：hooks symlink 化之后工作区常态脏" }),
-];
-
-function buildDeps(rows: MemoryEntry[]): {
-  deps: SynthesisPromoteScanDeps;
-  promoted: PromoteRequest[];
-} {
-  const all = [...EVIDENCE, ...rows];
-  const byId = new Map(all.map((e) => [e.id, e]));
-  const promoted: PromoteRequest[] = [];
-
-  return {
-    promoted,
-    deps: {
-      store: {
-        async list() {
-          return all;
-        },
-        async getById(id: string) {
-          return byId.get(id) ?? null;
-        },
-      } as any,
-      async promote(req) {
-        promoted.push(req);
-        return {
-          id: `durable-${req.memoryId}`,
-          text: byId.get(req.memoryId)?.text ?? "",
-          category: req.category,
-          importance: req.importance,
-          scope: req.scope,
-          resolvedScope: req.scope,
-          canonicalKey: `key:${req.memoryId}`,
-          storedAt: new Date().toISOString(),
-          disposition: "stored",
-          sourceMemoryId: req.memoryId,
-          sourceCategory: "cases",
-        } as any;
-      },
-    },
-  };
-}
-
-function goodSynthesis(over: Partial<RowSpec> = {}): MemoryEntry {
-  return row({
-    id: "syn-good",
-    text: "换机交接的失败都同一个形状：脏工作区被当成临时状态，真相源迁走后它变成常态",
-    importance: 0.85,
-    ...over,
-    synthesis: {
-      contract: MIN_PROMOTABLE_CONTRACT_VERSION,
-      evidenceMemories: ["ev-alpha", "ev-beta"],
-      originalCategory: "patterns",
-      ...(over.synthesis ?? {}),
-    },
-  });
-}
-
-// ---------------------------------------------------------------------------
-
-describe("synthesis promotion: what qualifies", () => {
-  it("promotes a contract-compliant conclusion with enough live evidence", async () => {
-    const { deps, promoted } = buildDeps([goodSynthesis()]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(result.candidates).toHaveLength(1);
-    expect(result.promoted).toBe(1);
-    expect(result.candidates[0]).toMatchObject({
-      seedId: "syn-good",
-      category: "patterns",
-      contractVersion: MIN_PROMOTABLE_CONTRACT_VERSION,
-      evidenceIds: ["ev-alpha", "ev-beta"],
-    });
-    // Promotion goes through the shared promoteMemory path, not a private writer.
-    expect(promoted).toEqual([
-      { memoryId: "syn-good", category: "patterns", scope: SCOPE, importance: 0.85 },
-    ]);
-  });
-
-  it("defaults to dry-run and writes nothing", async () => {
-    const { deps, promoted } = buildDeps([goodSynthesis()]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE);
-
-    expect(DEFAULT_SYNTHESIS_PROMOTE_CONFIG.dryRun).toBe(true);
-    expect(result.dryRun).toBe(true);
-    expect(result.candidates).toHaveLength(1);
-    expect(result.promoted).toBe(0);
-    expect(promoted).toEqual([]);
-    expect(result.candidates[0]?.promoted).toBeNull();
-  });
-
-  it("ignores rows that are not synthesized derivatives", async () => {
-    // A hand-written durable memory is already on the durable layer; promoting it would be
-    // meaningless, and promoteMemory itself rejects non-evidence sources.
-    const { deps } = buildDeps([
-      row({ id: "handwritten", text: "Alice 用 Bun，不用 npm" }),
-      goodSynthesis(),
-    ]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(result.scannedSyntheses).toBe(1);
-    expect(result.candidates.map((c) => c.seedId)).toEqual(["syn-good"]);
-  });
-
-  it("takes the durable category from the synthesis boundary", async () => {
-    const { deps, promoted } = buildDeps([
-      goodSynthesis({ synthesis: { originalCategory: "preferences" } as any }),
-    ]);
-
-    await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(promoted[0]?.category).toBe("preferences");
-  });
-});
-
-describe("synthesis promotion: what it refuses, and says so", () => {
-  it("skips derivatives written before the synthesis contract", async () => {
-    // The 4,749 rows already in the database predate validation entirely — they were never
-    // checked for abstention, evidence, or prompt echo. Promoting them would launder
-    // unvalidated output into durable memory.
-    const { deps, promoted } = buildDeps([
-      goodSynthesis({ id: "syn-legacy", synthesis: { contract: null } as any }),
-      goodSynthesis({ id: "syn-v1", synthesis: { contract: 1 } as any }),
-    ]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(result.skipped.pre_contract).toBe(2);
-    expect(result.candidates).toHaveLength(0);
-    expect(promoted).toEqual([]);
-  });
-
-  it("abstains when the declared evidence cannot be resolved at all", async () => {
-    // Not judging is the right answer when the provenance needed for the judgement is
-    // missing — the same abstention rule the cross-source promotion check uses.
-    const { deps, promoted } = buildDeps([
-      goodSynthesis({ id: "syn-dangling", synthesis: { evidenceMemories: ["gone-1", "gone-2"] } as any }),
-    ]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(result.skipped.evidence_unresolvable).toBe(1);
-    expect(promoted).toEqual([]);
-  });
-
-  it("abstains when the evidence field is missing or malformed", async () => {
-    const { deps } = buildDeps([
-      goodSynthesis({ id: "syn-noevidence", synthesis: { evidenceMemories: undefined } as any }),
-      goodSynthesis({ id: "syn-badevidence", synthesis: { evidenceMemories: "not-an-array" } as any }),
-    ]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(result.skipped.evidence_unresolvable).toBe(2);
-    expect(result.candidates).toHaveLength(0);
-  });
-
-  it("counts duplicate evidence ids once", async () => {
-    // "Three similar cases" and "three distinct episodes" differ in dimension, not degree;
-    // the same source listed twice is one source.
-    const { deps } = buildDeps([
-      goodSynthesis({ id: "syn-dup", synthesis: { evidenceMemories: ["ev-alpha", "ev-alpha"] } as any }),
-    ]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(result.skipped.too_few_distinct_evidence).toBe(1);
-    expect(result.candidates).toHaveLength(0);
-  });
-
-  it("does not count evidence that is no longer active", async () => {
-    const superseded = row({ id: "ev-gone", text: "已被推翻的旧结论", status: "superseded" });
-    const { deps } = buildDeps([
-      superseded,
-      goodSynthesis({ id: "syn-stale", synthesis: { evidenceMemories: ["ev-alpha", "ev-gone"] } as any }),
-    ]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    // One live source left, below the floor of two.
-    expect(result.skipped.too_few_distinct_evidence).toBe(1);
-    expect(result.candidates).toHaveLength(0);
-  });
-
-  it("skips a conclusion below the importance floor", async () => {
-    const { deps } = buildDeps([goodSynthesis({ id: "syn-weak", importance: 0.4 })]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(result.skipped.below_importance).toBe(1);
-    expect(result.candidates).toHaveLength(0);
-  });
-
-  it("skips a conclusion already promoted", async () => {
-    const { deps } = buildDeps([goodSynthesis({ id: "syn-done", promotedTo: "durable-syn-done" })]);
-
-    const result = await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(result.skipped.already_promoted).toBe(1);
-    expect(result.candidates).toHaveLength(0);
-  });
-
-  it("reports the rejection breakdown even when nothing is promoted", async () => {
-    // Otherwise "found nothing" and "filtered everything out" read identically.
-    const { deps } = buildDeps([
-      goodSynthesis({ id: "syn-legacy", synthesis: { contract: 1 } as any }),
-      goodSynthesis({ id: "syn-weak", importance: 0.2 }),
-    ]);
-
-    const text = formatSynthesisPromoteResult(await scanSynthesisPromotions(deps, SCOPE));
-
-    expect(text).toContain("2 synthesized conclusion(s) examined");
-    expect(text).toContain("pre_contract=1");
-    expect(text).toContain("below_importance=1");
-    expect(text).toContain("No promotion candidates found");
-  });
-});
-
-describe("synthesis promotion: the guarantees around it", () => {
-  it("never modifies the synthesized row — evidence stays readable as evidence", async () => {
-    const synthesis = goodSynthesis();
-    const before = synthesis.metadata;
-    const { deps } = buildDeps([synthesis]);
-
-    await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    // Archive-first: the conclusion keeps its evidence boundary and its support set, so a
-    // later reader can still tell what the durable copy was derived from.
-    expect(synthesis.metadata).toBe(before);
-    expect(JSON.parse(synthesis.metadata!).boundary.layer).toBe("evidence");
-  });
-
-  it("re-scanning promotes the same seed through the same idempotent path", async () => {
-    // Duplicate suppression lives in promoteMemory -> writeDurableEntry's canonicalKey
-    // dedup, so a second scan revises rather than piling up a parallel memory. What this
-    // asserts is that the scan keeps routing through it instead of growing its own writer.
-    const { deps, promoted } = buildDeps([goodSynthesis()]);
-
-    await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-    await scanSynthesisPromotions(deps, SCOPE, { dryRun: false });
-
-    expect(promoted).toHaveLength(2);
-    expect(new Set(promoted.map((p) => p.memoryId)).size).toBe(1);
-  });
-
-  it("makes the promoted copy eligible for stable memory while the source stays out", async () => {
-    // This is the whole point. The synthesized row is refused by
-    // shouldUseStableMemoryResult; the durable copy promoteMemory writes is not.
-    const synthesis = goodSynthesis({ synthesis: { originalCategory: "preferences" } as any });
-
-    expect(
-      shouldUseStableMemoryResult({
-        category: "preferences",
-        scope: SCOPE,
-        metadata: synthesis.metadata,
-      }),
-    ).toBe(false);
-
-    const promotedMetadata = JSON.stringify({
-      evolution: { status: "active", version: 1 },
-      boundary: { layer: "durable", authority: "structured-memory", conflictPolicy: "latest-wins" },
-      promotedFrom: { memoryId: synthesis.id, scope: SCOPE, category: "cases" },
-    });
-
-    expect(
-      shouldUseStableMemoryResult({
-        category: "preferences",
-        scope: SCOPE,
-        metadata: promotedMetadata,
-      }),
-    ).toBe(true);
-  });
-});