@vellumai/assistant 0.5.14 → 0.5.16

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

@@ -1,26 +1,8 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { rmSync } from "node:fs";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { eq } from "drizzle-orm";
 
-const testDir = mkdtempSync(join(tmpdir(), "skill-memory-"));
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-  getWorkspaceSkillsDir: () => join(testDir, "skills"),
-  getWorkspaceConfigPath: () => join(testDir, "config.json"),
-  readPlatformToken: () => undefined,
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -38,16 +20,15 @@ mock.module("../memory/qdrant-client.js", () => ({
   initQdrantClient: () => {},
 }));
 
-// Controllable mock for resolveCatalog used by seedCatalogSkillMemories
-let mockResolveCatalog: () => Promise<
-  import("../skills/catalog-install.js").CatalogSkill[]
-> = async () => [];
+// Controllable mock for loadSkillCatalog used by seedCatalogSkillMemories
+let mockLoadSkillCatalog: () => import("../config/skills.js").SkillSummary[] =
+  () => [];
 
-mock.module("../skills/catalog-install.js", () => ({
-  resolveCatalog: (..._args: unknown[]) => mockResolveCatalog(),
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: (..._args: unknown[]) => mockLoadSkillCatalog(),
 }));
 
-// Controllable mock for isAssistantFeatureFlagEnabled used by seedCatalogSkillMemories
+// Controllable mock for isAssistantFeatureFlagEnabled used by resolveSkillStates
 let mockIsFeatureFlagEnabled: (key: string) => boolean = () => true;
 
 mock.module("../config/assistant-feature-flags.js", () => ({
@@ -78,25 +59,24 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 
+import type { SkillSummary } from "../config/skills.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { memoryItems, memoryJobs } from "../memory/schema.js";
-import type { CatalogSkill } from "../skills/catalog-install.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();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    // best effort cleanup
-  }
 });
 
 function resetTables() {
@@ -107,11 +87,17 @@ function resetTables() {
   db.run("DELETE FROM memory_jobs");
 }
 
-function makeSkill(overrides: Partial<CatalogSkill> = {}): CatalogSkill {
+function makeSkillSummary(
+  overrides: Partial<SkillSummary> = {},
+): SkillSummary {
   return {
     id: "test-skill",
-    name: "Test Skill",
+    name: "test-skill",
+    displayName: "Test Skill",
     description: "A skill for testing",
+    directoryPath: "/skills/test-skill",
+    skillFilePath: "/skills/test-skill/SKILL.md",
+    source: "managed",
     ...overrides,
   };
 }
@@ -120,33 +106,63 @@ function makeSkill(overrides: Partial<CatalogSkill> = {}): CatalogSkill {
 
 describe("buildCapabilityStatement", () => {
   test("includes display name, id, and description", () => {
-    const entry = makeSkill({
-      metadata: { vellum: { "display-name": "My Skill" } },
-    });
-    const result = buildCapabilityStatement(entry);
+    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 entry = makeSkill({
-      metadata: {
-        vellum: {
-          "display-name": "My Skill",
-          "activation-hints": ["user asks to search", "needs web data"],
-        },
-      },
-    });
-    const result = buildCapabilityStatement(entry);
+    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("works without metadata (falls back to name)", () => {
-    const entry = makeSkill({ metadata: undefined });
-    const result = buildCapabilityStatement(entry);
+  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");
@@ -154,20 +170,70 @@ describe("buildCapabilityStatement", () => {
 
   test("truncates long statements to 500 chars", () => {
     const longDesc = "x".repeat(600);
-    const entry = makeSkill({ description: longDesc });
-    const result = buildCapabilityStatement(entry);
+    const input: SkillCapabilityInput = {
+      id: "test-skill",
+      displayName: "Test Skill",
+      description: longDesc,
+    };
+    const result = buildCapabilityStatement(input);
     expect(result.length).toBe(500);
   });
 });
 
+// ─── fromSkillSummary ────────────────────────────────────────────────────────
+
+describe("fromSkillSummary", () => {
+  test("maps displayName from SkillSummary", () => {
+    const entry = makeSkillSummary({ displayName: "Pretty Name" });
+    const input = fromSkillSummary(entry);
+    expect(input.displayName).toBe("Pretty Name");
+  });
+
+  test("maps activationHints from SkillSummary", () => {
+    const hints = ["user asks to search", "needs web data"];
+    const entry = makeSkillSummary({ activationHints: hints });
+    const input = fromSkillSummary(entry);
+    expect(input.activationHints).toEqual(hints);
+  });
+
+  test("leaves activationHints undefined when not present", () => {
+    const entry = makeSkillSummary({ activationHints: undefined });
+    const input = fromSkillSummary(entry);
+    expect(input.activationHints).toBeUndefined();
+  });
+
+  test("maps avoidWhen from SkillSummary", () => {
+    const cues = ["offline mode", "user wants local files only"];
+    const entry = makeSkillSummary({ avoidWhen: cues });
+    const input = fromSkillSummary(entry);
+    expect(input.avoidWhen).toEqual(cues);
+  });
+
+  test("leaves avoidWhen undefined when not present", () => {
+    const entry = makeSkillSummary({ avoidWhen: undefined });
+    const input = fromSkillSummary(entry);
+    expect(input.avoidWhen).toBeUndefined();
+  });
+
+  test("copies id and description directly", () => {
+    const entry = makeSkillSummary({
+      id: "my-id",
+      description: "Does amazing things",
+    });
+    const input = fromSkillSummary(entry);
+    expect(input.id).toBe("my-id");
+    expect(input.description).toBe("Does amazing things");
+  });
+});
+
 // ─── upsertSkillCapabilityMemory ─────────────────────────────────────────────
 
 describe("upsertSkillCapabilityMemory", () => {
   beforeEach(resetTables);
 
   test("inserts with correct kind, subject, confidence, importance", () => {
-    const entry = makeSkill();
-    upsertSkillCapabilityMemory("test-skill", entry);
+    const input = fromSkillSummary(makeSkillSummary());
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const db = getDb();
     const items = db.select().from(memoryItems).all();
@@ -186,8 +252,8 @@ describe("upsertSkillCapabilityMemory", () => {
   });
 
   test("is idempotent (same entry only touches lastSeenAt)", () => {
-    const entry = makeSkill();
-    upsertSkillCapabilityMemory("test-skill", entry);
+    const input = fromSkillSummary(makeSkillSummary());
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const db = getDb();
     const before = db.select().from(memoryItems).all();
@@ -195,7 +261,7 @@ describe("upsertSkillCapabilityMemory", () => {
     const originalLastSeen = before[0].lastSeenAt;
 
     // Upsert again
-    upsertSkillCapabilityMemory("test-skill", entry);
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const after = db.select().from(memoryItems).all();
     expect(after).toHaveLength(1);
@@ -209,8 +275,10 @@ describe("upsertSkillCapabilityMemory", () => {
   });
 
   test("updates statement when description changes", () => {
-    const entry = makeSkill({ description: "Original description" });
-    upsertSkillCapabilityMemory("test-skill", entry);
+    const input = fromSkillSummary(
+      makeSkillSummary({ description: "Original description" }),
+    );
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const db = getDb();
     const before = db.select().from(memoryItems).all();
@@ -218,8 +286,10 @@ describe("upsertSkillCapabilityMemory", () => {
     expect(before[0].statement).toContain("Original description");
 
     // Change description
-    const updatedEntry = makeSkill({ description: "Updated description" });
-    upsertSkillCapabilityMemory("test-skill", updatedEntry);
+    const updatedInput = fromSkillSummary(
+      makeSkillSummary({ description: "Updated description" }),
+    );
+    upsertSkillCapabilityMemory("test-skill", updatedInput);
 
     const after = db.select().from(memoryItems).all();
     expect(after).toHaveLength(1);
@@ -232,8 +302,8 @@ describe("upsertSkillCapabilityMemory", () => {
   });
 
   test("reactivates soft-deleted items", () => {
-    const entry = makeSkill();
-    upsertSkillCapabilityMemory("test-skill", entry);
+    const input = fromSkillSummary(makeSkillSummary());
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const db = getDb();
     // Soft-delete the item
@@ -249,7 +319,7 @@ describe("upsertSkillCapabilityMemory", () => {
     db.run("DELETE FROM memory_jobs");
 
     // Upsert again — should reactivate
-    upsertSkillCapabilityMemory("test-skill", entry);
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const reactivated = db.select().from(memoryItems).all();
     expect(reactivated).toHaveLength(1);
@@ -273,7 +343,10 @@ describe("upsertSkillCapabilityMemory", () => {
     db.run("DROP TABLE IF EXISTS memory_items");
 
     expect(() => {
-      upsertSkillCapabilityMemory("test-skill", makeSkill());
+      upsertSkillCapabilityMemory(
+        "test-skill",
+        fromSkillSummary(makeSkillSummary()),
+      );
     }).not.toThrow();
 
     // Restore DB state for subsequent tests.
@@ -281,8 +354,9 @@ describe("upsertSkillCapabilityMemory", () => {
     // 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(join(testDir, `test.db${ext}`), { force: true });
+      rmSync(`${dbPath}${ext}`, { force: true });
     }
     initializeDb();
   });
@@ -294,8 +368,8 @@ describe("deleteSkillCapabilityMemory", () => {
   beforeEach(resetTables);
 
   test("soft-deletes matching item", () => {
-    const entry = makeSkill();
-    upsertSkillCapabilityMemory("test-skill", entry);
+    const input = fromSkillSummary(makeSkillSummary());
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const db = getDb();
     const before = db.select().from(memoryItems).all();
@@ -333,8 +407,9 @@ describe("deleteSkillCapabilityMemory", () => {
     // 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(join(testDir, `test.db${ext}`), { force: true });
+      rmSync(`${dbPath}${ext}`, { force: true });
     }
     initializeDb();
   });
@@ -346,19 +421,31 @@ describe("seedCatalogSkillMemories", () => {
   beforeEach(() => {
     resetTables();
     // Reset mocks to defaults
-    mockResolveCatalog = async () => [];
+    mockLoadSkillCatalog = () => [];
     mockIsFeatureFlagEnabled = () => true;
   });
 
-  test("upserts capability memories for all catalog entries", async () => {
-    const skills: CatalogSkill[] = [
-      makeSkill({ id: "skill-a", name: "Skill A", description: "Does A" }),
-      makeSkill({ id: "skill-b", name: "Skill B", description: "Does B" }),
-      makeSkill({ id: "skill-c", name: "Skill C", description: "Does C" }),
+  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",
+      }),
     ];
-    mockResolveCatalog = async () => skills;
+    mockLoadSkillCatalog = () => skills;
 
-    await seedCatalogSkillMemories();
+    seedCatalogSkillMemories();
 
     const db = getDb();
     const items = db
@@ -381,15 +468,128 @@ describe("seedCatalogSkillMemories", () => {
     }
   });
 
-  test("prunes stale capabilities for skills no longer in catalog", async () => {
+  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: CatalogSkill[] = [
-      makeSkill({ id: "skill-a", name: "Skill A", description: "Does A" }),
-      makeSkill({ id: "skill-b", name: "Skill B", description: "Does B" }),
-      makeSkill({ id: "skill-c", name: "Skill C", description: "Does C" }),
+    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",
+      }),
     ];
-    mockResolveCatalog = async () => initialSkills;
-    await seedCatalogSkillMemories();
+    mockLoadSkillCatalog = () => initialSkills;
+    seedCatalogSkillMemories();
 
     const db = getDb();
     const beforeItems = db
@@ -401,10 +601,14 @@ describe("seedCatalogSkillMemories", () => {
     expect(beforeItems.every((i) => i.status === "active")).toBe(true);
 
     // Now seed with only skill-a — skill-b and skill-c should be pruned
-    mockResolveCatalog = async () => [
-      makeSkill({ id: "skill-a", name: "Skill A", description: "Does A" }),
+    mockLoadSkillCatalog = () => [
+      makeSkillSummary({
+        id: "skill-a",
+        displayName: "Skill A",
+        description: "Does A",
+      }),
     ];
-    await seedCatalogSkillMemories();
+    seedCatalogSkillMemories();
 
     const afterItems = db
       .select()
@@ -424,11 +628,11 @@ describe("seedCatalogSkillMemories", () => {
     expect(deletedSubjects).toEqual(["skill:skill-b", "skill:skill-c"]);
   });
 
-  test("handles empty catalog without errors", async () => {
+  test("handles empty catalog without errors", () => {
     // Pre-populate a skill so we can verify it gets pruned
     upsertSkillCapabilityMemory(
       "existing-skill",
-      makeSkill({ id: "existing-skill" }),
+      fromSkillSummary(makeSkillSummary({ id: "existing-skill" })),
     );
 
     const db = getDb();
@@ -437,8 +641,8 @@ describe("seedCatalogSkillMemories", () => {
     expect(beforeItems[0].status).toBe("active");
 
     // Seed with empty catalog
-    mockResolveCatalog = async () => [];
-    await seedCatalogSkillMemories();
+    mockLoadSkillCatalog = () => [];
+    seedCatalogSkillMemories();
 
     // The existing skill should be pruned (soft-deleted)
     const afterItems = db.select().from(memoryItems).all();
@@ -446,35 +650,69 @@ describe("seedCatalogSkillMemories", () => {
     expect(afterItems[0].status).toBe("deleted");
   });
 
-  test("does not throw when resolveCatalog rejects", async () => {
-    mockResolveCatalog = async () => {
-      throw new Error("Network failure");
+  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
-    await expect(seedCatalogSkillMemories()).resolves.toBeUndefined();
+    expect(() => seedCatalogSkillMemories()).not.toThrow();
   });
 
-  test("skips skills whose feature flag is disabled", async () => {
-    const skills: CatalogSkill[] = [
-      makeSkill({
+  test("skips skills whose feature flag is disabled", () => {
+    const skills: SkillSummary[] = [
+      makeSkillSummary({
         id: "unflagged-skill",
-        name: "Unflagged",
+        displayName: "Unflagged",
         description: "No flag",
       }),
-      makeSkill({
+      makeSkillSummary({
         id: "flagged-skill",
-        name: "Flagged",
+        displayName: "Flagged",
         description: "Has flag",
-        metadata: { vellum: { "feature-flag": "my_gated_feature" } },
+        featureFlag: "my_gated_feature",
       }),
     ];
-    mockResolveCatalog = async () => skills;
+    mockLoadSkillCatalog = () => skills;
 
     // Disable the feature flag for the flagged skill
     mockIsFeatureFlagEnabled = (key: string) => key !== "my_gated_feature";
 
-    await seedCatalogSkillMemories();
+    seedCatalogSkillMemories();
 
     const db = getDb();
     const items = db
@@ -489,24 +727,24 @@ describe("seedCatalogSkillMemories", () => {
     expect(items[0].status).toBe("active");
   });
 
-  test("prunes pre-existing capability for a skill whose flag becomes disabled", async () => {
+  test("prunes pre-existing capability for a skill whose flag becomes disabled", () => {
     // First seed with both skills, all flags enabled
-    const skills: CatalogSkill[] = [
-      makeSkill({
+    const skills: SkillSummary[] = [
+      makeSkillSummary({
         id: "unflagged-skill",
-        name: "Unflagged",
+        displayName: "Unflagged",
         description: "No flag",
       }),
-      makeSkill({
+      makeSkillSummary({
         id: "flagged-skill",
-        name: "Flagged",
+        displayName: "Flagged",
         description: "Has flag",
-        metadata: { vellum: { "feature-flag": "my_gated_feature" } },
+        featureFlag: "my_gated_feature",
       }),
     ];
-    mockResolveCatalog = async () => skills;
+    mockLoadSkillCatalog = () => skills;
     mockIsFeatureFlagEnabled = () => true;
-    await seedCatalogSkillMemories();
+    seedCatalogSkillMemories();
 
     const db = getDb();
     const beforeItems = db
@@ -519,7 +757,7 @@ describe("seedCatalogSkillMemories", () => {
 
     // Now disable the flag — the flagged skill should be pruned
     mockIsFeatureFlagEnabled = (key: string) => key !== "my_gated_feature";
-    await seedCatalogSkillMemories();
+    seedCatalogSkillMemories();
 
     const afterItems = db
       .select()
@@ -538,9 +776,13 @@ describe("seedCatalogSkillMemories", () => {
     expect(deleted[0].subject).toBe("skill:flagged-skill");
   });
 
-  test("does not throw on DB error during pruning", async () => {
-    mockResolveCatalog = async () => [
-      makeSkill({ id: "skill-a", name: "Skill A", description: "Does A" }),
+  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
@@ -548,13 +790,14 @@ describe("seedCatalogSkillMemories", () => {
     const db = getDb();
     db.run("DROP TABLE IF EXISTS memory_items");
 
-    await expect(seedCatalogSkillMemories()).resolves.toBeUndefined();
+    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(join(testDir, `test.db${ext}`), { force: true });
+      rmSync(`${dbPath}${ext}`, { force: true });
     }
     initializeDb();
   });