recallnest 2.6.1 → 3.0.0

package/src/__tests__/retrieve-audit-revision.test.ts

@@ -0,0 +1,255 @@
+/**
+ * Retrieve-audit revision/provenance coverage.
+ *
+ * `3fc1875` connected the retrieve audit (setAuditLogger had zero callers, so the
+ * `?.` call was a permanent no-op). What it records is `query="…" hits=N` — enough to
+ * prove a retrieval happened, not enough to answer the question an audit log is for:
+ * when an agent acted on recalled memory, *which revision did it read*?
+ *
+ * That gap is not cosmetic. `archiveBeliefVersion` rewrites a belief in place: the
+ * canonical id stays, `evolution.version` goes up, and the old text survives as a
+ * separate `superseded` row. So "memory abc1234 was retrieved" is ambiguous across every
+ * belief change, and a stale answer is indistinguishable from a current one after the
+ * fact.
+ *
+ * These tests pin the extra fields on the existing audit row. They deliberately do not
+ * introduce a second audit path — the assertions run against the same `AuditLogger`
+ * interface the store/update/delete operations already use.
+ */
+
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { AUDIT_RETRIEVED_CAP, createAuditLogger, type AuditEntry } from "../audit-log.js";
+import { createRetriever } from "../retriever.js";
+
+function recordingLogger(): { entries: AuditEntry[]; logger: any } {
+  const entries: AuditEntry[] = [];
+  return {
+    entries,
+    logger: {
+      log(entry: Omit<AuditEntry, "timestamp">) {
+        entries.push({ timestamp: new Date().toISOString(), ...entry });
+      },
+      getRecent: () => entries,
+      exportAll: () => entries,
+      count: () => entries.length,
+    },
+  };
+}
+
+interface FakeRow {
+  id: string;
+  text: string;
+  metadata?: Record<string, unknown>;
+  score?: number;
+}
+
+function buildRetriever(rows: FakeRow[]) {
+  const results = rows.map((row) => ({
+    entry: {
+      id: row.id,
+      text: row.text,
+      vector: [1, 0, 0],
+      category: "cases",
+      scope: "memory",
+      importance: 0.8,
+      timestamp: Date.parse("2026-08-01T00:00:00.000Z"),
+      ...(row.metadata ? { metadata: JSON.stringify(row.metadata) } : {}),
+    },
+    score: row.score ?? 0.9,
+  }));
+
+  return createRetriever(
+    {
+      hasFtsSupport: false,
+      async vectorSearch() {
+        return results;
+      },
+    } as any,
+    {
+      async embedQuery() {
+        return [1, 0, 0];
+      },
+      async embedPassage() {
+        return [1, 0, 0];
+      },
+    } as any,
+    {
+      mode: "vector",
+      rerank: "none",
+      filterNoise: false,
+      hardMinScore: 0,
+      minScore: 0,
+      recencyWeight: 0,
+      timeDecayHalfLifeDays: 0,
+    },
+  );
+}
+
+describe("retrieve audit records revision and provenance", () => {
+  it("records the served revision, lifecycle status, and boundary of each hit", async () => {
+    const { entries, logger } = recordingLogger();
+    const retriever = buildRetriever([
+      {
+        id: "aaaaaaaa-1111-2222-3333-444444444444",
+        text: "Alice uses Bun, not npm",
+        metadata: {
+          evolution: { status: "active", version: 3 },
+          boundary: {
+            layer: "durable",
+            authority: "structured-memory",
+            conflictPolicy: "latest-wins",
+          },
+        },
+      },
+    ]);
+    retriever.setAuditLogger(logger);
+
+    await retriever.retrieve({ query: "which runtime does recallnest use", scopeFilter: ["memory"], limit: 5 });
+
+    const row = entries.find((e) => e.operation === "retrieve");
+    expect(row).toBeDefined();
+    expect(row?.retrieved).toEqual([
+      { id: "aaaaaaaa", rev: 3, st: "active", ly: "durable", au: "structured-memory" },
+    ]);
+    // The pre-existing details string is untouched — this extends the row, not replaces it.
+    expect(row?.details).toContain('query="which runtime does recallnest use"');
+    expect(row?.details).toContain("hits=1");
+  });
+
+  it("distinguishes a superseded revision from the live one", async () => {
+    const { entries, logger } = recordingLogger();
+    // Both rows are reachable by design: belief history is archive-first, so a query can
+    // legitimately surface the old text. Without `rev`/`st` the audit row cannot tell
+    // afterwards whether the agent read the current belief or the retired one.
+    const retriever = buildRetriever([
+      {
+        id: "cccccccc-0000-0000-0000-000000000000",
+        text: "Deploys go through the mini",
+        metadata: {
+          evolution: { status: "active", version: 2 },
+          boundary: { layer: "durable", authority: "structured-memory", conflictPolicy: "latest-wins" },
+        },
+      },
+      {
+        id: "hhhhhhhh-0000-0000-0000-000000000000",
+        text: "Deploys go through the MacBook",
+        metadata: {
+          evolution: { status: "superseded", version: 1, supersededBy: "cccccccc-0000-0000-0000-000000000000" },
+          boundary: { layer: "durable", authority: "structured-memory", conflictPolicy: "latest-wins" },
+        },
+        score: 0.85,
+      },
+    ]);
+    retriever.setAuditLogger(logger);
+
+    await retriever.retrieve({
+      query: "where do deploys run",
+      scopeFilter: ["memory"],
+      limit: 5,
+      // Superseded rows are excluded by default; this is the path that can serve one.
+      includeArchived: true,
+    });
+
+    const row = entries.find((e) => e.operation === "retrieve");
+    const served = row?.retrieved ?? [];
+    const byId = new Map(served.map((r) => [r.id, r]));
+
+    expect(byId.get("cccccccc")).toMatchObject({ rev: 2, st: "active" });
+    expect(byId.get("hhhhhhhh")).toMatchObject({ rev: 1, st: "superseded" });
+  });
+
+  it("defaults a memory with no evolution block to revision 1 / active", async () => {
+    const { entries, logger } = recordingLogger();
+    // Pre-versioning rows exist in the live database; they must not break the audit row.
+    const retriever = buildRetriever([
+      { id: "eeeeeeee-0000-0000-0000-000000000000", text: "legacy entry with no metadata" },
+    ]);
+    retriever.setAuditLogger(logger);
+
+    await retriever.retrieve({ query: "legacy", scopeFilter: ["memory"], limit: 5 });
+
+    const row = entries.find((e) => e.operation === "retrieve");
+    expect(row?.retrieved).toEqual([{ id: "eeeeeeee", rev: 1, st: "active" }]);
+    // No boundary metadata means no layer/authority claim — absent, not guessed.
+    expect(row?.retrieved?.[0]).not.toHaveProperty("ly");
+    expect(row?.retrieved?.[0]).not.toHaveProperty("au");
+  });
+
+  it("caps the list and says so, rather than silently reporting a short one", async () => {
+    const { entries, logger } = recordingLogger();
+    const overCap = AUDIT_RETRIEVED_CAP + 4;
+    const retriever = buildRetriever(
+      Array.from({ length: overCap }, (_, i) => ({
+        id: `${String(i).padStart(8, "0")}-0000-0000-0000-000000000000`,
+        text: `candidate ${i}`,
+        metadata: { evolution: { status: "active", version: 1 } },
+        score: 0.9 - i * 0.001,
+      })),
+    );
+    retriever.setAuditLogger(logger);
+
+    await retriever.retrieve({ query: "many candidate rows for one query", scopeFilter: ["memory"], limit: overCap });
+
+    const row = entries.find((e) => e.operation === "retrieve");
+    expect(row?.retrieved).toHaveLength(AUDIT_RETRIEVED_CAP);
+    // audit.jsonl has no rotation, so the list is bounded — but truncation must be legible.
+    expect(row?.retrievedTotal).toBe(overCap);
+    expect(row?.details).toContain(`hits=${overCap}`);
+  });
+
+  it("round-trips the new fields through the real file logger", async () => {
+    // The unit tests above assert against an in-memory logger. This one proves the fields
+    // survive the actual JSONL path — serialization, append, and parse-back — so a shape
+    // that only works in tests cannot pass. Uses a temp dir, never the production log.
+    const dir = mkdtempSync(join(tmpdir(), "recallnest-audit-"));
+    const logPath = join(dir, "audit.jsonl");
+
+    try {
+      const retriever = buildRetriever([
+        {
+          id: "ffffffff-0000-0000-0000-000000000000",
+          text: "Release verification runs on the mini",
+          metadata: {
+            evolution: { status: "active", version: 5 },
+            boundary: { layer: "evidence", authority: "distillation", conflictPolicy: "append-only" },
+          },
+        },
+      ]);
+      retriever.setAuditLogger(createAuditLogger(logPath));
+
+      await retriever.retrieve({
+        query: "where does release verification run",
+        scopeFilter: ["memory"],
+        limit: 5,
+      });
+
+      const lines = readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
+      const row = lines.map((l) => JSON.parse(l) as AuditEntry).find((e) => e.operation === "retrieve");
+
+      expect(row?.retrieved).toEqual([
+        { id: "ffffffff", rev: 5, st: "active", ly: "evidence", au: "distillation" },
+      ]);
+      expect(typeof row?.timestamp).toBe("string");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("omits both fields when nothing was served", async () => {
+    const { entries, logger } = recordingLogger();
+    const retriever = buildRetriever([]);
+    retriever.setAuditLogger(logger);
+
+    await retriever.retrieve({ query: "a question with no stored answer", scopeFilter: ["memory"], limit: 5 });
+
+    const row = entries.find((e) => e.operation === "retrieve");
+    expect(row).toBeDefined();
+    expect(row).not.toHaveProperty("retrieved");
+    // retrievedTotal exists to flag truncation; with an empty list there is none to flag.
+    expect(row).not.toHaveProperty("retrievedTotal");
+  });
+});

package/src/__tests__/source-heartbeat.test.ts

@@ -48,10 +48,14 @@ function makeEntry(id: string): MemoryEntry {
   };
 }
 
-function createMockStore(entries: MemoryEntry[]): Pick<MemoryStore, "list" | "stats" | "getVectors"> {
+function createMockStore(entries: MemoryEntry[]): Pick<MemoryStore, "list" | "listPage" | "stats" | "getVectors"> {
   return {
     // 复刻真实 store:list() 为性能不返回向量,诊断检查经 getVectors 补回。
     async list() { return entries.map(e => ({ ...e, vector: [] })); },
+    async listPage(opts: { limit?: number; offset?: number } = {}) {
+      const { limit = 1000, offset = 0 } = opts;
+      return entries.slice(offset, offset + limit).map(e => ({ ...e, vector: [] }));
+    },
     async stats() {
       return { totalCount: entries.length, scopeCounts: {}, categoryCounts: {} };
     },
@@ -62,7 +66,7 @@ function createMockStore(entries: MemoryEntry[]): Pick<MemoryStore, "list" | "st
       }
       return map;
     },
-  } as Pick<MemoryStore, "list" | "stats" | "getVectors">;
+  } as Pick<MemoryStore, "list" | "listPage" | "stats" | "getVectors">;
 }
 
 // ---------------------------------------------------------------------------

package/src/__tests__/store-patch-metadata.test.ts

@@ -203,3 +203,33 @@ describe("MemoryStore.listPage", () => {
     expect(withVec.vector).toEqual([1, 0, 0]);
   });
 });
+
+describe("MemoryStore.repairSingletonVersionGroups", () => {
+  it("dissolves only singleton groups and preserves all unrelated metadata", async () => {
+    const store = createStore();
+    const singleton = await seed(store, {
+      text: "singleton",
+      metadata: JSON.stringify({
+        version_group: "vg-single",
+        version_rank: 1.4,
+        version_created: "2026-07-07T00:00:00.000Z",
+        marker: "keep",
+      }),
+    });
+    const pairA = await seed(store, {
+      text: "pair-a",
+      metadata: JSON.stringify({ version_group: "vg-pair", version_rank: 2, version_created: "2026-07-07T00:00:00.000Z" }),
+    });
+    const pairB = await seed(store, {
+      text: "pair-b",
+      metadata: JSON.stringify({ version_group: "vg-pair", version_rank: 1, version_created: "2026-07-07T00:00:00.000Z" }),
+    });
+
+    expect(await store.repairSingletonVersionGroups()).toBe(1);
+    const singletonMeta = JSON.parse((await store.getById(singleton.id))!.metadata!);
+    expect(singletonMeta).toEqual({ marker: "keep" });
+    expect(JSON.parse((await store.getById(pairA.id))!.metadata!).version_group).toBe("vg-pair");
+    expect(JSON.parse((await store.getById(pairB.id))!.metadata!).version_group).toBe("vg-pair");
+    expect(await store.repairSingletonVersionGroups()).toBe(0);
+  });
+});

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

@@ -0,0 +1,252 @@
+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 条");
+  });
+});