recallnest 2.2.0 → 2.2.1

package/src/__tests__/version-manager.test.ts

@@ -1,213 +0,0 @@
-/**
- * Tests for Tier 3.3: Version Coexistence + Competition
- *
- * Validates:
- * 1. computeVersionRank formula
- * 2. createVersionGroup tags both entries with same group
- * 3. deduplicateByVersionGroup keeps top-ranked per group
- * 4. Entries without version_group pass through unchanged
- * 5. Multiple version groups are handled independently
- * 6. Existing version_group is reused (not duplicated)
- */
-import { describe, expect, it } from "bun:test";
-import {
-  computeVersionRank,
-  deduplicateByVersionGroup,
-  createVersionGroup,
-} from "../version-manager.js";
-import type { MemoryEntry } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEntry(
-  id: string,
-  overrides: {
-    confidence?: number;
-    accessCount?: number;
-    version_group?: string;
-    version_rank?: number;
-  } = {},
-): MemoryEntry {
-  const meta: Record<string, unknown> = {
-    confidence: overrides.confidence ?? 0.7,
-    accessCount: overrides.accessCount ?? 0,
-  };
-  if (overrides.version_group) meta.version_group = overrides.version_group;
-  if (overrides.version_rank !== undefined) meta.version_rank = overrides.version_rank;
-
-  return {
-    id,
-    text: `memory-${id}`,
-    vector: [1, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: JSON.stringify(meta),
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]) {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  const updates: Array<{ id: string; metadata: string }> = [];
-
-  return {
-    data,
-    updates,
-    async getById(id: string) {
-      return data.get(id) ?? null;
-    },
-    async update(id: string, upd: { metadata?: string }, _scope?: string[]) {
-      const entry = data.get(id);
-      if (!entry) return null;
-      if (upd.metadata) {
-        entry.metadata = upd.metadata;
-        updates.push({ id, metadata: upd.metadata });
-      }
-      return entry;
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// computeVersionRank
-// ---------------------------------------------------------------------------
-
-describe("computeVersionRank", () => {
-  it("computes rank from importance, confidence, and accessCount", () => {
-    const entry = makeEntry("a", { confidence: 1.0, accessCount: 10 });
-    const rank = computeVersionRank(entry);
-    // quality = 0.5*0.7 + 0.5*1.0 = 0.85 (importance=0.7 from makeEntry)
-    // rank = 0.85 * (1 + ln(11)) ≈ 0.85 * 3.398 = 2.888
-    expect(rank).toBeGreaterThan(2.8);
-    expect(rank).toBeLessThan(3.0);
-  });
-
-  it("returns baseline for default confidence and zero access", () => {
-    const entry = makeEntry("b", { confidence: 0.7, accessCount: 0 });
-    const rank = computeVersionRank(entry);
-    // quality = 0.5*0.7 + 0.5*0.7 = 0.7
-    // rank = 0.7 * (1 + 0) = 0.7
-    expect(rank).toBeCloseTo(0.7, 5);
-  });
-
-  it("higher confidence wins over lower with same access", () => {
-    const high = computeVersionRank(makeEntry("h", { confidence: 1.0, accessCount: 5 }));
-    const low = computeVersionRank(makeEntry("l", { confidence: 0.3, accessCount: 5 }));
-    expect(high).toBeGreaterThan(low);
-  });
-
-  it("higher access wins over lower with same confidence", () => {
-    const frequent = computeVersionRank(makeEntry("f", { confidence: 0.7, accessCount: 20 }));
-    const rare = computeVersionRank(makeEntry("r", { confidence: 0.7, accessCount: 1 }));
-    expect(frequent).toBeGreaterThan(rare);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// createVersionGroup
-// ---------------------------------------------------------------------------
-
-describe("createVersionGroup", () => {
-  it("tags both entries with the same version_group", async () => {
-    const canonical = makeEntry("canon", { confidence: 1.0, accessCount: 5 });
-    const member = makeEntry("member", { confidence: 0.5, accessCount: 1 });
-    const store = createMockStore([canonical, member]);
-
-    const groupId = await createVersionGroup(store as any, canonical, member, "project:test");
-
-    expect(groupId).toBeTruthy();
-    expect(store.updates.length).toBe(2);
-
-    const canonMeta = JSON.parse(store.data.get("canon")!.metadata);
-    const memberMeta = JSON.parse(store.data.get("member")!.metadata);
-
-    expect(canonMeta.version_group).toBe(groupId);
-    expect(memberMeta.version_group).toBe(groupId);
-    expect(canonMeta.version_rank).toBeGreaterThan(memberMeta.version_rank);
-  });
-
-  it("reuses existing version_group from canonical", async () => {
-    const canonical = makeEntry("canon", {
-      confidence: 1.0,
-      accessCount: 5,
-      version_group: "vg-existing",
-      version_rank: 3.0,
-    });
-    const member = makeEntry("new", { confidence: 0.5, accessCount: 0 });
-    const store = createMockStore([canonical, member]);
-
-    const groupId = await createVersionGroup(store as any, canonical, member, "project:test");
-
-    expect(groupId).toBe("vg-existing");
-    const memberMeta = JSON.parse(store.data.get("new")!.metadata);
-    expect(memberMeta.version_group).toBe("vg-existing");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// deduplicateByVersionGroup
-// ---------------------------------------------------------------------------
-
-describe("deduplicateByVersionGroup", () => {
-  it("keeps only the top-ranked entry per version group", () => {
-    const results = [
-      { entry: makeEntry("a", { version_group: "vg1", version_rank: 3.0 }), score: 0.9, sources: {} },
-      { entry: makeEntry("b", { version_group: "vg1", version_rank: 1.0 }), score: 0.85, sources: {} },
-      { entry: makeEntry("c"), score: 0.8, sources: {} },
-    ];
-
-    const deduped = deduplicateByVersionGroup(results);
-
-    expect(deduped.length).toBe(2);
-    expect(deduped.map(r => r.entry.id)).toContain("a");
-    expect(deduped.map(r => r.entry.id)).toContain("c");
-    expect(deduped.map(r => r.entry.id)).not.toContain("b");
-  });
-
-  it("passes through entries without version_group", () => {
-    const results = [
-      { entry: makeEntry("x"), score: 0.9, sources: {} },
-      { entry: makeEntry("y"), score: 0.8, sources: {} },
-    ];
-
-    const deduped = deduplicateByVersionGroup(results);
-
-    expect(deduped.length).toBe(2);
-  });
-
-  it("handles multiple independent version groups", () => {
-    const results = [
-      { entry: makeEntry("a1", { version_group: "vg1", version_rank: 3.0 }), score: 0.95, sources: {} },
-      { entry: makeEntry("a2", { version_group: "vg1", version_rank: 1.0 }), score: 0.90, sources: {} },
-      { entry: makeEntry("b1", { version_group: "vg2", version_rank: 2.0 }), score: 0.85, sources: {} },
-      { entry: makeEntry("b2", { version_group: "vg2", version_rank: 4.0 }), score: 0.80, sources: {} },
-      { entry: makeEntry("solo"), score: 0.75, sources: {} },
-    ];
-
-    const deduped = deduplicateByVersionGroup(results);
-
-    expect(deduped.length).toBe(3);
-    const ids = deduped.map(r => r.entry.id);
-    expect(ids).toContain("a1"); // vg1 winner (rank 3.0)
-    expect(ids).toContain("b2"); // vg2 winner (rank 4.0)
-    expect(ids).toContain("solo");
-  });
-
-  it("handles empty array", () => {
-    expect(deduplicateByVersionGroup([])).toEqual([]);
-  });
-
-  it("handles single entry in a version group", () => {
-    const results = [
-      { entry: makeEntry("only", { version_group: "vg1", version_rank: 2.0 }), score: 0.9, sources: {} },
-    ];
-
-    const deduped = deduplicateByVersionGroup(results);
-
-    expect(deduped.length).toBe(1);
-    expect(deduped[0].entry.id).toBe("only");
-  });
-});

package/src/__tests__/workflow-observation.test.ts

@@ -1,400 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  applyWorkflowObservationScopeSuggestions,
-  formatWorkflowObservationScopeReview,
-  keepWorkflowObservationScopesGlobal,
-  parseWorkflowObservationScopeCue,
-  reviewWorkflowObservationScopes,
-} from "../workflow-observation-scope-review.js";
-import {
-  buildWorkflowEvidence,
-  buildWorkflowHealthDashboard,
-  buildWorkflowObservationRecord,
-  inspectWorkflowHealth,
-  resolveWorkflowObservationScope,
-} from "../workflow-observation-engine.js";
-import { collectScopeInventory } from "../scope-inventory.js";
-import { buildSessionCheckpointResult } from "../session-engine.js";
-import { MemoryStore } from "../store.js";
-import { buildManagedCheckpointObservation, buildManagedResumeObservation } from "../workflow-observation-managed.js";
-import { WorkflowObservationStore } from "../workflow-observation-store.js";
-
-describe("workflow observation engine", () => {
-  it("defaults observation scope to global", () => {
-    const record = buildWorkflowObservationRecord({
-      workflowId: "resume_context",
-      outcome: "missed",
-      summary: "Fresh window skipped resume_context before repo exploration.",
-    });
-
-    expect(resolveWorkflowObservationScope(record)).toBe("global");
-    expect(record.resolvedScope).toBe("global");
-  });
-
-  it("aggregates workflow health and evidence from append-only observations", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "recallnest-workflow-observations-"));
-    try {
-      const store = new WorkflowObservationStore(dir);
-      const records = [
-        {
-          workflowId: "resume_context",
-          scope: "project:recallnest",
-          outcome: "missed",
-          summary: "Fresh window explored the repo before continuity recovery.",
-          signal: "missed-startup-trigger",
-          source: "smoke",
-          recordedAt: "2026-03-15T03:00:00.000Z",
-        },
-        {
-          workflowId: "resume_context",
-          scope: "project:recallnest",
-          outcome: "corrected",
-          summary: "User had to remind the agent to recover continuity first.",
-          signal: "user-correction",
-          source: "agent",
-          recordedAt: "2026-03-16T03:00:00.000Z",
-        },
-        {
-          workflowId: "resume_context",
-          scope: "project:recallnest",
-          outcome: "success",
-          summary: "Fresh window recovered RecallNest continuity before coding.",
-          signal: "startup-recovered",
-          source: "smoke",
-          recordedAt: "2026-03-17T03:00:00.000Z",
-        },
-        {
-          workflowId: "checkpoint_session",
-          scope: "project:recallnest",
-          outcome: "failure",
-          summary: "Checkpoint still carried repo-state text before the product-side guard landed.",
-          signal: "repo-state-contamination",
-          source: "smoke",
-          recordedAt: "2026-03-17T04:00:00.000Z",
-        },
-      ];
-
-      for (const record of records) {
-        await store.save(buildWorkflowObservationRecord(record));
-      }
-
-      const health = await inspectWorkflowHealth(store, {
-        workflowId: "resume_context",
-        scope: "project:recallnest",
-        now: new Date("2026-03-17T12:00:00.000Z"),
-      });
-      expect(health.status).toBe("watch");
-      expect(health.windows[1]?.total).toBe(3);
-      expect(health.windows[1]?.missed).toBe(1);
-      expect(health.windows[1]?.corrected).toBe(1);
-      expect(health.windows[1]?.successRate).toBeCloseTo(1 / 3, 5);
-
-      const dashboard = buildWorkflowHealthDashboard(
-        await store.listRecent({ scope: "project:recallnest", limit: 50 }),
-        { scope: "project:recallnest" },
-      );
-      expect(dashboard[0]?.workflowId).toBe("checkpoint_session");
-      expect(dashboard[0]?.status).toBe("critical");
-
-      const evidence = await buildWorkflowEvidence(store, {
-        workflowId: "checkpoint_session",
-        scope: "project:recallnest",
-        now: new Date("2026-03-17T12:00:00.000Z"),
-      });
-      expect(evidence.topSignals[0]?.signal).toBe("repo-state-contamination");
-      expect(evidence.suggestions).toContain(
-        "Keep volatile repo-state text out of saved checkpoints and handoff summaries unless this window verified it.",
-      );
-      expect(evidence.suggestions).toContain(
-        "Add end-of-window guards so checkpoint content is sanitized before it becomes the next handoff.",
-      );
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("builds managed continuity observations without routing them into regular memory", () => {
-    const resumeObservation = buildManagedResumeObservation({
-      sessionId: "session-123",
-      task: "Continue RecallNest continuity work",
-    }, {
-      stableContext: ["Entity: RecallNest continuity revolves around three primitives."],
-      relevantPatterns: ["Call resume_context before coding."],
-      recentCases: ["Case: RecallNest sparse startup context cleanup"],
-      latestCheckpoint: {
-        sessionId: "session-123",
-        summary: "Checkpoint summary",
-        updatedAt: "2026-03-17T11:00:00.000Z",
-      },
-      responseMode: "default",
-    });
-
-    expect(resumeObservation.workflowId).toBe("resume_context");
-    expect(resumeObservation.outcome).toBe("success");
-    expect(resumeObservation.scope).toBe("session:session-123");
-    expect(resumeObservation.source).toBe("managed");
-    expect(resumeObservation.signal).toBe("managed-resume-resolved");
-    expect(resumeObservation.tags).toContain("managed");
-    expect(resumeObservation.tools).toEqual(["resume_context"]);
-
-    const checkpointObservation = buildManagedCheckpointObservation(buildSessionCheckpointResult({
-      sessionId: "session-123",
-      scope: "project:recallnest",
-      summary: "Only resumed context here. git status shows modified files.",
-      openLoops: ["git status still needs review"],
-    }));
-
-    expect(checkpointObservation.workflowId).toBe("checkpoint_session");
-    expect(checkpointObservation.outcome).toBe("corrected");
-    expect(checkpointObservation.scope).toBe("project:recallnest");
-    expect(checkpointObservation.source).toBe("managed");
-    expect(checkpointObservation.signal).toBe("repo-state-sanitized");
-    expect(checkpointObservation.summary).toContain("summary and openLoops");
-    expect(checkpointObservation.tools).toEqual(["checkpoint_session"]);
-  });
-
-  it("uses resolved scope fallback for managed resume observations when request scope is absent", () => {
-    const observation = buildManagedResumeObservation({
-      task: "Continue RecallNest scope cleanup",
-    }, {
-      resolvedScope: "project:recallnest",
-      stableContext: ["Entity: RecallNest continuity revolves around three primitives."],
-      relevantPatterns: [],
-      recentCases: [],
-      latestCheckpoint: {
-        sessionId: "session-xyz",
-        resolvedScope: "project:recallnest",
-        summary: "Checkpoint summary",
-        updatedAt: "2026-03-18T00:00:00.000Z",
-      },
-      responseMode: "default",
-    });
-
-    expect(observation.scope).toBe("project:recallnest");
-  });
-
-  it("reviews and applies cue-based scope suggestions for legacy global workflow observations", () => {
-    const dir = mkdtempSync(join(tmpdir(), "recallnest-workflow-scope-review-"));
-    try {
-      const recallnestPath = join(dir, "recallnest.json");
-      const externalPath = join(dir, "external.json");
-      writeFileSync(recallnestPath, JSON.stringify({
-        workflowId: "resume_context",
-        summary: "Managed resume_context recovered 1 stable item(s), 1 pattern(s), and 1 case(s).",
-        source: "managed",
-        task: "Continue RecallNest scope cleanup",
-        recordedAt: "2026-03-18T00:00:00.000Z",
-        observationId: "obs-recallnest",
-        resolvedScope: "global",
-      }, null, 2) + "\n");
-      writeFileSync(externalPath, JSON.stringify({
-        workflowId: "resume_context",
-        summary: "Managed resume_context recovered 1 stable item(s), 0 pattern(s), and 0 case(s).",
-        source: "managed",
-        task: "A2A code Claude SDK calling error",
-        recordedAt: "2026-03-18T00:01:00.000Z",
-        observationId: "obs-external",
-        resolvedScope: "global",
-      }, null, 2) + "\n");
-
-      const review = reviewWorkflowObservationScopes({
-        dir,
-        currentScope: "global",
-        source: "managed",
-        workflowId: "resume_context",
-        cues: [parseWorkflowObservationScopeCue("recallnest=project:recallnest")],
-      });
-
-      expect(review.totalCount).toBe(2);
-      expect(review.suggestedCount).toBe(1);
-      expect(review.manualReviewCount).toBe(1);
-      expect(review.entries[0]?.suggestedScope).toBeUndefined();
-      expect(review.entries[1]?.suggestedScope).toBe("project:recallnest");
-      expect(formatWorkflowObservationScopeReview(review)).toContain("project:recallnest");
-
-      const result = applyWorkflowObservationScopeSuggestions(review);
-      expect(result.updatedCount).toBe(1);
-      expect(result.skippedCount).toBe(1);
-
-      const rewritten = JSON.parse(readFileSync(recallnestPath, "utf-8"));
-      const untouched = JSON.parse(readFileSync(externalPath, "utf-8"));
-      expect(rewritten.scope).toBe("project:recallnest");
-      expect(rewritten.resolvedScope).toBe("project:recallnest");
-      expect(untouched.resolvedScope).toBe("global");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("can infer a scope from a nearby managed observation when cues are absent", () => {
-    const dir = mkdtempSync(join(tmpdir(), "recallnest-workflow-scope-neighbor-"));
-    try {
-      const globalPath = join(dir, "global.json");
-      const neighborPath = join(dir, "neighbor.json");
-      writeFileSync(globalPath, JSON.stringify({
-        workflowId: "resume_context",
-        summary: "Managed resume_context recovered 2 stable item(s), 1 pattern(s), and 0 case(s).",
-        source: "managed",
-        recordedAt: "2026-03-18T00:00:00.000Z",
-        observationId: "obs-global",
-        resolvedScope: "global",
-      }, null, 2) + "\n");
-      writeFileSync(neighborPath, JSON.stringify({
-        workflowId: "checkpoint_session",
-        summary: "Managed checkpoint_session sanitized repo-state text out of summary before saving the handoff.",
-        source: "managed",
-        recordedAt: "2026-03-18T00:00:40.000Z",
-        observationId: "obs-neighbor",
-        resolvedScope: "session:recallnest-2026-03-18",
-      }, null, 2) + "\n");
-
-      const review = reviewWorkflowObservationScopes({
-        dir,
-        currentScope: "global",
-        source: "managed",
-        workflowId: "resume_context",
-        neighborWindowSeconds: 90,
-      });
-
-      expect(review.totalCount).toBe(1);
-      expect(review.suggestedCount).toBe(1);
-      expect(review.entries[0]?.suggestedScope).toBe("session:recallnest-2026-03-18");
-      expect(review.entries[0]?.reason).toContain("matched nearby checkpoint_session");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("can mark manual-review legacy global observations as reviewed keep-global", () => {
-    const dir = mkdtempSync(join(tmpdir(), "recallnest-workflow-scope-keep-global-"));
-    try {
-      const externalPath = join(dir, "external.json");
-      writeFileSync(externalPath, JSON.stringify({
-        workflowId: "resume_context",
-        summary: "Managed resume_context recovered 1 stable item(s), 0 pattern(s), and 0 case(s).",
-        source: "managed",
-        task: "A2A code Claude SDK calling error",
-        recordedAt: "2026-03-18T00:01:00.000Z",
-        observationId: "obs-external",
-        resolvedScope: "global",
-      }, null, 2) + "\n");
-
-      const review = reviewWorkflowObservationScopes({
-        dir,
-        currentScope: "global",
-        source: "managed",
-        workflowId: "resume_context",
-      });
-      expect(review.totalCount).toBe(1);
-      expect(review.manualReviewCount).toBe(1);
-
-      const result = keepWorkflowObservationScopesGlobal(review, {
-        ids: ["obs-external"],
-        reason: "external-task",
-        reviewedAt: "2026-03-18T00:05:00.000Z",
-      });
-      expect(result.reviewedCount).toBe(1);
-      expect(result.skippedCount).toBe(0);
-      expect(result.unmatchedIds).toEqual([]);
-      expect(result.ambiguousIds).toEqual([]);
-
-      const rewritten = JSON.parse(readFileSync(externalPath, "utf-8"));
-      expect(rewritten.legacyScopeReview).toEqual({
-        decision: "keep",
-        kind: "global",
-        reason: "external-task",
-        reviewedAt: "2026-03-18T00:05:00.000Z",
-      });
-
-      const nextReview = reviewWorkflowObservationScopes({
-        dir,
-        currentScope: "global",
-        source: "managed",
-        workflowId: "resume_context",
-      });
-      expect(nextReview.totalCount).toBe(0);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("keeps mixed rewrite and keep-global review flows converged on a clean second pass", async () => {
-    const root = mkdtempSync(join(tmpdir(), "recallnest-workflow-scope-mixed-"));
-    try {
-      const workflowDir = join(root, "workflow-observations");
-      mkdirSync(workflowDir, { recursive: true });
-      const recallnestPath = join(workflowDir, "recallnest.json");
-      const externalPath = join(workflowDir, "external.json");
-      writeFileSync(recallnestPath, JSON.stringify({
-        workflowId: "resume_context",
-        summary: "Managed resume_context recovered 1 stable item(s), 1 pattern(s), and 1 case(s).",
-        source: "managed",
-        task: "Continue RecallNest scope cleanup",
-        recordedAt: "2026-03-18T00:00:00.000Z",
-        observationId: "obs-recallnest",
-        resolvedScope: "global",
-      }, null, 2) + "\n");
-      writeFileSync(externalPath, JSON.stringify({
-        workflowId: "resume_context",
-        summary: "Managed resume_context recovered 1 stable item(s), 0 pattern(s), and 0 case(s).",
-        source: "managed",
-        task: "A2A code Claude SDK calling error",
-        recordedAt: "2026-03-18T00:01:00.000Z",
-        observationId: "obs-external",
-        resolvedScope: "global",
-      }, null, 2) + "\n");
-
-      const review = reviewWorkflowObservationScopes({
-        dir: workflowDir,
-        currentScope: "global",
-        source: "managed",
-        workflowId: "resume_context",
-        cues: [parseWorkflowObservationScopeCue("recallnest=project:recallnest")],
-      });
-      expect(review.totalCount).toBe(2);
-      expect(review.suggestedCount).toBe(1);
-      expect(review.manualReviewCount).toBe(1);
-
-      const keepResult = keepWorkflowObservationScopesGlobal(review, {
-        ids: ["obs-external"],
-        reason: "external-task",
-        reviewedAt: "2026-03-18T00:05:00.000Z",
-      });
-      const rewriteResult = applyWorkflowObservationScopeSuggestions(review);
-      expect(keepResult.reviewedCount).toBe(1);
-      expect(rewriteResult.updatedCount).toBe(1);
-
-      const nextReview = reviewWorkflowObservationScopes({
-        dir: workflowDir,
-        currentScope: "global",
-        source: "managed",
-        workflowId: "resume_context",
-        cues: [parseWorkflowObservationScopeCue("recallnest=project:recallnest")],
-      });
-      expect(nextReview.totalCount).toBe(0);
-
-      const store = new MemoryStore({
-        dbPath: join(root, "db"),
-        vectorDim: 3,
-      });
-      const inventory = await collectScopeInventory({
-        store,
-        sampleLimit: 5,
-        workflowObservationsDir: workflowDir,
-        pinsDir: join(root, "pins"),
-        checkpointsDir: join(root, "checkpoints"),
-      });
-      const workflowLayer = inventory.layers.find((layer) => layer.layer === "workflow-observations");
-      expect(inventory.totalAnomalyCount).toBe(0);
-      expect(inventory.totalReviewedCount).toBe(1);
-      expect(workflowLayer?.anomalyCount).toBe(0);
-      expect(workflowLayer?.reviewedCount).toBe(1);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});