recallnest 2.5.4 → 2.6.1

package/src/__tests__/retriever-lazy-init-dispatch.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from "bun:test";
+
+import { createRetriever } from "../retriever.js";
+
+/**
+ * 回归：retrieve() 在分派前必须等 store 完成惰性初始化。
+ *
+ * 真实 MemoryStore 的 hasFtsSupport 在 ensureInitialized() 跑完前恒为 false
+ * （ftsIndexCreated 初值 false，建索引发生在 doInitialize 里）。retriever.ts 的
+ * 分派条件是 `mode === "vector" || !this.store.hasFtsSupport`，若不先 await
+ * store.ready()，hybrid 模式的**首次**检索会读到初始化前的 false 并静默落回
+ * vector 路径——同一实例第二次才正常。
+ *
+ * 该缺陷自 c10607a（2026-03-03 初始版本）就在，长期未暴露：生产 mode 一直是
+ * "vector"，第一个条件短路；而 eval 每 case 新建组件，每个 case 都停在"首次"，
+ * 于是 eval 从未测到过 hybrid 路径。
+ *
+ * 下面的 fake store 用 getter + ready() 精确复现这个时序：不修复则 bm25Search
+ * 不会被调用。
+ */
+function buildResult(id: string, text: string) {
+  return {
+    entry: {
+      id,
+      text,
+      vector: [1, 0, 0],
+      category: "preferences",
+      scope: "memory:test",
+      importance: 0.8,
+      timestamp: Date.parse("2026-08-07T00:00:00.000Z"),
+      metadata: JSON.stringify({}),
+    },
+    score: 0.8,
+  };
+}
+
+const fakeEmbedder = {
+  async embedQuery() {
+    return [1, 0, 0];
+  },
+  async embedPassage() {
+    return [1, 0, 0];
+  },
+} as any;
+
+function buildLazyStore() {
+  const calls = { bm25: 0, vector: 0, ready: 0 };
+  let initialized = false;
+
+  const store = {
+    // 复现真实时序：初始化完成前恒 false
+    get hasFtsSupport() {
+      return initialized;
+    },
+    async ready() {
+      calls.ready += 1;
+      initialized = true;
+    },
+    async vectorSearch() {
+      calls.vector += 1;
+      return [buildResult("vec-1", "vector hit")];
+    },
+    async bm25Search() {
+      calls.bm25 += 1;
+      return [buildResult("bm25-1", "bm25 hit")];
+    },
+  };
+
+  return { store, calls };
+}
+
+const LOOSE_CONFIG = {
+  rerank: "none" as const,
+  filterNoise: false,
+  hardMinScore: 0,
+  minScore: 0,
+  recencyWeight: 0,
+  timeDecayHalfLifeDays: 0,
+};
+
+describe("retrieve() 分派与 store 惰性初始化的时序", () => {
+  it("hybrid 模式的首次检索不因惰性初始化落回 vector 路径", async () => {
+    const { store, calls } = buildLazyStore();
+    const retriever = createRetriever(store as any, fakeEmbedder, {
+      ...LOOSE_CONFIG,
+      mode: "hybrid",
+    });
+
+    await retriever.retrieve({ query: "双机契约 同步", limit: 5 });
+
+    // 修复前：hasFtsSupport 读到初始化前的 false → 落回 vectorOnly → bm25 为 0。
+    expect(calls.ready).toBeGreaterThan(0);
+    expect(calls.bm25).toBeGreaterThan(0);
+  });
+
+  it("vector 模式不受影响——短路在第一个条件，不走 BM25", async () => {
+    const { store, calls } = buildLazyStore();
+    const retriever = createRetriever(store as any, fakeEmbedder, {
+      ...LOOSE_CONFIG,
+      mode: "vector",
+    });
+
+    await retriever.retrieve({ query: "双机契约 同步", limit: 5 });
+
+    // 这条守的是"修复不得改变生产行为"：生产 mode 就是 vector。
+    expect(calls.bm25).toBe(0);
+    expect(calls.vector).toBeGreaterThan(0);
+  });
+
+  it("琐碎 query 走 skip 分支时不触发初始化", async () => {
+    const { store, calls } = buildLazyStore();
+    const retriever = createRetriever(store as any, fakeEmbedder, {
+      ...LOOSE_CONFIG,
+      mode: "hybrid",
+    });
+
+    // shouldSkipRetrieval 在分派之前提前 return，await ready() 不该被执行到。
+    await retriever.retrieve({ query: "ok", limit: 5 });
+
+    expect(calls.ready).toBe(0);
+    expect(calls.vector).toBe(0);
+  });
+});

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

@@ -599,3 +599,56 @@ describe("A2 verifier integration", () => {
     expect(text).toContain("fake_cmd");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Read evidence (Artel read-driven promotion) — aggregateReadEvidence / applyReadBoost
+// ---------------------------------------------------------------------------
+
+import { aggregateReadEvidence, applyReadBoost } from "../skill-promotion.js";
+
+describe("aggregateReadEvidence", () => {
+  it("sums accessCount and unions readerIds across entries", () => {
+    const entries = [
+      { metadata: JSON.stringify({ accessCount: 3, readerIds: ["r-a", "r-b"], distinctReaderCount: 2 }) },
+      { metadata: JSON.stringify({ accessCount: 2, readerIds: ["r-b", "r-c"], distinctReaderCount: 2 }) },
+    ];
+    const ev = aggregateReadEvidence(entries);
+    expect(ev.totalAccess).toBe(5);
+    expect(ev.distinctReaders).toBe(3); // union {r-a, r-b, r-c}
+  });
+
+  it("falls back to saturated per-entry count when readerIds capped", () => {
+    // READER_ID_CAP 饱和后 readerIds 停增但 distinctReaderCount 保留饱和值
+    const entries = [
+      { metadata: JSON.stringify({ accessCount: 10, readerIds: ["r-a"], distinctReaderCount: 8 }) },
+    ];
+    const ev = aggregateReadEvidence(entries);
+    expect(ev.distinctReaders).toBe(8); // max(union=1, saturated=8)
+  });
+
+  it("tolerates missing and broken metadata", () => {
+    const ev = aggregateReadEvidence([
+      { metadata: undefined },
+      { metadata: "not-json{" },
+      { metadata: JSON.stringify({ accessCount: 1 }) },
+    ]);
+    expect(ev.totalAccess).toBe(1);
+    expect(ev.distinctReaders).toBe(0);
+  });
+});
+
+describe("applyReadBoost", () => {
+  it("adds no boost for zero readers", () => {
+    expect(applyReadBoost(0.5, 0)).toBe(0.5);
+  });
+
+  it("scales boost linearly and saturates at 4 readers", () => {
+    expect(applyReadBoost(0.5, 2)).toBeCloseTo(0.5 + 0.075, 5); // half of max 0.15
+    expect(applyReadBoost(0.5, 4)).toBeCloseTo(0.65, 5);        // full boost
+    expect(applyReadBoost(0.5, 12)).toBeCloseTo(0.65, 5);       // saturated
+  });
+
+  it("caps combined confidence at 0.99", () => {
+    expect(applyReadBoost(0.95, 4)).toBe(0.99);
+  });
+});

package/src/__tests__/stable-context-length-contract.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "bun:test";
+
+import { selectStableResults } from "../context-composer-stable-selection.js";
+import { ResumeContextResponseSchema } from "../session-schema.js";
+import type { RetrievalResult } from "../retriever.js";
+
+// selectStableResults 产出的行必须过得了 stableContext 的 schema 上限。
+// 这条曾经断过：formatStableResult 截到 230、schema 上限 220，中间的
+// interleaveUnique（context-composer-stable.ts:199-206）不再截一次，
+// 于是 221~230 字符的行会让 composeResumeContext 末尾的
+// ResumeContextResponseSchema.parse 抛错，**整个 resume_context 调用失败**
+// —— 不是降级，是抛异常。实测 14 条真实问法里 1 条命中。
+//
+// 用长文本喂进去，逼出最长可能的输出，再拿真 schema 验，
+// 这样将来任一侧的数字被改动都会在这里红，而不是等生产上抛。
+
+const SCHEMA_MAX = 220;
+
+function longPreference(): RetrievalResult {
+  return {
+    entry: {
+      id: "test-long-pref",
+      // 远超上限的正文，确保格式化后会吃满截断长度
+      text: `用户确立的一条长期偏好：${"跨端协作时先确认目标仓库与路径再动手，".repeat(30)}`,
+      vector: [],
+      category: "preferences",
+      scope: "memory:pivot",
+      importance: 0.9,
+      timestamp: Date.now(),
+    },
+    score: 1,
+    sources: {},
+  } as RetrievalResult;
+}
+
+describe("stableContext 长度契约", () => {
+  it("超长偏好格式化后不超过 schema 上限", () => {
+    const lines = selectStableResults("preferences", [longPreference()], 3, {
+      taskSeed: "跨端协作要注意什么",
+    });
+    expect(lines.length).toBeGreaterThan(0);
+    for (const line of lines) {
+      expect(line.length).toBeLessThanOrEqual(SCHEMA_MAX);
+    }
+  });
+
+  it("这些行能通过真实的 ResumeContextResponseSchema", () => {
+    const stableContext = selectStableResults("preferences", [longPreference()], 3, {
+      taskSeed: "跨端协作要注意什么",
+    });
+    // 只验长度这一维：其余必填字段给最小合法值，schema 变动时这里也会跟着红
+    expect(() =>
+      ResumeContextResponseSchema.parse({
+        summary: "test",
+        generatedAt: new Date().toISOString(),
+        stableContext,
+        relevantPatterns: [],
+        recentCases: [],
+      }),
+    ).not.toThrow();
+  });
+});

package/src/__tests__/store-read-consistency.test.ts

@@ -0,0 +1,122 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { readConsistencyInterval as envReadConsistencyInterval } from "../env-config.js";
+import { MemoryStore } from "../store.js";
+
+const cleanupPaths: string[] = [];
+const savedEnv = process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL;
+
+afterEach(() => {
+  while (cleanupPaths.length > 0) {
+    const target = cleanupPaths.pop();
+    if (target) {
+      rmSync(target, { recursive: true, force: true });
+    }
+  }
+  if (savedEnv === undefined) {
+    delete process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL;
+  } else {
+    process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL = savedEnv;
+  }
+});
+
+function tempDb(): string {
+  const dbPath = mkdtempSync(join(tmpdir(), "recallnest-read-consistency-"));
+  cleanupPaths.push(dbPath);
+  return dbPath;
+}
+
+function entry(i: number) {
+  return {
+    text: `read-consistency memory ${i}`,
+    vector: [0.1 * i, 0.2 * i, 0.3 * i],
+    category: "fact" as const,
+    scope: "project:rci-test",
+    importance: 0.5,
+  };
+}
+
+// A writer always sees its own commits on its own handle; the staleness gap
+// only exists ACROSS handles. Two independent MemoryStore instances against
+// the same dbPath reproduce the cross-process topology (CLI ingest vs resident
+// MCP/API/UI server) in-process: the writer deletes a row after the reader's
+// handle has already opened the table.
+describe("read consistency across independent connections", () => {
+  it("default (env unset) is strong consistency: reader sees the writer's delete", async () => {
+    delete process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL;
+    const dbPath = tempDb();
+
+    const writer = new MemoryStore({ dbPath, vectorDim: 3 });
+    const e1 = await writer.store(entry(1));
+    await writer.store(entry(2));
+
+    const reader = new MemoryStore({ dbPath, vectorDim: 3 });
+    expect((await reader.list(undefined, undefined, 20, 0)).length).toBe(2);
+
+    await writer.delete(e1.id);
+
+    expect((await reader.list(undefined, undefined, 20, 0)).length).toBe(1);
+  });
+
+  it("env 'off' restores the legacy pinned-handle behavior (negative control)", async () => {
+    process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL = "off";
+    const dbPath = tempDb();
+
+    const writer = new MemoryStore({ dbPath, vectorDim: 3 });
+    const e1 = await writer.store(entry(1));
+    await writer.store(entry(2));
+
+    const reader = new MemoryStore({ dbPath, vectorDim: 3 });
+    expect((await reader.list(undefined, undefined, 20, 0)).length).toBe(2);
+
+    await writer.delete(e1.id);
+
+    expect((await reader.list(undefined, undefined, 20, 0)).length).toBe(2);
+  });
+
+  it("explicit config wins over env: interval 0 sees the delete despite env 'off'", async () => {
+    process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL = "off";
+    const dbPath = tempDb();
+
+    const writer = new MemoryStore({ dbPath, vectorDim: 3 });
+    const e1 = await writer.store(entry(1));
+    await writer.store(entry(2));
+
+    const reader = new MemoryStore({ dbPath, vectorDim: 3, readConsistencyInterval: 0 });
+    expect((await reader.list(undefined, undefined, 20, 0)).length).toBe(2);
+
+    await writer.delete(e1.id);
+
+    expect((await reader.list(undefined, undefined, 20, 0)).length).toBe(1);
+  });
+
+  // Cross-handle visibility behavior is pinned by the three tests above;
+  // what remains is the env parsing matrix of the resolver itself.
+  it("env resolver: unset/empty → 0, off/none → undefined, numbers pass, junk clamps to 0", () => {
+    delete process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL;
+    expect(envReadConsistencyInterval()).toBe(0);
+
+    process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL = "";
+    expect(envReadConsistencyInterval()).toBe(0);
+
+    for (const legacy of ["off", "none"]) {
+      process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL = legacy;
+      expect(envReadConsistencyInterval()).toBeUndefined();
+    }
+
+    process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL = "7";
+    expect(envReadConsistencyInterval()).toBe(7);
+    process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL = "1.5";
+    expect(envReadConsistencyInterval()).toBe(1.5);
+    process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL = "0";
+    expect(envReadConsistencyInterval()).toBe(0);
+
+    for (const junk of ["-3", "abc", "Infinity", "NaN"]) {
+      process.env.RECALLNEST_READ_CONSISTENCY_INTERVAL = junk;
+      expect(envReadConsistencyInterval()).toBe(0);
+    }
+  });
+});

package/src/__tests__/store-schema-migration.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it, afterEach } from "bun:test";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import * as lancedb from "@lancedb/lancedb";
+
+import { MemoryStore } from "../store.js";
+
+const DIM = 4;
+
+/**
+ * Regression: the pre-2026-04-09 table schema has 8 columns (no language /
+ * fts_text). The old migration check sampled a row to detect missing columns,
+ * so a 0-row legacy table never migrated and EVERY write then failed with
+ * "Found field not in schema: language". Production hit exactly this: a table
+ * created one day before the columns existed, empty for 3 months.
+ */
+
+async function createLegacyTable(dbPath: string, withRow: boolean) {
+  const db = await lancedb.connect(dbPath);
+  const seed = [
+    {
+      id: "__seed__",
+      text: withRow ? "legacy row" : "",
+      vector: new Array(DIM).fill(0),
+      category: "other",
+      scope: "s",
+      importance: 0.5,
+      timestamp: 1,
+      metadata: "{}",
+    },
+  ];
+  const t = await db.createTable("memories", seed);
+  if (!withRow) await t.delete('id = "__seed__"');
+  return t;
+}
+
+describe("MemoryStore schema migration (empty legacy table)", () => {
+  let dir = "";
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true });
+    dir = "";
+  });
+
+  it("migrates an EMPTY legacy table so writes succeed", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rn-mig-empty-"));
+    await createLegacyTable(dir, false);
+
+    const store = new MemoryStore({ dbPath: dir, vectorDim: DIM });
+    const entry = await store.store({
+      text: "first write after migration",
+      vector: new Array(DIM).fill(0.1),
+      category: "other",
+      scope: "s",
+      importance: 0.5,
+    });
+    expect(entry.id).toBeTruthy();
+
+    const db = await lancedb.connect(dir);
+    const t = await db.openTable("memories");
+    const fields = (await t.schema()).fields.map((f) => f.name);
+    expect(fields).toContain("language");
+    expect(fields).toContain("fts_text");
+  });
+
+  it("migrates a NON-EMPTY legacy table and backfills defaults", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rn-mig-full-"));
+    await createLegacyTable(dir, true);
+
+    const store = new MemoryStore({ dbPath: dir, vectorDim: DIM });
+    await store.store({
+      text: "second row",
+      vector: new Array(DIM).fill(0.2),
+      category: "other",
+      scope: "s",
+      importance: 0.5,
+    });
+
+    const db = await lancedb.connect(dir);
+    const t = await db.openTable("memories");
+    const rows = await t.query().toArray();
+    expect(rows).toHaveLength(2);
+    const legacy = rows.find((r) => r.id === "__seed__") as any;
+    expect(legacy.language).toBe("en");
+    expect(legacy.fts_text).toBe("legacy row");
+  });
+});

package/src/__tests__/store-upsert.test.ts

@@ -182,3 +182,20 @@ describe("store P0-2 idempotency (upsert-backed store/storeBatch)", () => {
     expect(rows.filter((r) => r.text === "batch-x" || r.text === "batch-y").length).toBe(2);
   });
 });
+
+describe("update() vector fallback (2026-07-23 null-vector regression)", () => {
+  it("metadata-only update preserves the original vector on healthy rows", async () => {
+    const store = makeStore();
+    const scope = "project:nullvec-test";
+    const entry = await store.store({
+      text: "健康行", vector: [0.1, 0.2, 0.3], category: "events", scope, importance: 0.7, metadata: "{}",
+    });
+    const updated = await store.update(entry.id, { metadata: JSON.stringify({ touched: true }) });
+    expect(updated).not.toBeNull();
+    // 修复 row.vector null-guard 后，正常行的 vector 必须原样保留（回归保护）
+    const rows = await store.list([scope]);
+    expect(rows.length).toBe(1);
+    const meta = JSON.parse(rows[0].metadata || "{}") as Record<string, unknown>;
+    expect(meta.touched).toBe(true);
+  });
+});

package/src/__tests__/term-registry-terminal-roster.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from "bun:test";
+
+import { selectStableResults } from "../context-composer-stable-selection.js";
+import { selectTaskResults } from "../context-composer-task-selection.js";
+import {
+  PREFERENCE_SPECIFICITY_GROUPS,
+  TASK_RESULT_SPECIFICITY_GROUPS,
+} from "../term-registry.js";
+import type { RetrievalResult } from "../retriever.js";
+
+// 端清单在检索术语簇里的落地。守两件事：
+//   ① 补上的端名真的解除了过滤（行为层）
+//   ② **有意的不对称不许被"机械补齐"抹掉**（结构层）——
+//      taskTerms 补端名、resultTerms 不补。这条最容易被后来人当成漏改而"顺手统一"，
+//      所以用测试钉住，并把理由写在断言旁边。
+// 背景同 memory-boundaries.ts:64-70 的 TRANSCRIPT_SOURCES —— 那处是字面 scope 前缀层，
+// 按字面补；这里是检索语义层，两侧方向相反，不能照抄。
+
+function stableCandidate(text: string): RetrievalResult {
+  return {
+    entry: {
+      id: `test-${text.slice(0, 8)}`,
+      text,
+      vector: [],
+      category: "preferences",
+      scope: "memory:pivot",
+      importance: 0.8,
+      timestamp: Date.now(),
+    },
+    score: 1,
+    sources: {},
+  } as RetrievalResult;
+}
+
+function taskCandidate(text: string): RetrievalResult {
+  return {
+    entry: {
+      id: `test-${text.slice(0, 8)}`,
+      text,
+      vector: [],
+      category: "cases",
+      scope: "memory:pivot",
+      importance: 0.8,
+      timestamp: Date.now(),
+    },
+    score: 1,
+    sources: {},
+  } as RetrievalResult;
+}
+
+// 会被 PREFERENCE_SPECIFICITY_GROUPS 认领的偏好（正文含 "codex" + "独立验证"）
+const CODEX_REVIEW_PREF =
+  "用户要求互审时由 Codex 做独立验证，交接材料里客观证据自动抽取，判断性材料必须手写填充。";
+
+describe("端清单 · PREFERENCE_SPECIFICITY_GROUPS", () => {
+  it("问 kimi / agy / antigravity 时不再把 CC·Codex 的验收偏好滤掉", () => {
+    for (const task of [
+      "kimi 互审的时候要注意什么",
+      "agy 那边是谁在做审查",
+      "antigravity 的会话是怎么接进来的",
+    ]) {
+      expect(
+        selectStableResults("preferences", [stableCandidate(CODEX_REVIEW_PREF)], 3, { taskSeed: task }),
+      ).toHaveLength(1);
+    }
+  });
+
+  it("问端拓扑本身（三端 / 四端）时同样解除", () => {
+    for (const task of ["四端的触发规则都装好了吗", "三端现在还一致吗"]) {
+      expect(
+        selectStableResults("preferences", [stableCandidate(CODEX_REVIEW_PREF)], 3, { taskSeed: task }),
+      ).toHaveLength(1);
+    }
+  });
+
+  it("与端无关的任务仍然滤掉 —— 放宽不能变成不过滤", () => {
+    for (const task of ["帮我写一篇公众号文章", "百度网盘上传断链怎么排查"]) {
+      expect(
+        selectStableResults("preferences", [stableCandidate(CODEX_REVIEW_PREF)], 3, { taskSeed: task }),
+      ).toHaveLength(0);
+    }
+  });
+
+  it("resultTerms 有意不含端名 —— 别照着 taskTerms 补齐", () => {
+    // resultTerms 是「谁被这组认领」，加裸端名会把"顺带提了一句 kimi"的无关偏好
+    // 整条变成可滤对象。已知实例：裸词 "codex" 已因 `.codex/AGENTS.md` 这种
+    // 路径片段误认领记忆（shadow 实测 b8731a81）。再加端名 = 把缺陷复制三份。
+    for (const term of ["kimi", "antigravity", "agy", "三端", "四端"]) {
+      expect(PREFERENCE_SPECIFICITY_GROUPS[0]?.resultTerms).not.toContain(term);
+    }
+    expect(PREFERENCE_SPECIFICITY_GROUPS[0]?.taskTerms).toEqual(
+      expect.arrayContaining(["kimi", "antigravity", "agy", "三端", "四端"]),
+    );
+  });
+});
+
+describe("端清单 · 三端历史事件组（TASK_RESULT_SPECIFICITY_GROUPS）", () => {
+  const historyGroup = TASK_RESULT_SPECIFICITY_GROUPS.find((group) =>
+    group.resultTerms.includes("three-terminal continuity trigger validation"),
+  );
+
+  it("resultTerms 是历史专名，不是端清单 —— 不补任何端名", () => {
+    expect(historyGroup).toBeDefined();
+    for (const term of ["kimi", "antigravity", "agy"]) {
+      expect(historyGroup?.resultTerms).not.toContain(term);
+    }
+  });
+
+  it("taskTerms 补她真实的问法（三端 / 四端），但同样不补端名", () => {
+    // "三端" 不是 "三终端" 的子串，补之前真的匹配不上
+    expect(historyGroup?.taskTerms).toEqual(expect.arrayContaining(["三端", "四端"]));
+    for (const term of ["kimi", "antigravity", "agy"]) {
+      expect(historyGroup?.taskTerms).not.toContain(term);
+    }
+  });
+
+  it("只提端名、不问触发/接入的任务，不该把这条三端历史放进来", () => {
+    const history = taskCandidate(
+      "三端连续性触发验证：three-terminal continuity trigger validation 已完成，continue-style prompts triggered recall reliably。",
+    );
+    expect(selectTaskResults("cases", [history], 3, { taskSeed: "kimi 挂了" })).toHaveLength(0);
+    // 对照：真正相关的问法照旧放行
+    expect(
+      selectTaskResults("cases", [history], 3, { taskSeed: "三端的触发验证结论还成立吗" }).length,
+    ).toBeGreaterThan(0);
+  });
+});