@vellumai/assistant 0.5.15 → 0.6.0

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

@@ -1,25 +1,7 @@
-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,
-}));
+import { eq, like } from "drizzle-orm";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -38,16 +20,25 @@ 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("../config/skills.js", () => ({
+  loadSkillCatalog: (..._args: unknown[]) => mockLoadSkillCatalog(),
+}));
+
+// Controllable mock for getCachedCatalogSync used by seedCatalogSkillMemories
+let mockGetCachedCatalogSync: () => import("../skills/catalog-install.js").CatalogSkill[] =
+  () => [];
 
-mock.module("../skills/catalog-install.js", () => ({
-  resolveCatalog: (..._args: unknown[]) => mockResolveCatalog(),
+mock.module("../skills/catalog-cache.js", () => ({
+  getCachedCatalogSync: (..._args: unknown[]) => mockGetCachedCatalogSync(),
+  getCatalog: async () => mockGetCachedCatalogSync(),
+  invalidateCatalogCache: () => {},
 }));
 
-// 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,40 +69,44 @@ 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 { memoryGraphNodes, 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();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    // best effort cleanup
-  }
 });
 
 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_graph_nodes");
   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 +115,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,77 +179,131 @@ 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);
+  test("inserts with correct type, content, confidence, significance", () => {
+    const input = fromSkillSummary(makeSkillSummary());
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const db = getDb();
-    const items = db.select().from(memoryItems).all();
+    const items = db.select().from(memoryGraphNodes).all();
     expect(items).toHaveLength(1);
-    expect(items[0].kind).toBe("capability");
-    expect(items[0].subject).toBe("skill:test-skill");
+    expect(items[0].type).toBe("procedural");
+    expect(items[0].content).toMatch(/^skill:test-skill\n/);
     expect(items[0].confidence).toBe(1.0);
-    expect(items[0].importance).toBe(0.7);
-    expect(items[0].status).toBe("active");
+    expect(items[0].significance).toBe(0.7);
+    expect(items[0].fidelity).toBe("vivid");
     expect(items[0].scopeId).toBe("default");
 
-    // Should also enqueue an embed_item job
+    // Should also enqueue an embed_graph_node job
     const jobs = db.select().from(memoryJobs).all();
     expect(jobs).toHaveLength(1);
-    expect(jobs[0].type).toBe("embed_item");
+    expect(jobs[0].type).toBe("embed_graph_node");
   });
 
-  test("is idempotent (same entry only touches lastSeenAt)", () => {
-    const entry = makeSkill();
-    upsertSkillCapabilityMemory("test-skill", entry);
+  test("is idempotent (same entry only touches lastAccessed)", () => {
+    const input = fromSkillSummary(makeSkillSummary());
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const db = getDb();
-    const before = db.select().from(memoryItems).all();
+    const before = db.select().from(memoryGraphNodes).all();
     expect(before).toHaveLength(1);
-    const originalLastSeen = before[0].lastSeenAt;
+    const originalLastAccessed = before[0].lastAccessed;
 
     // Upsert again
-    upsertSkillCapabilityMemory("test-skill", entry);
+    upsertSkillCapabilityMemory("test-skill", input);
 
-    const after = db.select().from(memoryItems).all();
+    const after = db.select().from(memoryGraphNodes).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);
+    // Same content, so only lastAccessed changes
+    expect(after[0].content).toBe(before[0].content);
+    expect(after[0].lastAccessed).toBeGreaterThanOrEqual(originalLastAccessed);
 
     // 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 entry = makeSkill({ description: "Original description" });
-    upsertSkillCapabilityMemory("test-skill", entry);
+  test("updates content when description changes", () => {
+    const input = fromSkillSummary(
+      makeSkillSummary({ description: "Original description" }),
+    );
+    upsertSkillCapabilityMemory("test-skill", input);
 
     const db = getDb();
-    const before = db.select().from(memoryItems).all();
+    const before = db.select().from(memoryGraphNodes).all();
     expect(before).toHaveLength(1);
-    expect(before[0].statement).toContain("Original description");
+    expect(before[0].content).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();
+    const after = db.select().from(memoryGraphNodes).all();
     expect(after).toHaveLength(1);
-    expect(after[0].statement).toContain("Updated description");
-    expect(after[0].fingerprint).not.toBe(before[0].fingerprint);
+    expect(after[0].content).toContain("Updated description");
+    expect(after[0].content).not.toBe(before[0].content);
 
     // Should enqueue a second embed job
     const jobs = db.select().from(memoryJobs).all();
@@ -232,33 +311,33 @@ 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
-    db.update(memoryItems)
-      .set({ status: "deleted" })
-      .where(eq(memoryItems.subject, "skill:test-skill"))
+    db.update(memoryGraphNodes)
+      .set({ fidelity: "gone" })
+      .where(like(memoryGraphNodes.content, "skill:test-skill\n%"))
       .run();
 
-    const deleted = db.select().from(memoryItems).all();
-    expect(deleted[0].status).toBe("deleted");
+    const deleted = db.select().from(memoryGraphNodes).all();
+    expect(deleted[0].fidelity).toBe("gone");
 
     // Clear jobs from initial insert
     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();
+    const reactivated = db.select().from(memoryGraphNodes).all();
     expect(reactivated).toHaveLength(1);
-    expect(reactivated[0].status).toBe("active");
+    expect(reactivated[0].fidelity).toBe("vivid");
 
     // 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");
+    expect(jobs[0].type).toBe("embed_graph_node");
   });
 
   test("does not throw on DB error", () => {
@@ -268,12 +347,15 @@ describe("upsertSkillCapabilityMemory", () => {
     // 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.
+    // We drop the memory_graph_nodes table to force an error on the next query.
     const db = getDb();
-    db.run("DROP TABLE IF EXISTS memory_items");
+    db.run("DROP TABLE IF EXISTS memory_graph_nodes");
 
     expect(() => {
-      upsertSkillCapabilityMemory("test-skill", makeSkill());
+      upsertSkillCapabilityMemory(
+        "test-skill",
+        fromSkillSummary(makeSkillSummary()),
+      );
     }).not.toThrow();
 
     // Restore DB state for subsequent tests.
@@ -281,8 +363,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,19 +377,19 @@ 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();
+    const before = db.select().from(memoryGraphNodes).all();
     expect(before).toHaveLength(1);
-    expect(before[0].status).toBe("active");
+    expect(before[0].fidelity).toBe("vivid");
 
     deleteSkillCapabilityMemory("test-skill");
 
-    const after = db.select().from(memoryItems).all();
+    const after = db.select().from(memoryGraphNodes).all();
     expect(after).toHaveLength(1);
-    expect(after[0].status).toBe("deleted");
+    expect(after[0].fidelity).toBe("gone");
   });
 
   test("is no-op for missing item", () => {
@@ -316,7 +399,7 @@ describe("deleteSkillCapabilityMemory", () => {
     }).not.toThrow();
 
     const db = getDb();
-    const items = db.select().from(memoryItems).all();
+    const items = db.select().from(memoryGraphNodes).all();
     expect(items).toHaveLength(0);
   });
 
@@ -324,7 +407,7 @@ describe("deleteSkillCapabilityMemory", () => {
     // 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");
+    db.run("DROP TABLE IF EXISTS memory_graph_nodes");
 
     expect(() => {
       deleteSkillCapabilityMemory("test-skill");
@@ -333,8 +416,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,215 +430,416 @@ describe("seedCatalogSkillMemories", () => {
   beforeEach(() => {
     resetTables();
     // Reset mocks to defaults
-    mockResolveCatalog = async () => [];
+    mockLoadSkillCatalog = () => [];
     mockIsFeatureFlagEnabled = () => true;
+    // Default: non-empty cache so pruning is allowed
+    mockGetCachedCatalogSync = () => [
+      { id: "_sentinel", name: "_sentinel", description: "" },
+    ];
   });
 
-  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
       .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
+      .from(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
       .all();
     expect(items).toHaveLength(3);
 
-    const subjects = items.map((i) => i.subject).sort();
-    expect(subjects).toEqual([
+    const contentPrefixes = items.map((i) => i.content.split("\n")[0]).sort();
+    expect(contentPrefixes).toEqual([
       "skill:skill-a",
       "skill:skill-b",
       "skill:skill-c",
     ]);
 
-    // All should be active
+    // All should be vivid
     for (const item of items) {
-      expect(item.status).toBe("active");
+      expect(item.fidelity).toBe("vivid");
     }
   });
 
-  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(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
+      .all();
+    expect(items).toHaveLength(2);
+
+    const contentPrefixes = items.map((i) => i.content.split("\n")[0]).sort();
+    expect(contentPrefixes).toEqual(["skill:bundled-skill", "skill:managed-skill"]);
+
+    for (const item of items) {
+      expect(item.fidelity).toBe("vivid");
+    }
+  });
+
+  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(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
+      .all();
+
+    // Only allowed-bundled and managed-skill should be seeded
+    expect(items).toHaveLength(2);
+    const contentPrefixes = items.map((i) => i.content.split("\n")[0]).sort();
+    expect(contentPrefixes).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
       .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
+      .from(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
       .all();
     expect(beforeItems).toHaveLength(3);
-    expect(beforeItems.every((i) => i.status === "active")).toBe(true);
+    expect(beforeItems.every((i) => i.fidelity === "vivid")).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()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
+      .from(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
       .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");
+    const active = afterItems.filter((i) => i.fidelity === "vivid");
+    const deleted = afterItems.filter((i) => i.fidelity === "gone");
 
     expect(active).toHaveLength(1);
-    expect(active[0].subject).toBe("skill:skill-a");
+    expect(active[0].content).toMatch(/^skill:skill-a\n/);
 
     expect(deleted).toHaveLength(2);
-    const deletedSubjects = deleted.map((i) => i.subject).sort();
-    expect(deletedSubjects).toEqual(["skill:skill-b", "skill:skill-c"]);
+    const deletedPrefixes = deleted.map((i) => i.content.split("\n")[0]).sort();
+    expect(deletedPrefixes).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();
-    const beforeItems = db.select().from(memoryItems).all();
+    const beforeItems = db.select().from(memoryGraphNodes).all();
     expect(beforeItems).toHaveLength(1);
-    expect(beforeItems[0].status).toBe("active");
+    expect(beforeItems[0].fidelity).toBe("vivid");
 
     // 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();
+    const afterItems = db.select().from(memoryGraphNodes).all();
+    expect(afterItems).toHaveLength(1);
+    expect(afterItems[0].fidelity).toBe("gone");
+  });
+
+  test("does not prune when catalog cache is empty", () => {
+    // Pre-populate a skill
+    upsertSkillCapabilityMemory(
+      "existing-skill",
+      fromSkillSummary(makeSkillSummary({ id: "existing-skill" })),
+    );
+
+    const db = getDb();
+    const beforeItems = db.select().from(memoryGraphNodes).all();
+    expect(beforeItems).toHaveLength(1);
+    expect(beforeItems[0].fidelity).toBe("vivid");
+
+    // Seed with empty catalog AND empty cache — pruning guard should skip
+    mockLoadSkillCatalog = () => [];
+    mockGetCachedCatalogSync = () => [];
+    seedCatalogSkillMemories();
+
+    // The existing skill should NOT be pruned because the cache is empty
+    const afterItems = db.select().from(memoryGraphNodes).all();
     expect(afterItems).toHaveLength(1);
-    expect(afterItems[0].status).toBe("deleted");
+    expect(afterItems[0].fidelity).toBe("vivid");
   });
 
-  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(memoryGraphNodes)
+      .values({
+        id: "cli-doctor-item",
+        type: "procedural",
+        content: "cli:doctor\nThe doctor command diagnoses issues.",
+        fidelity: "vivid",
+        confidence: 1.0,
+        significance: 0.7,
+        sourceType: "inferred",
+        scopeId: "default",
+        created: now,
+        lastAccessed: now,
+        lastConsolidated: now,
+        emotionalCharge: '{"valence":0,"intensity":0.1,"decayCurve":"linear","decayRate":0.05,"originalIntensity":0.1}',
+        stability: 14,
+        reinforcementCount: 0,
+        lastReinforced: now,
+        sourceConversations: "[]",
+        narrativeRole: null,
+        partOfStory: null,
+      })
+      .run();
+
+    // Seed with empty catalog — skill pruner runs but should skip cli:* items
+    mockLoadSkillCatalog = () => [];
+    seedCatalogSkillMemories();
+
+    const item = db
+      .select()
+      .from(memoryGraphNodes)
+      .where(like(memoryGraphNodes.content, "cli:doctor\n%"))
+      .get();
+    expect(item).toBeDefined();
+    expect(item!.fidelity).toBe("vivid");
+  });
+
+  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
       .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
+      .from(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
       .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");
+    expect(items[0].content).toMatch(/^skill:unflagged-skill\n/);
+    expect(items[0].fidelity).toBe("vivid");
   });
 
-  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
       .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
+      .from(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
       .all();
     expect(beforeItems).toHaveLength(2);
-    expect(beforeItems.every((i) => i.status === "active")).toBe(true);
+    expect(beforeItems.every((i) => i.fidelity === "vivid")).toBe(true);
 
     // Now disable the flag — the flagged skill should be pruned
     mockIsFeatureFlagEnabled = (key: string) => key !== "my_gated_feature";
-    await seedCatalogSkillMemories();
+    seedCatalogSkillMemories();
 
     const afterItems = db
       .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
+      .from(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
       .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");
+    const active = afterItems.filter((i) => i.fidelity === "vivid");
+    const deleted = afterItems.filter((i) => i.fidelity === "gone");
 
     expect(active).toHaveLength(1);
-    expect(active[0].subject).toBe("skill:unflagged-skill");
+    expect(active[0].content).toMatch(/^skill:unflagged-skill\n/);
 
     expect(deleted).toHaveLength(1);
-    expect(deleted[0].subject).toBe("skill:flagged-skill");
+    expect(deleted[0].content).toMatch(/^skill:flagged-skill\n/);
   });
 
-  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
+    // Drop memory_graph_nodes to force a DB error during the prune phase
     resetDb();
     const db = getDb();
-    db.run("DROP TABLE IF EXISTS memory_items");
+    db.run("DROP TABLE IF EXISTS memory_graph_nodes");
 
-    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();
   });