recallnest 2.2.1 → 2.5.4

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

@@ -0,0 +1,122 @@
+import { describe, test, expect } from "bun:test";
+import { verifyDraft, tokensOf, type VerifyDraft, type VerifyEvidence } from "../skill-verifier.js";
+
+describe("verifyDraft — tool coverage", () => {
+  test("passes when draft tools ⊆ evidence tools and narrative resonates", () => {
+    const draft: VerifyDraft = {
+      tools: ["git", "bun test"],
+      summary: "Fix the failing deploy by resetting the database migration",
+      steps: ["reset migration", "rerun deploy"],
+    };
+    const evidence: VerifyEvidence[] = [
+      { text: "deploy failed, reset migration then rerun deploy worked", tools: ["git", "bun test"] },
+      { text: "another deploy reset migration fix", tools: ["git"] },
+    ];
+    const r = verifyDraft(draft, evidence);
+    expect(r.ok).toBe(true);
+    expect(r.coverage).toBe(1);
+    expect(r.unmappedTools).toEqual([]);
+  });
+
+  test("fails coverage when draft claims a tool no evidence used (hallucinated command)", () => {
+    const draft: VerifyDraft = {
+      tools: ["fictional_cmd", "another_fake"],
+      summary: "deploy reset migration rerun",
+      steps: [],
+    };
+    const evidence: VerifyEvidence[] = [
+      { text: "deploy reset migration rerun worked", tools: ["git"] },
+    ];
+    const r = verifyDraft(draft, evidence);
+    expect(r.ok).toBe(false);
+    expect(r.reason).toContain("coverage");
+    expect(r.unmappedTools).toContain("fictional_cmd");
+  });
+
+  test("empty draft tools → coverage 1 (nothing to hallucinate), judged on resonance only", () => {
+    const draft: VerifyDraft = { tools: [], summary: "deploy reset migration", steps: [] };
+    const evidence: VerifyEvidence[] = [
+      { text: "deploy reset migration done", tools: [] },
+      { text: "deploy reset migration again", tools: [] },
+    ];
+    const r = verifyDraft(draft, evidence);
+    expect(r.coverage).toBe(1);
+    expect(r.ok).toBe(true);
+  });
+
+  test("coverage exactly 0.5 (1 of 2 tools mapped) passes the strict < 0.5 threshold", () => {
+    const r = verifyDraft(
+      { tools: ["git", "fake_cmd"], summary: "deploy reset migration rerun", steps: [] },
+      [{ text: "deploy reset migration rerun", tools: ["git"] }],
+    );
+    expect(r.coverage).toBe(0.5);
+    expect(r.reason ?? "").not.toContain("coverage");
+    expect(r.unmappedTools).toContain("fake_cmd");
+  });
+});
+
+describe("verifyDraft — evidence resonance", () => {
+  test("fails resonance when narrative shares no tokens with evidence", () => {
+    const draft: VerifyDraft = {
+      tools: [],
+      summary: "quantum entanglement teleportation protocol alpha",
+      steps: ["calibrate flux capacitor"],
+    };
+    const evidence: VerifyEvidence[] = [
+      { text: "deploy database migration reset rerun", tools: [] },
+      { text: "another unrelated commit push branch", tools: [] },
+    ];
+    const r = verifyDraft(draft, evidence);
+    expect(r.ok).toBe(false);
+    expect(r.reason).toContain("resonance");
+  });
+
+  test("CJK: passes resonance on Chinese pattern + cases sharing ≥2 bigrams", () => {
+    const draft: VerifyDraft = {
+      tools: [],
+      summary: "重启服务前先检查代理端口配置",
+      steps: ["确认代理端口", "重启服务"],
+    };
+    const evidence: VerifyEvidence[] = [
+      { text: "重启服务后代理端口失效，检查配置解决", tools: [] },
+      { text: "代理端口配置错误导致重启失败", tools: [] },
+    ];
+    const r = verifyDraft(draft, evidence);
+    expect(r.ok).toBe(true);
+    expect(r.resonance).toBeGreaterThanOrEqual(0.5);
+  });
+});
+
+describe("verifyDraft — boundaries", () => {
+  test("empty evidence → no-evidence verdict", () => {
+    const r = verifyDraft({ tools: ["git"], summary: "x", steps: [] }, []);
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("no-evidence");
+  });
+
+  test("verdict always carries coverage + resonance numbers", () => {
+    const r = verifyDraft(
+      { tools: ["git"], summary: "deploy reset migration rerun", steps: [] },
+      [{ text: "deploy reset migration rerun", tools: ["git"] }],
+    );
+    expect(typeof r.coverage).toBe("number");
+    expect(typeof r.resonance).toBe("number");
+  });
+});
+
+describe("tokensOf", () => {
+  test("extracts ASCII identifiers ≥4 chars, drops stopwords", () => {
+    const toks = tokensOf("deploy the database migration");
+    expect(toks.has("deploy")).toBe(true);
+    expect(toks.has("database")).toBe(true);
+    expect(toks.has("migration")).toBe(true);
+    expect(toks.has("the")).toBe(false);
+  });
+
+  test("extracts CJK 2-gram bigrams", () => {
+    const toks = tokensOf("重启服务");
+    expect(toks.has("重启")).toBe(true);
+    expect(toks.has("启服")).toBe(true);
+    expect(toks.has("服务")).toBe(true);
+  });
+});

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

@@ -0,0 +1,250 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test";
+import { existsSync, mkdirSync, rmSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  readHeartbeats,
+  writeHeartbeat,
+  checkSourceStaleness,
+  formatAge,
+  type HeartbeatFile,
+} from "../source-heartbeat.js";
+import { runDataCheckup } from "../data-checkup.js";
+import type { MemoryEntry, MemoryStore } from "../store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function tmpHeartbeatPath(): string {
+  const dir = join(tmpdir(), `recallnest-test-heartbeat-${Date.now()}`);
+  mkdirSync(dir, { recursive: true });
+  return join(dir, "source-heartbeat.json");
+}
+
+function makeEntry(id: string): MemoryEntry {
+  return {
+    id,
+    text: "test memory",
+    vector: [1, 0, 0, 0, 0],
+    category: "events",
+    scope: "project:test",
+    importance: 0.7,
+    timestamp: Date.now(),
+    metadata: JSON.stringify({
+      evolution: {
+        status: "active",
+        version: 1,
+        accessCount: 0,
+        lastAccessedAt: null,
+        supersededBy: null,
+        consolidatedInto: null,
+        contributedToPattern: null,
+        sourceMemories: [],
+        validFrom: Date.now(),
+        validUntil: null,
+      },
+    }),
+  };
+}
+
+function createMockStore(entries: MemoryEntry[]): Pick<MemoryStore, "list" | "stats" | "getVectors"> {
+  return {
+    // 复刻真实 store:list() 为性能不返回向量,诊断检查经 getVectors 补回。
+    async list() { return entries.map(e => ({ ...e, vector: [] })); },
+    async stats() {
+      return { totalCount: entries.length, scopeCounts: {}, categoryCounts: {} };
+    },
+    async getVectors(ids: string[]) {
+      const map = new Map<string, number[]>();
+      for (const e of entries) {
+        if (ids.includes(e.id) && e.vector && e.vector.length > 0) map.set(e.id, e.vector);
+      }
+      return map;
+    },
+  } as Pick<MemoryStore, "list" | "stats" | "getVectors">;
+}
+
+// ---------------------------------------------------------------------------
+// Tests: readHeartbeats / writeHeartbeat
+// ---------------------------------------------------------------------------
+
+describe("source-heartbeat", () => {
+  let tmpPath: string;
+
+  beforeEach(() => {
+    tmpPath = tmpHeartbeatPath();
+  });
+
+  afterEach(() => {
+    try {
+      const dir = join(tmpPath, "..");
+      rmSync(dir, { recursive: true, force: true });
+    } catch { /* ignore */ }
+  });
+
+  it("returns empty object when file does not exist", () => {
+    const result = readHeartbeats(tmpPath);
+    expect(result).toEqual({});
+  });
+
+  it("writes and reads back a heartbeat", () => {
+    writeHeartbeat("obsidian", 42, [], tmpPath);
+
+    const heartbeats = readHeartbeats(tmpPath);
+    expect(Object.keys(heartbeats)).toEqual(["obsidian"]);
+    expect(heartbeats.obsidian.source).toBe("obsidian");
+    expect(heartbeats.obsidian.recordsIngested).toBe(42);
+    expect(heartbeats.obsidian.errors).toEqual([]);
+    expect(heartbeats.obsidian.lastIngest).toBeTruthy();
+  });
+
+  it("updates existing source without losing other sources", () => {
+    writeHeartbeat("obsidian", 10, [], tmpPath);
+    writeHeartbeat("email", 5, ["timeout"], tmpPath);
+    writeHeartbeat("obsidian", 20, [], tmpPath); // update
+
+    const heartbeats = readHeartbeats(tmpPath);
+    expect(Object.keys(heartbeats).sort()).toEqual(["email", "obsidian"]);
+    expect(heartbeats.obsidian.recordsIngested).toBe(20);
+    expect(heartbeats.email.recordsIngested).toBe(5);
+    expect(heartbeats.email.errors).toEqual(["timeout"]);
+  });
+
+  it("caps stored errors to 10", () => {
+    const manyErrors = Array.from({ length: 15 }, (_, i) => `error-${i}`);
+    writeHeartbeat("broken", 0, manyErrors, tmpPath);
+
+    const heartbeats = readHeartbeats(tmpPath);
+    expect(heartbeats.broken.errors.length).toBe(10);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: checkSourceStaleness
+// ---------------------------------------------------------------------------
+
+describe("checkSourceStaleness", () => {
+  let tmpPath: string;
+
+  beforeEach(() => {
+    tmpPath = tmpHeartbeatPath();
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(join(tmpPath, ".."), { recursive: true, force: true });
+    } catch { /* ignore */ }
+  });
+
+  it("returns empty for fresh sources", () => {
+    writeHeartbeat("obsidian", 10, [], tmpPath);
+    const stale = checkSourceStaleness(7, tmpPath);
+    expect(stale).toEqual([]);
+  });
+
+  it("detects stale sources", () => {
+    // Manually write a stale heartbeat
+    const staleDate = new Date(Date.now() - 10 * 86_400_000).toISOString();
+    const heartbeats: HeartbeatFile = {
+      old_source: {
+        source: "old_source",
+        lastIngest: staleDate,
+        recordsIngested: 5,
+        errors: [],
+      },
+    };
+    const { writeFileSync } = require("node:fs");
+    writeFileSync(tmpPath, JSON.stringify(heartbeats));
+
+    const stale = checkSourceStaleness(7, tmpPath);
+    expect(stale.length).toBe(1);
+    expect(stale[0].source).toBe("old_source");
+    expect(stale[0].daysSince).toBeGreaterThanOrEqual(9);
+  });
+
+  it("returns empty for missing file", () => {
+    const stale = checkSourceStaleness(7, "/tmp/nonexistent-path.json");
+    expect(stale).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: formatAge
+// ---------------------------------------------------------------------------
+
+describe("formatAge", () => {
+  it("returns 'just now' for recent timestamps", () => {
+    expect(formatAge(new Date().toISOString())).toBe("just now");
+  });
+
+  it("returns hours for <24h", () => {
+    const twoHoursAgo = new Date(Date.now() - 2 * 3_600_000).toISOString();
+    expect(formatAge(twoHoursAgo)).toBe("2h ago");
+  });
+
+  it("returns days for >=24h", () => {
+    const threeDaysAgo = new Date(Date.now() - 3 * 86_400_000).toISOString();
+    expect(formatAge(threeDaysAgo)).toBe("3d ago");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: data_checkup integration
+// ---------------------------------------------------------------------------
+
+describe("data_checkup with source_health", () => {
+  let tmpPath: string;
+
+  beforeEach(() => {
+    tmpPath = tmpHeartbeatPath();
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(join(tmpPath, ".."), { recursive: true, force: true });
+    } catch { /* ignore */ }
+  });
+
+  it("includes source_health check (8 checks total)", async () => {
+    const entries = [makeEntry("a"), makeEntry("b")];
+    const report = await runDataCheckup({
+      store: createMockStore(entries),
+      openConflictCount: 0,
+      heartbeatPath: tmpPath,
+    });
+
+    expect(report.checks.length).toBe(8);
+    const sourceCheck = report.checks.find((c) => c.name === "source_health");
+    expect(sourceCheck).toBeTruthy();
+    expect(sourceCheck!.status).toBe("ok");
+    expect(sourceCheck!.detail).toContain("No connector sources tracked yet");
+  });
+
+  it("reports warning for stale sources", async () => {
+    // Write a stale heartbeat
+    const staleDate = new Date(Date.now() - 10 * 86_400_000).toISOString();
+    const heartbeats: HeartbeatFile = {
+      email: {
+        source: "email",
+        lastIngest: staleDate,
+        recordsIngested: 5,
+        errors: [],
+      },
+    };
+    const { writeFileSync } = require("node:fs");
+    writeFileSync(tmpPath, JSON.stringify(heartbeats));
+
+    const entries = [makeEntry("a")];
+    const report = await runDataCheckup({
+      store: createMockStore(entries),
+      openConflictCount: 0,
+      heartbeatPath: tmpPath,
+    });
+
+    const sourceCheck = report.checks.find((c) => c.name === "source_health");
+    expect(sourceCheck).toBeTruthy();
+    expect(sourceCheck!.status).toBe("warning");
+    expect(sourceCheck!.detail).toContain("stale");
+  });
+});

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

@@ -0,0 +1,205 @@
+/**
+ * Tests for the store-level metadata write channel (P0 Track A):
+ * - update() atomic upsert via mergeInsert (no delete+add vanish window)
+ * - patchMetadata() per-id serial queue: no lost increments under concurrency,
+ *   rejection isolation, queue self-cleanup, prefix/full-id queue sharing
+ * - listPage() true DB-level pagination with category filter and includeVector
+ */
+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 { MemoryStore, type MemoryEntry } from "../store.js";
+
+const cleanupPaths: string[] = [];
+
+afterEach(() => {
+  while (cleanupPaths.length > 0) {
+    const target = cleanupPaths.pop();
+    if (target) {
+      rmSync(target, { recursive: true, force: true });
+    }
+  }
+});
+
+function createStore(): MemoryStore {
+  const dbPath = mkdtempSync(join(tmpdir(), "recallnest-patch-meta-"));
+  cleanupPaths.push(dbPath);
+  return new MemoryStore({ dbPath, vectorDim: 3 });
+}
+
+async function seed(store: MemoryStore, overrides: Partial<MemoryEntry> = {}): Promise<MemoryEntry> {
+  return store.store({
+    text: "patch metadata target",
+    vector: [1, 0, 0],
+    category: "cases",
+    scope: "project:patch-test",
+    importance: 0.6,
+    metadata: "{}",
+    ...overrides,
+  });
+}
+
+describe("MemoryStore.update (mergeInsert upsert)", () => {
+  it("keeps the row continuously visible and intact after update", async () => {
+    const store = createStore();
+    const entry = await seed(store);
+
+    const updated = await store.update(entry.id, { metadata: JSON.stringify({ marker: 1 }) });
+    expect(updated).not.toBeNull();
+
+    // Immediately readable by id, by list, and by vector search
+    const byId = await store.getById(entry.id);
+    expect(byId?.id).toBe(entry.id);
+    expect(JSON.parse(byId?.metadata || "{}").marker).toBe(1);
+
+    const listed = await store.list(["project:patch-test"]);
+    expect(listed.map(e => e.id)).toContain(entry.id);
+
+    const hits = await store.vectorSearch([1, 0, 0], 5, 0, ["project:patch-test"]);
+    expect(hits.map(h => h.entry.id)).toContain(entry.id);
+
+    // Vector column survived the upsert
+    const vectors = await store.getVectors([entry.id]);
+    expect(vectors.get(entry.id)).toEqual([1, 0, 0]);
+
+    // No duplicate row was created
+    const all = await store.list(["project:patch-test"], undefined, 100, 0);
+    expect(all.filter(e => e.id === entry.id)).toHaveLength(1);
+  });
+});
+
+describe("MemoryStore.patchMetadata", () => {
+  it("does not lose increments under 20 concurrent mixed patches on one id", async () => {
+    const store = createStore();
+    const entry = await seed(store);
+
+    const jobs: Array<Promise<unknown>> = [];
+    for (let i = 0; i < 10; i++) {
+      jobs.push(store.patchMetadata(entry.id, meta => {
+        const usage = (meta.usage as Record<string, unknown> | undefined) ?? {};
+        const count = typeof usage.useCount === "number" ? usage.useCount : 0;
+        meta.usage = { ...usage, useCount: count + 1 };
+        return meta;
+      }));
+      jobs.push(store.patchMetadata(entry.id, meta => {
+        const count = typeof meta.accessCount === "number" ? meta.accessCount : 0;
+        meta.accessCount = count + 1;
+        return meta;
+      }));
+    }
+    await Promise.all(jobs);
+
+    const after = await store.getById(entry.id);
+    const meta = JSON.parse(after?.metadata || "{}");
+    expect(meta.usage.useCount).toBe(10);
+    expect(meta.accessCount).toBe(10);
+  });
+
+  it("rejects the failing patch only; later patches still run; queue self-cleans", async () => {
+    const store = createStore();
+    const entry = await seed(store);
+
+    const first = store.patchMetadata(entry.id, meta => {
+      meta.step = 1;
+      return meta;
+    });
+    const failing = store.patchMetadata(entry.id, () => {
+      throw new Error("boom");
+    });
+    const third = store.patchMetadata(entry.id, meta => {
+      meta.step = 3;
+      return meta;
+    });
+
+    await expect(failing).rejects.toThrow("boom");
+    await first;
+    await third;
+
+    const after = await store.getById(entry.id);
+    expect(JSON.parse(after?.metadata || "{}").step).toBe(3);
+    expect(store.pendingMetadataPatchCount).toBe(0);
+  });
+
+  it("routes prefix and full-id callers through the same queue", async () => {
+    const store = createStore();
+    const entry = await seed(store);
+    // getById prefix semantics = string prefix (LIKE 'xxx%'), so take the
+    // first 8 hex chars (the segment before the first hyphen).
+    const prefix = entry.id.slice(0, 8);
+
+    const jobs: Array<Promise<unknown>> = [];
+    for (let i = 0; i < 10; i++) {
+      jobs.push(store.patchMetadata(entry.id, meta => {
+        const count = typeof meta.n === "number" ? meta.n : 0;
+        meta.n = count + 1;
+        return meta;
+      }));
+      jobs.push(store.patchMetadata(prefix, meta => {
+        const count = typeof meta.n === "number" ? meta.n : 0;
+        meta.n = count + 1;
+        return meta;
+      }));
+    }
+    await Promise.all(jobs);
+
+    const after = await store.getById(entry.id);
+    expect(JSON.parse(after?.metadata || "{}").n).toBe(20);
+    expect(store.pendingMetadataPatchCount).toBe(0);
+  });
+
+  it("returns null for a missing id without queue residue", async () => {
+    const store = createStore();
+    await seed(store); // initialize table
+    const result = await store.patchMetadata("00000000-0000-4000-8000-000000000000", meta => meta);
+    expect(result).toBeNull();
+    // settle the no-op queue entry
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(store.pendingMetadataPatchCount).toBe(0);
+  });
+
+  it("enforces scope permissions like update()", async () => {
+    const store = createStore();
+    const entry = await seed(store);
+    await expect(
+      store.patchMetadata(entry.id, meta => meta, ["project:other"]),
+    ).rejects.toThrow(/outside accessible scopes/);
+  });
+});
+
+describe("MemoryStore.listPage", () => {
+  it("paginates at the DB level with category pushdown", async () => {
+    const store = createStore();
+    for (let i = 0; i < 7; i++) {
+      await seed(store, { text: `case ${i}`, category: "cases" });
+    }
+    for (let i = 0; i < 3; i++) {
+      await seed(store, { text: `pattern ${i}`, category: "patterns", vector: [0, 1, 0] });
+    }
+
+    const page1 = await store.listPage({ scopeFilter: ["project:patch-test"], category: "cases", limit: 4, offset: 0 });
+    const page2 = await store.listPage({ scopeFilter: ["project:patch-test"], category: "cases", limit: 4, offset: 4 });
+    expect(page1).toHaveLength(4);
+    expect(page2).toHaveLength(3);
+    expect([...page1, ...page2].every(e => e.category === "cases")).toBe(true);
+    // No overlap between pages
+    const ids = new Set([...page1, ...page2].map(e => e.id));
+    expect(ids.size).toBe(7);
+
+    const patterns = await store.listPage({ scopeFilter: ["project:patch-test"], category: "patterns", limit: 100 });
+    expect(patterns).toHaveLength(3);
+  });
+
+  it("omits vectors by default and returns them with includeVector", async () => {
+    const store = createStore();
+    await seed(store);
+
+    const [bare] = await store.listPage({ scopeFilter: ["project:patch-test"], limit: 1 });
+    expect(bare.vector).toEqual([]);
+
+    const [withVec] = await store.listPage({ scopeFilter: ["project:patch-test"], limit: 1, includeVector: true });
+    expect(withVec.vector).toEqual([1, 0, 0]);
+  });
+});

package/src/__tests__/store-scope-audit.test.ts

@@ -0,0 +1,81 @@
+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 { MemoryStore, classifyLegacyScope } from "../store.js";
+
+const cleanupPaths: string[] = [];
+
+afterEach(() => {
+  while (cleanupPaths.length > 0) {
+    const target = cleanupPaths.pop();
+    if (target) {
+      rmSync(target, { recursive: true, force: true });
+    }
+  }
+});
+
+function createStore(): MemoryStore {
+  const dbPath = mkdtempSync(join(tmpdir(), "recallnest-scope-audit-"));
+  cleanupPaths.push(dbPath);
+  return new MemoryStore({
+    dbPath,
+    vectorDim: 3,
+  });
+}
+
+describe("classifyLegacyScope", () => {
+  it("flags missing, empty, and global scope values", () => {
+    expect(classifyLegacyScope(undefined)).toBe("missing");
+    expect(classifyLegacyScope(null)).toBe("missing");
+    expect(classifyLegacyScope("")).toBe("empty");
+    expect(classifyLegacyScope("   ")).toBe("empty");
+    expect(classifyLegacyScope("global")).toBe("global");
+    expect(classifyLegacyScope(" global ")).toBe("global");
+    expect(classifyLegacyScope("project:recallnest")).toBeUndefined();
+  });
+});
+
+describe("MemoryStore.auditLegacyScopes", () => {
+  it("reports global and empty scope rows without mixing in valid scoped data", async () => {
+    const store = createStore();
+
+    await store.store({
+      text: "Scoped memory should not appear in the audit.",
+      vector: [1, 0, 0],
+      category: "entities",
+      scope: "project:recallnest",
+      importance: 0.8,
+      metadata: "{}",
+    });
+    await store.store({
+      text: "Historical row that used the global fallback.",
+      vector: [0, 1, 0],
+      category: "events",
+      scope: "global",
+      importance: 0.5,
+      metadata: "{}",
+    });
+    await store.store({
+      text: "Historical row that was written without a real scope.",
+      vector: [0, 0, 1],
+      category: "events",
+      scope: "   ",
+      importance: 0.4,
+      metadata: "{}",
+    });
+
+    const audit = await store.auditLegacyScopes(10);
+
+    expect(audit.totalCount).toBe(2);
+    expect(audit.counts).toEqual({
+      missing: 0,
+      empty: 1,
+      global: 1,
+    });
+    expect(audit.samples).toHaveLength(2);
+    expect(audit.samples.map((sample) => sample.kind).sort()).toEqual(["empty", "global"]);
+    expect(audit.samples.every((sample) => sample.scope !== "project:recallnest")).toBe(true);
+  });
+});