recallnest 3.0.0 → 4.0.0

package/src/__tests__/scope-inventory.test.ts

@@ -1,200 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { collectScopeInventory, formatScopeInventoryReport } from "../scope-inventory.js";
-import { MemoryStore } from "../store.js";
-
-const cleanupPaths: string[] = [];
-
-afterEach(() => {
-  while (cleanupPaths.length > 0) {
-    const target = cleanupPaths.pop();
-    if (target) {
-      rmSync(target, { recursive: true, force: true });
-    }
-  }
-});
-
-function createTempRoot(): string {
-  const root = mkdtempSync(join(tmpdir(), "recallnest-scope-inventory-"));
-  cleanupPaths.push(root);
-  return root;
-}
-
-function writeJson(dir: string, name: string, payload: unknown): void {
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, name), JSON.stringify(payload, null, 2) + "\n");
-}
-
-describe("collectScopeInventory", () => {
-  it("audits memories, pins, checkpoints, and workflow observations separately", async () => {
-    const root = createTempRoot();
-    const store = new MemoryStore({
-      dbPath: join(root, "db"),
-      vectorDim: 3,
-    });
-
-    await store.store({
-      text: "Scoped durable memory.",
-      vector: [1, 0, 0],
-      category: "entities",
-      scope: "project:recallnest",
-      importance: 0.8,
-      metadata: "{}",
-    });
-    await store.store({
-      text: "Historical global memory row.",
-      vector: [0, 1, 0],
-      category: "events",
-      scope: "global",
-      importance: 0.5,
-      metadata: "{}",
-    });
-
-    const pinsDir = join(root, "pins");
-    writeJson(pinsDir, "pin-legacy.json", {
-      id: "pin-legacy",
-      type: "pinned-memory",
-      title: "Legacy pin",
-      summary: "Pinned from an old global row.",
-      source: {
-        memoryId: "memory-1",
-        scope: "global",
-        timestamp: Date.now(),
-        metadata: {},
-      },
-      createdAt: "2026-03-18T00:00:00.000Z",
-      updatedAt: "2026-03-18T00:00:00.000Z",
-      snippet: "Legacy pin snippet.",
-    });
-
-    const checkpointsDir = join(root, "session-checkpoints");
-    writeJson(checkpointsDir, "checkpoint-legacy.json", {
-      checkpointId: "checkpoint-legacy",
-      sessionId: "session-1",
-      resolvedScope: "   ",
-      summary: "Old checkpoint that never got a real resolved scope.",
-      updatedAt: "2026-03-18T00:01:00.000Z",
-    });
-
-    const workflowDir = join(root, "workflow-observations");
-    writeJson(workflowDir, "workflow-legacy.json", {
-      observationId: "workflow-legacy",
-      workflowId: "resume_context",
-      resolvedScope: null,
-      summary: "Legacy workflow observation missing scope.",
-      recordedAt: "2026-03-18T00:02:00.000Z",
-    });
-    mkdirSync(workflowDir, { recursive: true });
-    writeFileSync(join(workflowDir, "broken.json"), "{not-json");
-
-    const report = await collectScopeInventory({
-      store,
-      sampleLimit: 10,
-      pinsDir,
-      checkpointsDir,
-      workflowObservationsDir: workflowDir,
-    });
-
-    expect(report.totalScannedCount).toBe(6);
-    expect(report.totalAnomalyCount).toBe(4);
-    expect(report.totalInvalidCount).toBe(1);
-    expect(report.totalReviewedCount).toBe(0);
-
-    const memoryLayer = report.layers.find((layer) => layer.layer === "memories");
-    const pinLayer = report.layers.find((layer) => layer.layer === "pins");
-    const checkpointLayer = report.layers.find((layer) => layer.layer === "session-checkpoints");
-    const workflowLayer = report.layers.find((layer) => layer.layer === "workflow-observations");
-
-    expect(memoryLayer?.anomalyCount).toBe(1);
-    expect(memoryLayer?.counts.global).toBe(1);
-    expect(pinLayer?.anomalyCount).toBe(1);
-    expect(pinLayer?.counts.global).toBe(1);
-    expect(checkpointLayer?.anomalyCount).toBe(1);
-    expect(checkpointLayer?.counts.empty).toBe(1);
-    expect(workflowLayer?.anomalyCount).toBe(1);
-    expect(workflowLayer?.counts.missing).toBe(1);
-    expect(workflowLayer?.invalidCount).toBe(1);
-    expect(workflowLayer?.reviewedCount).toBe(0);
-
-    const output = formatScopeInventoryReport(report);
-    expect(output).toContain("Scope inventory");
-    expect(output).toContain("[memories]");
-    expect(output).toContain("[pins]");
-    expect(output).toContain("[session-checkpoints]");
-    expect(output).toContain("[workflow-observations]");
-  });
-
-  it("returns a clean report when every layer is scoped correctly", async () => {
-    const root = createTempRoot();
-    const store = new MemoryStore({
-      dbPath: join(root, "db"),
-      vectorDim: 3,
-    });
-
-    await store.store({
-      text: "Scoped memory.",
-      vector: [1, 0, 0],
-      category: "entities",
-      scope: "project:recallnest",
-      importance: 0.9,
-      metadata: "{}",
-    });
-
-    const report = await collectScopeInventory({
-      store,
-      sampleLimit: 5,
-      pinsDir: join(root, "missing-pins"),
-      checkpointsDir: join(root, "missing-checkpoints"),
-      workflowObservationsDir: join(root, "missing-workflows"),
-    });
-
-    expect(report.totalScannedCount).toBe(1);
-    expect(report.totalAnomalyCount).toBe(0);
-    expect(report.totalInvalidCount).toBe(0);
-    expect(report.totalReviewedCount).toBe(0);
-    expect(report.layers.every((layer) => layer.samples.length === 0)).toBe(true);
-    expect(formatScopeInventoryReport(report)).toContain("No unresolved legacy scope anomalies found");
-  });
-
-  it("suppresses reviewed keep-global workflow observations from unresolved anomaly counts", async () => {
-    const root = createTempRoot();
-    const store = new MemoryStore({
-      dbPath: join(root, "db"),
-      vectorDim: 3,
-    });
-
-    const workflowDir = join(root, "workflow-observations");
-    writeJson(workflowDir, "workflow-reviewed.json", {
-      observationId: "workflow-reviewed",
-      workflowId: "resume_context",
-      resolvedScope: "global",
-      summary: "Legacy workflow observation intentionally left global.",
-      recordedAt: "2026-03-18T00:02:00.000Z",
-      legacyScopeReview: {
-        decision: "keep",
-        kind: "global",
-        reason: "external-task",
-        reviewedAt: "2026-03-18T00:03:00.000Z",
-      },
-    });
-
-    const report = await collectScopeInventory({
-      store,
-      sampleLimit: 5,
-      workflowObservationsDir: workflowDir,
-      pinsDir: join(root, "missing-pins"),
-      checkpointsDir: join(root, "missing-checkpoints"),
-    });
-
-    const workflowLayer = report.layers.find((layer) => layer.layer === "workflow-observations");
-    expect(report.totalAnomalyCount).toBe(0);
-    expect(report.totalReviewedCount).toBe(1);
-    expect(workflowLayer?.anomalyCount).toBe(0);
-    expect(workflowLayer?.reviewedCount).toBe(1);
-    expect(workflowLayer?.samples).toHaveLength(0);
-    expect(formatScopeInventoryReport(report)).toContain("Reviewed keeps : 1");
-  });
-});

package/src/__tests__/scope-policy.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { matchesScopeFilter, resolveScopeSelection, resolveSessionScope } from "../scope-policy.js";
-
-describe("scope-policy", () => {
-  it("prefers explicit scope over inferred values", () => {
-    const resolved = resolveScopeSelection({
-      scope: "project:recallnest",
-      sessionId: "session-123",
-      operation: "test:search",
-      env: {
-        RECALLNEST_DEFAULT_SCOPE: "project:other",
-      } as NodeJS.ProcessEnv,
-    });
-
-    expect(resolved.resolvedScope).toBe("project:recallnest");
-    expect(resolved.scopeFilter).toEqual(["project:recallnest"]);
-    expect(resolved.inferredFrom).toBe("scope");
-  });
-
-  it("falls back to session scope when explicit scope is absent", () => {
-    expect(resolveSessionScope("session-123")).toBe("session:session-123");
-
-    const resolved = resolveScopeSelection({
-      sessionId: "session-123",
-      operation: "test:search",
-      env: {} as NodeJS.ProcessEnv,
-    });
-
-    expect(resolved.resolvedScope).toBe("session:session-123");
-    expect(resolved.scopeFilter).toEqual(["session:session-123"]);
-    expect(resolved.inferredFrom).toBe("sessionId");
-  });
-
-  it("uses environment defaults when request scope is omitted", () => {
-    const resolved = resolveScopeSelection({
-      operation: "test:search",
-      env: {
-        RECALLNEST_DEFAULT_SCOPE: "project:recallnest",
-      } as NodeJS.ProcessEnv,
-    });
-
-    expect(resolved.resolvedScope).toBe("project:recallnest");
-    expect(resolved.scopeFilter).toEqual(["project:recallnest"]);
-    expect(resolved.inferredFrom).toBe("RECALLNEST_DEFAULT_SCOPE");
-  });
-
-  it("requires explicit opt-in before allowing cross-scope reads", () => {
-    expect(() => resolveScopeSelection({
-      operation: "test:search",
-      env: {} as NodeJS.ProcessEnv,
-    })).toThrow("requires a scope");
-
-    const allScopes = resolveScopeSelection({
-      operation: "test:search",
-      allScopes: true,
-      env: {} as NodeJS.ProcessEnv,
-    });
-
-    expect(allScopes.allScopes).toBe(true);
-    expect(allScopes.scopeFilter).toBeUndefined();
-  });
-
-  it("matches both exact and prefix scope filters", () => {
-    expect(matchesScopeFilter("project:recallnest", ["project:recallnest"])).toBe(true);
-    expect(matchesScopeFilter("cc:session-123", ["cc"])).toBe(true);
-    expect(matchesScopeFilter("project:other", ["project:recallnest"])).toBe(false);
-  });
-});

package/src/__tests__/scope-suggester.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  boundedLevenshtein,
-  createScopeSuggester,
-  formatScopeSuggestion,
-  normalizeScope,
-  suggestScopes,
-} from "../scope-suggester.js";
-
-describe("normalizeScope", () => {
-  it("lowercases and strips separators", () => {
-    expect(normalizeScope("CC-Foo")).toBe("ccfoo");
-    expect(normalizeScope("cc_foo bar")).toBe("ccfoobar");
-  });
-});
-
-describe("boundedLevenshtein", () => {
-  it("computes small distances and early-exits beyond max", () => {
-    expect(boundedLevenshtein("recallnest", "recallnest", 2)).toBe(0);
-    expect(boundedLevenshtein("recallnst", "recallnest", 2)).toBe(1);
-    expect(boundedLevenshtein("recalnst", "recallnest", 2)).toBe(2);
-    expect(boundedLevenshtein("abc", "xyzuvw", 2)).toBe(3); // max+1
-  });
-});
-
-describe("suggestScopes", () => {
-  const known = ["recallnest", "recallnest:self", "cc", "cc:55bcbfb3", "project:test"];
-
-  it("matches typos within edit distance 2", () => {
-    expect(suggestScopes("recallnst", known)).toContain("recallnest");
-  });
-
-  it("matches case differences via normalization", () => {
-    expect(suggestScopes("RecallNest", known)[0]).toBe("recallnest");
-  });
-
-  it("matches separator convention drift", () => {
-    expect(suggestScopes("recall-nest", known)[0]).toBe("recallnest");
-    expect(suggestScopes("recall_nest", known)[0]).toBe("recallnest");
-  });
-
-  it("matches by prefix in both directions", () => {
-    expect(suggestScopes("recall", known)).toContain("recallnest");
-  });
-
-  it("returns empty for unrelated input", () => {
-    expect(suggestScopes("totally-unrelated-thing", known)).toEqual([]);
-    expect(suggestScopes("", known)).toEqual([]);
-  });
-
-  it("caps suggestions at maxSuggestions", () => {
-    const many = ["aa1", "aa2", "aa3", "aa4", "aa5"];
-    expect(suggestScopes("aa", many, 3)).toHaveLength(3);
-  });
-});
-
-describe("createScopeSuggester", () => {
-  it("derives prefix families and caches scope counts", async () => {
-    let calls = 0;
-    const suggest = createScopeSuggester(async () => {
-      calls++;
-      return { "cc:55bcbfb3": 100, "cc:65314581": 50, "codex:019cc122": 30 };
-    });
-
-    // 拼错的 prefix 应命中 prefix 家族(cc),不需要整串 session scope 相似
-    const r1 = await suggest("ccc");
-    expect(r1).toContain("cc");
-
-    await suggest("codx");
-    expect(calls).toBe(1); // 60s TTL 内复用缓存
-  });
-});
-
-describe("formatScopeSuggestion", () => {
-  it("renders hint or empty string", () => {
-    expect(formatScopeSuggestion("recallnst", ["recallnest"])).toContain("recallnest");
-    expect(formatScopeSuggestion("x", [])).toBe("");
-  });
-});

package/src/__tests__/session-checkpoint.test.ts

@@ -1,291 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdtempSync, readdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { buildSessionCheckpointRecord, buildSessionCheckpointResult, normalizeCheckpointScope, resolveCheckpointScope, type CheckpointQuality } from "../session-engine.js";
-import { formatCheckpointRecallSummary, formatCheckpointSaved, formatCheckpointSummary, formatResumeContext } from "../session-output.js";
-import { SessionCheckpointStore } from "../session-store.js";
-
-describe("session checkpoint engine", () => {
-  it("defaults checkpoint scope to session:<sessionId>", () => {
-    const record = buildSessionCheckpointRecord({
-      sessionId: "session-abc",
-      summary: "Implement checkpoint storage",
-    });
-
-    expect(resolveCheckpointScope(record)).toBe("session:session-abc");
-    expect(record.resolvedScope).toBe("session:session-abc");
-  });
-});
-
-describe("SessionCheckpointStore", () => {
-  it("saves and retrieves latest checkpoints by scope and session", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "recallnest-checkpoints-"));
-    try {
-      const store = new SessionCheckpointStore(dir);
-
-      const first = await store.save(buildSessionCheckpointRecord({
-        sessionId: "session-1",
-        scope: "agent:codex",
-        summary: "First checkpoint",
-        nextActions: ["Implement checkpoint_session"],
-        updatedAt: "2026-03-16T03:00:00.000Z",
-      }));
-
-      const second = await store.save(buildSessionCheckpointRecord({
-        sessionId: "session-2",
-        scope: "agent:codex",
-        summary: "Second checkpoint",
-        updatedAt: "2026-03-16T03:05:00.000Z",
-      }));
-
-      const latestByScope = await store.getLatest({ scope: "agent:codex" });
-      const latestBySession = await store.getLatest({ sessionId: "session-1" });
-
-      expect(latestByScope?.checkpointId).toBe(second.checkpointId);
-      expect(latestBySession?.checkpointId).toBe(first.checkpointId);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("uses idempotencyKey to replace retried checkpoint files", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "recallnest-checkpoint-idempotency-"));
-    try {
-      const store = new SessionCheckpointStore(dir);
-      const baseInput = {
-        sessionId: "session-retry",
-        scope: "project:recallnest",
-        summary: "Save retry-safe checkpoint state.",
-        decisions: ["Use explicit idempotency keys for client retries"],
-        idempotencyKey: "checkpoint-request-123",
-      };
-
-      const first = await store.save(buildSessionCheckpointRecord({
-        ...baseInput,
-        updatedAt: "2026-06-26T01:00:00.000Z",
-      }));
-      const retried = await store.save(buildSessionCheckpointRecord({
-        ...baseInput,
-        updatedAt: "2026-06-26T01:01:00.000Z",
-      }));
-
-      expect(retried.checkpointId).toBe(first.checkpointId);
-      expect(readdirSync(dir).filter((name) => name.endsWith(".json"))).toHaveLength(1);
-
-      const recent = await store.listRecent({ sessionId: "session-retry", limit: 10 });
-      expect(recent).toHaveLength(1);
-      expect(recent[0]?.updatedAt).toBe("2026-06-26T01:01:00.000Z");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("session checkpoint output", () => {
-  it("formats saved and summary views", () => {
-    const record = buildSessionCheckpointRecord({
-      sessionId: "session-xyz",
-      summary: "Current task is implementing session checkpoints",
-      decisions: ["Keep checkpoints out of LanceDB"],
-      openLoops: ["Need resume_context next"],
-      nextActions: ["Add latest checkpoint API"],
-    });
-
-    expect(formatCheckpointSaved(record)).toContain("Keep checkpoints out of LanceDB");
-    expect(formatCheckpointSummary(record)).toContain("Latest checkpoint");
-    expect(formatCheckpointSummary(null)).toBe("No checkpoint found.");
-  });
-
-  it("enriches recall checkpoint summaries with missing entity hints only once", () => {
-    const record = buildSessionCheckpointRecord({
-      sessionId: "session-entity-hints",
-      summary: "Raised continuity coverage for RecallNest startup recovery.",
-      entities: ["RecallNest", "smoke:claude-continuity", "resume_context"],
-    });
-
-    expect(formatCheckpointRecallSummary(record)).toBe(
-      "Raised continuity coverage for RecallNest startup recovery. Entities: smoke:claude-continuity, resume_context",
-    );
-  });
-
-  it("includes recall-only guidance in formatted resume context output", () => {
-    const output = formatResumeContext({
-      summary: "Stable context: Preference: 用户不喜欢 AI 味太重的文案语气。",
-      resolvedScope: "project:writing",
-      stableContext: ["Preference: 用户不喜欢 AI 味太重的文案语气。"],
-      relevantPatterns: [],
-      recentCases: [],
-      latestCheckpoint: {
-        sessionId: "session-writing",
-        resolvedScope: "project:writing",
-        summary: "Continue writing-style preference recovery.",
-        updatedAt: "2026-03-16T04:30:00.000Z",
-      },
-      responseMode: "recall-only",
-      responseGuidance: "Recall-only mode: answer from the recalled stable context item only.",
-      generatedAt: "2026-03-16T04:40:00.000Z",
-    });
-
-    expect(output).toContain("Scope: project:writing");
-    expect(output).toContain("Response mode: recall-only");
-    expect(output).toContain("Guidance: Recall-only mode");
-    expect(output).toContain("Stable context:");
-  });
-
-  it("sanitizes repo-state text out of checkpoint content", () => {
-    const result = buildSessionCheckpointResult({
-      sessionId: "session-repo-state",
-      summary: "Only resumed context in this window. git status shows many modified files.",
-      task: "Handle git status follow-up",
-      decisions: ["Keep repo-state out of checkpoints."],
-      openLoops: ["git status shows many uncommitted changes that still need review"],
-      nextActions: ["Process modified files after checking git status locally"],
-    });
-    const { record } = result;
-
-    expect(record.summary).toBe("Checkpoint captured current task state without repo-state details.");
-    expect(record.task).toBeUndefined();
-    expect(record.decisions).toEqual(["Keep repo-state out of checkpoints."]);
-    expect(record.openLoops).toEqual(["Current repo state still needs local verification if it matters for the next task."]);
-    expect(record.nextActions).toEqual(["Verify current repo state locally if it matters for the next task."]);
-    expect(result.sanitization.changed).toBe(true);
-    expect(result.sanitization.changedFields).toEqual(["summary", "task", "openLoops", "nextActions"]);
-  });
-
-  it("does not mark sanitization when checkpoint content is already clean", () => {
-    const result = buildSessionCheckpointResult({
-      sessionId: "session-clean",
-      summary: "Continue wiring workflow observations into managed continuity.",
-      task: "Hook managed continuity observations",
-      decisions: ["Keep observations out of durable memory."],
-      openLoops: ["Need to update the managed snippets."],
-      nextActions: ["Add MCP and HTTP auto-observation coverage."],
-    });
-
-    expect(result.sanitization.changed).toBe(false);
-    expect(result.sanitization.changedFields).toEqual([]);
-  });
-});
-
-describe("checkpoint scope normalization", () => {
-  it("normalizes bare project names to project: prefix", () => {
-    expect(normalizeCheckpointScope("recallnest")).toBe("project:recallnest");
-    expect(normalizeCheckpointScope("RecallNest")).toBe("project:recallnest");
-    expect(normalizeCheckpointScope("telegram-bridge")).toBe("project:telegram-bridge");
-  });
-
-  it("preserves existing prefixes but lowercases", () => {
-    expect(normalizeCheckpointScope("project:RecallNest")).toBe("project:recallnest");
-    expect(normalizeCheckpointScope("session:abc")).toBe("session:abc");
-    expect(normalizeCheckpointScope("eval:continuity")).toBe("eval:continuity");
-  });
-
-  it("applies normalization at save time via resolveCheckpointScope", () => {
-    expect(resolveCheckpointScope({ sessionId: "s1", scope: "RecallNest" })).toBe("project:recallnest");
-    expect(resolveCheckpointScope({ sessionId: "s1", scope: "project:RecallNest" })).toBe("project:recallnest");
-    expect(resolveCheckpointScope({ sessionId: "s1" })).toBe("session:s1");
-  });
-
-  it("matches checkpoints across scope variants in getLatest", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "recallnest-scope-norm-"));
-    try {
-      const store = new SessionCheckpointStore(dir);
-
-      // Save with bare "recallnest" — will be normalized to "project:recallnest"
-      await store.save(buildSessionCheckpointRecord({
-        sessionId: "s-bare",
-        scope: "recallnest",
-        summary: "Bare scope checkpoint",
-      }));
-
-      // Save with "project:RecallNest" — will be normalized to "project:recallnest"
-      const later = buildSessionCheckpointRecord({
-        sessionId: "s-cased",
-        scope: "project:RecallNest",
-        summary: "Cased scope checkpoint",
-      });
-      // Manually set a later timestamp
-      (later as any).updatedAt = new Date(Date.now() + 1000).toISOString().replace(/\.\d+Z$/, ".000Z");
-      await store.save(later);
-
-      // Query with canonical "project:recallnest" should find both, return latest
-      const latest = await store.getLatest({ scope: "project:recallnest" });
-      expect(latest).not.toBeNull();
-      expect(latest!.summary).toBe("Cased scope checkpoint");
-
-      // Query with bare "recallnest" should also work
-      const latestBare = await store.getLatest({ scope: "recallnest" });
-      expect(latestBare).not.toBeNull();
-      expect(latestBare!.summary).toBe("Cased scope checkpoint");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("checkpoint quality gate", () => {
-  it("classifies checkpoints with fallback summary and empty fields as minimal", () => {
-    const result = buildSessionCheckpointResult({
-      sessionId: "s-empty",
-      scope: "project:recallnest",
-      summary: "git status shows 5 modified files and 3 untracked files",
-    });
-    // Summary was sanitized to fallback, no decisions/openLoops/nextActions
-    expect(result.quality).toBe("minimal");
-    expect(result.sanitization.changed).toBe(true);
-  });
-
-  it("classifies checkpoints with real content as rich", () => {
-    const result = buildSessionCheckpointResult({
-      sessionId: "s-rich",
-      scope: "project:recallnest",
-      summary: "Completed scope normalization and checkpoint quality gate.",
-      decisions: ["Normalize scope at save and query time"],
-    });
-    expect(result.quality).toBe("rich");
-  });
-
-  it("classifies checkpoints with fallback summary but structured fields as rich", () => {
-    const result = buildSessionCheckpointResult({
-      sessionId: "s-mixed",
-      scope: "project:recallnest",
-      summary: "git status shows dirty worktree",
-      decisions: ["Keep using bun for builds"],
-    });
-    // Summary sanitized to fallback but decisions non-empty → still rich
-    expect(result.quality).toBe("rich");
-  });
-
-  it("prefers rich checkpoints over minimal ones in getLatest", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "recallnest-quality-gate-"));
-    try {
-      const store = new SessionCheckpointStore(dir);
-
-      // Save a rich checkpoint first (older)
-      await store.save(buildSessionCheckpointRecord({
-        sessionId: "s-rich",
-        scope: "project:recallnest",
-        summary: "Good checkpoint with real content.",
-        decisions: ["Keep checkpoints clean"],
-        updatedAt: "2026-03-22T01:00:00.000Z",
-      }));
-
-      // Save a minimal checkpoint later (newer) — all-sanitized fallback
-      await store.save(buildSessionCheckpointRecord({
-        sessionId: "s-minimal",
-        scope: "project:recallnest",
-        summary: "Checkpoint captured current task state without repo-state details.",
-        updatedAt: "2026-03-22T02:00:00.000Z",
-      }));
-
-      const latest = await store.getLatest({ scope: "project:recallnest" });
-      expect(latest).not.toBeNull();
-      // Should return the rich one even though it's older
-      expect(latest!.summary).toBe("Good checkpoint with real content.");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});