@vellumai/assistant 0.5.16 → 0.6.1

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

@@ -1,91 +1,7 @@
-import { rmSync } from "node:fs";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { eq } from "drizzle-orm";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../memory/qdrant-client.js", () => ({
-  getQdrantClient: () => ({
-    searchWithFilter: async () => [],
-    hybridSearch: async () => [],
-    upsertPoints: async () => {},
-    deletePoints: async () => {},
-  }),
-  initQdrantClient: () => {},
-}));
-
-// Controllable mock for loadSkillCatalog used by seedCatalogSkillMemories
-let mockLoadSkillCatalog: () => import("../config/skills.js").SkillSummary[] =
-  () => [];
-
-mock.module("../config/skills.js", () => ({
-  loadSkillCatalog: (..._args: unknown[]) => mockLoadSkillCatalog(),
-}));
-
-// Controllable mock for isAssistantFeatureFlagEnabled used by resolveSkillStates
-let mockIsFeatureFlagEnabled: (key: string) => boolean = () => true;
-
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string, _config: unknown) =>
-    mockIsFeatureFlagEnabled(key),
-  getAssistantFeatureFlagDefaults: () => ({}),
-}));
-
-import { DEFAULT_CONFIG } from "../config/defaults.js";
-
-const TEST_CONFIG = {
-  ...DEFAULT_CONFIG,
-  memory: {
-    ...DEFAULT_CONFIG.memory,
-    enabled: true,
-    extraction: {
-      ...DEFAULT_CONFIG.memory.extraction,
-      useLLM: false,
-    },
-  },
-};
-
-mock.module("../config/loader.js", () => ({
-  loadConfig: () => TEST_CONFIG,
-  getConfig: () => TEST_CONFIG,
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-}));
+import { describe, expect, test } from "bun:test";
 
 import type { SkillSummary } from "../config/skills.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import { memoryItems, memoryJobs } from "../memory/schema.js";
-import {
-  buildCapabilityStatement,
-  deleteSkillCapabilityMemory,
-  fromSkillSummary,
-  seedCatalogSkillMemories,
-  type SkillCapabilityInput,
-  upsertSkillCapabilityMemory,
-} from "../skills/skill-memory.js";
-import { ensureDataDir, getDbPath } from "../util/platform.js";
-
-ensureDataDir();
-initializeDb();
-
-afterAll(() => {
-  resetDb();
-});
-
-function resetTables() {
-  const db = getDb();
-  db.run("DELETE FROM memory_item_sources");
-  db.run("DELETE FROM memory_embeddings");
-  db.run("DELETE FROM memory_items");
-  db.run("DELETE FROM memory_jobs");
-}
+import { fromSkillSummary } from "../skills/skill-memory.js";
 
 function makeSkillSummary(
   overrides: Partial<SkillSummary> = {},
@@ -102,84 +18,6 @@ function makeSkillSummary(
   };
 }
 
-// ─── buildCapabilityStatement ────────────────────────────────────────────────
-
-describe("buildCapabilityStatement", () => {
-  test("includes display name, id, and description", () => {
-    const input: SkillCapabilityInput = {
-      id: "test-skill",
-      displayName: "My Skill",
-      description: "A skill for testing",
-    };
-    const result = buildCapabilityStatement(input);
-    expect(result).toContain('"My Skill"');
-    expect(result).toContain("(test-skill)");
-    expect(result).toContain("A skill for testing");
-  });
-
-  test("includes activation hints when present", () => {
-    const input: SkillCapabilityInput = {
-      id: "test-skill",
-      displayName: "My Skill",
-      description: "A skill for testing",
-      activationHints: ["user asks to search", "needs web data"],
-    };
-    const result = buildCapabilityStatement(input);
-    expect(result).toContain("Use when:");
-    expect(result).toContain("user asks to search");
-    expect(result).toContain("needs web data");
-  });
-
-  test("includes avoidWhen routing cues when present", () => {
-    const input: SkillCapabilityInput = {
-      id: "test-skill",
-      displayName: "My Skill",
-      description: "A skill for testing",
-      avoidWhen: ["user wants local files only", "offline mode"],
-    };
-    const result = buildCapabilityStatement(input);
-    expect(result).toContain("Avoid when:");
-    expect(result).toContain("user wants local files only");
-    expect(result).toContain("offline mode");
-  });
-
-  test("includes both activationHints and avoidWhen when present", () => {
-    const input: SkillCapabilityInput = {
-      id: "test-skill",
-      displayName: "My Skill",
-      description: "A skill for testing",
-      activationHints: ["user asks to search"],
-      avoidWhen: ["offline mode"],
-    };
-    const result = buildCapabilityStatement(input);
-    expect(result).toContain("Use when: user asks to search.");
-    expect(result).toContain("Avoid when: offline mode.");
-  });
-
-  test("works with just name as displayName", () => {
-    const input: SkillCapabilityInput = {
-      id: "test-skill",
-      displayName: "Test Skill",
-      description: "A skill for testing",
-    };
-    const result = buildCapabilityStatement(input);
-    expect(result).toContain('"Test Skill"');
-    expect(result).toContain("(test-skill)");
-    expect(result).toContain("A skill for testing");
-  });
-
-  test("truncates long statements to 500 chars", () => {
-    const longDesc = "x".repeat(600);
-    const input: SkillCapabilityInput = {
-      id: "test-skill",
-      displayName: "Test Skill",
-      description: longDesc,
-    };
-    const result = buildCapabilityStatement(input);
-    expect(result.length).toBe(500);
-  });
-});
-
 // ─── fromSkillSummary ────────────────────────────────────────────────────────
 
 describe("fromSkillSummary", () => {
@@ -225,580 +63,3 @@ describe("fromSkillSummary", () => {
     expect(input.description).toBe("Does amazing things");
   });
 });
-
-// ─── upsertSkillCapabilityMemory ─────────────────────────────────────────────
-
-describe("upsertSkillCapabilityMemory", () => {
-  beforeEach(resetTables);
-
-  test("inserts with correct kind, subject, confidence, importance", () => {
-    const input = fromSkillSummary(makeSkillSummary());
-    upsertSkillCapabilityMemory("test-skill", input);
-
-    const db = getDb();
-    const items = db.select().from(memoryItems).all();
-    expect(items).toHaveLength(1);
-    expect(items[0].kind).toBe("capability");
-    expect(items[0].subject).toBe("skill:test-skill");
-    expect(items[0].confidence).toBe(1.0);
-    expect(items[0].importance).toBe(0.7);
-    expect(items[0].status).toBe("active");
-    expect(items[0].scopeId).toBe("default");
-
-    // Should also enqueue an embed_item job
-    const jobs = db.select().from(memoryJobs).all();
-    expect(jobs).toHaveLength(1);
-    expect(jobs[0].type).toBe("embed_item");
-  });
-
-  test("is idempotent (same entry only touches lastSeenAt)", () => {
-    const input = fromSkillSummary(makeSkillSummary());
-    upsertSkillCapabilityMemory("test-skill", input);
-
-    const db = getDb();
-    const before = db.select().from(memoryItems).all();
-    expect(before).toHaveLength(1);
-    const originalLastSeen = before[0].lastSeenAt;
-
-    // Upsert again
-    upsertSkillCapabilityMemory("test-skill", input);
-
-    const after = db.select().from(memoryItems).all();
-    expect(after).toHaveLength(1);
-    // Fingerprint should be the same, so only lastSeenAt changes
-    expect(after[0].fingerprint).toBe(before[0].fingerprint);
-    expect(after[0].lastSeenAt).toBeGreaterThanOrEqual(originalLastSeen);
-
-    // Should NOT enqueue a second embed job (only 1 from initial insert)
-    const jobs = db.select().from(memoryJobs).all();
-    expect(jobs).toHaveLength(1);
-  });
-
-  test("updates statement when description changes", () => {
-    const input = fromSkillSummary(
-      makeSkillSummary({ description: "Original description" }),
-    );
-    upsertSkillCapabilityMemory("test-skill", input);
-
-    const db = getDb();
-    const before = db.select().from(memoryItems).all();
-    expect(before).toHaveLength(1);
-    expect(before[0].statement).toContain("Original description");
-
-    // Change description
-    const updatedInput = fromSkillSummary(
-      makeSkillSummary({ description: "Updated description" }),
-    );
-    upsertSkillCapabilityMemory("test-skill", updatedInput);
-
-    const after = db.select().from(memoryItems).all();
-    expect(after).toHaveLength(1);
-    expect(after[0].statement).toContain("Updated description");
-    expect(after[0].fingerprint).not.toBe(before[0].fingerprint);
-
-    // Should enqueue a second embed job
-    const jobs = db.select().from(memoryJobs).all();
-    expect(jobs).toHaveLength(2);
-  });
-
-  test("reactivates soft-deleted items", () => {
-    const input = fromSkillSummary(makeSkillSummary());
-    upsertSkillCapabilityMemory("test-skill", input);
-
-    const db = getDb();
-    // Soft-delete the item
-    db.update(memoryItems)
-      .set({ status: "deleted" })
-      .where(eq(memoryItems.subject, "skill:test-skill"))
-      .run();
-
-    const deleted = db.select().from(memoryItems).all();
-    expect(deleted[0].status).toBe("deleted");
-
-    // Clear jobs from initial insert
-    db.run("DELETE FROM memory_jobs");
-
-    // Upsert again — should reactivate
-    upsertSkillCapabilityMemory("test-skill", input);
-
-    const reactivated = db.select().from(memoryItems).all();
-    expect(reactivated).toHaveLength(1);
-    expect(reactivated[0].status).toBe("active");
-
-    // Should enqueue embed job for reactivated item
-    const jobs = db.select().from(memoryJobs).all();
-    expect(jobs).toHaveLength(1);
-    expect(jobs[0].type).toBe("embed_item");
-  });
-
-  test("does not throw on DB error", () => {
-    // Close the DB connection to force errors, then reinitialize
-    resetDb();
-    // getDb() will create a new connection, but we can force a DB error by
-    // dropping the table it reads from. Use a fresh DB without initialization.
-    // Instead, verify the try/catch by closing and reopening:
-    // resetDb closes the connection; getDb lazily reconnects.
-    // We drop the memory_items table to force an error on the next query.
-    const db = getDb();
-    db.run("DROP TABLE IF EXISTS memory_items");
-
-    expect(() => {
-      upsertSkillCapabilityMemory(
-        "test-skill",
-        fromSkillSummary(makeSkillSummary()),
-      );
-    }).not.toThrow();
-
-    // Restore DB state for subsequent tests.
-    // Delete the entire DB so initializeDb recreates it from scratch — just
-    // resetting the connection leaves stale migration checkpoints that skip
-    // checkpoint-guarded ALTER TABLE migrations (e.g. source_type column).
-    resetDb();
-    const dbPath = getDbPath();
-    for (const ext of ["", "-wal", "-shm"]) {
-      rmSync(`${dbPath}${ext}`, { force: true });
-    }
-    initializeDb();
-  });
-});
-
-// ─── deleteSkillCapabilityMemory ─────────────────────────────────────────────
-
-describe("deleteSkillCapabilityMemory", () => {
-  beforeEach(resetTables);
-
-  test("soft-deletes matching item", () => {
-    const input = fromSkillSummary(makeSkillSummary());
-    upsertSkillCapabilityMemory("test-skill", input);
-
-    const db = getDb();
-    const before = db.select().from(memoryItems).all();
-    expect(before).toHaveLength(1);
-    expect(before[0].status).toBe("active");
-
-    deleteSkillCapabilityMemory("test-skill");
-
-    const after = db.select().from(memoryItems).all();
-    expect(after).toHaveLength(1);
-    expect(after[0].status).toBe("deleted");
-  });
-
-  test("is no-op for missing item", () => {
-    // Should not throw when no matching item exists
-    expect(() => {
-      deleteSkillCapabilityMemory("nonexistent-skill");
-    }).not.toThrow();
-
-    const db = getDb();
-    const items = db.select().from(memoryItems).all();
-    expect(items).toHaveLength(0);
-  });
-
-  test("does not throw on DB error", () => {
-    // Close and reopen DB, then drop the table to force a query error
-    resetDb();
-    const db = getDb();
-    db.run("DROP TABLE IF EXISTS memory_items");
-
-    expect(() => {
-      deleteSkillCapabilityMemory("test-skill");
-    }).not.toThrow();
-
-    // Restore DB state for subsequent tests (see upsert "does not throw" test
-    // for rationale on why we delete the DB file).
-    resetDb();
-    const dbPath = getDbPath();
-    for (const ext of ["", "-wal", "-shm"]) {
-      rmSync(`${dbPath}${ext}`, { force: true });
-    }
-    initializeDb();
-  });
-});
-
-// ─── seedCatalogSkillMemories ─────────────────────────────────────────────
-
-describe("seedCatalogSkillMemories", () => {
-  beforeEach(() => {
-    resetTables();
-    // Reset mocks to defaults
-    mockLoadSkillCatalog = () => [];
-    mockIsFeatureFlagEnabled = () => true;
-  });
-
-  test("upserts capability memories for all enabled skills", () => {
-    const skills: SkillSummary[] = [
-      makeSkillSummary({
-        id: "skill-a",
-        displayName: "Skill A",
-        description: "Does A",
-      }),
-      makeSkillSummary({
-        id: "skill-b",
-        displayName: "Skill B",
-        description: "Does B",
-      }),
-      makeSkillSummary({
-        id: "skill-c",
-        displayName: "Skill C",
-        description: "Does C",
-      }),
-    ];
-    mockLoadSkillCatalog = () => skills;
-
-    seedCatalogSkillMemories();
-
-    const db = getDb();
-    const items = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
-      .all();
-    expect(items).toHaveLength(3);
-
-    const subjects = items.map((i) => i.subject).sort();
-    expect(subjects).toEqual([
-      "skill:skill-a",
-      "skill:skill-b",
-      "skill:skill-c",
-    ]);
-
-    // All should be active
-    for (const item of items) {
-      expect(item.status).toBe("active");
-    }
-  });
-
-  test("includes bundled skills in seeded memories", () => {
-    const skills: SkillSummary[] = [
-      makeSkillSummary({
-        id: "managed-skill",
-        displayName: "Managed",
-        description: "A managed skill",
-        source: "managed",
-      }),
-      makeSkillSummary({
-        id: "bundled-skill",
-        displayName: "Bundled",
-        description: "A bundled skill",
-        source: "bundled",
-        bundled: true,
-      }),
-    ];
-    mockLoadSkillCatalog = () => skills;
-
-    seedCatalogSkillMemories();
-
-    const db = getDb();
-    const items = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
-      .all();
-    expect(items).toHaveLength(2);
-
-    const subjects = items.map((i) => i.subject).sort();
-    expect(subjects).toEqual(["skill:bundled-skill", "skill:managed-skill"]);
-
-    for (const item of items) {
-      expect(item.status).toBe("active");
-    }
-  });
-
-  test("excludes bundled skills filtered by allowBundled config", () => {
-    const skills: SkillSummary[] = [
-      makeSkillSummary({
-        id: "allowed-bundled",
-        displayName: "Allowed Bundled",
-        description: "This bundled skill is allowed",
-        source: "bundled",
-        bundled: true,
-      }),
-      makeSkillSummary({
-        id: "blocked-bundled",
-        displayName: "Blocked Bundled",
-        description: "This bundled skill is not in allowBundled",
-        source: "bundled",
-        bundled: true,
-      }),
-      makeSkillSummary({
-        id: "managed-skill",
-        displayName: "Managed",
-        description: "A managed skill",
-        source: "managed",
-      }),
-    ];
-    mockLoadSkillCatalog = () => skills;
-
-    // Override config to set allowBundled to only allow one bundled skill
-    const configWithAllowBundled = {
-      ...TEST_CONFIG,
-      skills: {
-        ...TEST_CONFIG.skills,
-        allowBundled: ["allowed-bundled"],
-      },
-    };
-    mock.module("../config/loader.js", () => ({
-      loadConfig: () => configWithAllowBundled,
-      getConfig: () => configWithAllowBundled,
-      loadRawConfig: () => ({}),
-      saveRawConfig: () => {},
-      invalidateConfigCache: () => {},
-    }));
-
-    seedCatalogSkillMemories();
-
-    const db = getDb();
-    const items = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
-      .all();
-
-    // Only allowed-bundled and managed-skill should be seeded
-    expect(items).toHaveLength(2);
-    const subjects = items.map((i) => i.subject).sort();
-    expect(subjects).toEqual(["skill:allowed-bundled", "skill:managed-skill"]);
-
-    // Restore default config mock
-    mock.module("../config/loader.js", () => ({
-      loadConfig: () => TEST_CONFIG,
-      getConfig: () => TEST_CONFIG,
-      loadRawConfig: () => ({}),
-      saveRawConfig: () => {},
-      invalidateConfigCache: () => {},
-    }));
-  });
-
-  test("prunes stale capabilities for skills no longer enabled", () => {
-    // First seed with three skills
-    const initialSkills: SkillSummary[] = [
-      makeSkillSummary({
-        id: "skill-a",
-        displayName: "Skill A",
-        description: "Does A",
-      }),
-      makeSkillSummary({
-        id: "skill-b",
-        displayName: "Skill B",
-        description: "Does B",
-      }),
-      makeSkillSummary({
-        id: "skill-c",
-        displayName: "Skill C",
-        description: "Does C",
-      }),
-    ];
-    mockLoadSkillCatalog = () => initialSkills;
-    seedCatalogSkillMemories();
-
-    const db = getDb();
-    const beforeItems = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
-      .all();
-    expect(beforeItems).toHaveLength(3);
-    expect(beforeItems.every((i) => i.status === "active")).toBe(true);
-
-    // Now seed with only skill-a — skill-b and skill-c should be pruned
-    mockLoadSkillCatalog = () => [
-      makeSkillSummary({
-        id: "skill-a",
-        displayName: "Skill A",
-        description: "Does A",
-      }),
-    ];
-    seedCatalogSkillMemories();
-
-    const afterItems = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
-      .all();
-    expect(afterItems).toHaveLength(3); // still 3 rows, but 2 are soft-deleted
-
-    const active = afterItems.filter((i) => i.status === "active");
-    const deleted = afterItems.filter((i) => i.status === "deleted");
-
-    expect(active).toHaveLength(1);
-    expect(active[0].subject).toBe("skill:skill-a");
-
-    expect(deleted).toHaveLength(2);
-    const deletedSubjects = deleted.map((i) => i.subject).sort();
-    expect(deletedSubjects).toEqual(["skill:skill-b", "skill:skill-c"]);
-  });
-
-  test("handles empty catalog without errors", () => {
-    // Pre-populate a skill so we can verify it gets pruned
-    upsertSkillCapabilityMemory(
-      "existing-skill",
-      fromSkillSummary(makeSkillSummary({ id: "existing-skill" })),
-    );
-
-    const db = getDb();
-    const beforeItems = db.select().from(memoryItems).all();
-    expect(beforeItems).toHaveLength(1);
-    expect(beforeItems[0].status).toBe("active");
-
-    // Seed with empty catalog
-    mockLoadSkillCatalog = () => [];
-    seedCatalogSkillMemories();
-
-    // The existing skill should be pruned (soft-deleted)
-    const afterItems = db.select().from(memoryItems).all();
-    expect(afterItems).toHaveLength(1);
-    expect(afterItems[0].status).toBe("deleted");
-  });
-
-  test("does not prune non-skill capability memories", () => {
-    // Pre-insert a non-skill capability memory directly into the DB
-    const db = getDb();
-    const now = Date.now();
-    db.insert(memoryItems)
-      .values({
-        id: "cli-doctor-item",
-        kind: "capability",
-        subject: "cli:doctor",
-        statement: "The doctor command diagnoses issues.",
-        status: "active",
-        confidence: 1.0,
-        importance: 0.7,
-        fingerprint: "cli-doctor-fp",
-        sourceType: "extraction",
-        scopeId: "default",
-        firstSeenAt: now,
-        lastSeenAt: now,
-      })
-      .run();
-
-    // Seed with empty catalog — skill pruner runs but should skip cli:* items
-    mockLoadSkillCatalog = () => [];
-    seedCatalogSkillMemories();
-
-    const item = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.subject, "cli:doctor"))
-      .get();
-    expect(item).toBeDefined();
-    expect(item!.status).toBe("active");
-  });
-
-  test("does not throw when loadSkillCatalog throws", () => {
-    mockLoadSkillCatalog = () => {
-      throw new Error("Catalog load failure");
-    };
-
-    // Best-effort: should not propagate the error
-    expect(() => seedCatalogSkillMemories()).not.toThrow();
-  });
-
-  test("skips skills whose feature flag is disabled", () => {
-    const skills: SkillSummary[] = [
-      makeSkillSummary({
-        id: "unflagged-skill",
-        displayName: "Unflagged",
-        description: "No flag",
-      }),
-      makeSkillSummary({
-        id: "flagged-skill",
-        displayName: "Flagged",
-        description: "Has flag",
-        featureFlag: "my_gated_feature",
-      }),
-    ];
-    mockLoadSkillCatalog = () => skills;
-
-    // Disable the feature flag for the flagged skill
-    mockIsFeatureFlagEnabled = (key: string) => key !== "my_gated_feature";
-
-    seedCatalogSkillMemories();
-
-    const db = getDb();
-    const items = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
-      .all();
-
-    // Only the unflagged skill should have a capability row
-    expect(items).toHaveLength(1);
-    expect(items[0].subject).toBe("skill:unflagged-skill");
-    expect(items[0].status).toBe("active");
-  });
-
-  test("prunes pre-existing capability for a skill whose flag becomes disabled", () => {
-    // First seed with both skills, all flags enabled
-    const skills: SkillSummary[] = [
-      makeSkillSummary({
-        id: "unflagged-skill",
-        displayName: "Unflagged",
-        description: "No flag",
-      }),
-      makeSkillSummary({
-        id: "flagged-skill",
-        displayName: "Flagged",
-        description: "Has flag",
-        featureFlag: "my_gated_feature",
-      }),
-    ];
-    mockLoadSkillCatalog = () => skills;
-    mockIsFeatureFlagEnabled = () => true;
-    seedCatalogSkillMemories();
-
-    const db = getDb();
-    const beforeItems = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
-      .all();
-    expect(beforeItems).toHaveLength(2);
-    expect(beforeItems.every((i) => i.status === "active")).toBe(true);
-
-    // Now disable the flag — the flagged skill should be pruned
-    mockIsFeatureFlagEnabled = (key: string) => key !== "my_gated_feature";
-    seedCatalogSkillMemories();
-
-    const afterItems = db
-      .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
-      .all();
-    expect(afterItems).toHaveLength(2); // still 2 rows, but one soft-deleted
-
-    const active = afterItems.filter((i) => i.status === "active");
-    const deleted = afterItems.filter((i) => i.status === "deleted");
-
-    expect(active).toHaveLength(1);
-    expect(active[0].subject).toBe("skill:unflagged-skill");
-
-    expect(deleted).toHaveLength(1);
-    expect(deleted[0].subject).toBe("skill:flagged-skill");
-  });
-
-  test("does not throw on DB error during pruning", () => {
-    mockLoadSkillCatalog = () => [
-      makeSkillSummary({
-        id: "skill-a",
-        displayName: "Skill A",
-        description: "Does A",
-      }),
-    ];
-
-    // Drop memory_items to force a DB error during the prune phase
-    resetDb();
-    const db = getDb();
-    db.run("DROP TABLE IF EXISTS memory_items");
-
-    expect(() => seedCatalogSkillMemories()).not.toThrow();
-
-    // Restore DB state for subsequent tests (see upsert "does not throw" test
-    // for rationale on why we delete the DB file).
-    resetDb();
-    const dbPath = getDbPath();
-    for (const ext of ["", "-wal", "-shm"]) {
-      rmSync(`${dbPath}${ext}`, { force: true });
-    }
-    initializeDb();
-  });
-});