@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -1,8 +1,9 @@
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let TEST_DIR = "";
+const seedUpsertSlugs: string[] = [];
 
 const mockConfig = {
   provider: "anthropic",
@@ -32,6 +33,10 @@ const mockConfig = {
     },
     "web-search": { mode: "your-own", provider: "inference-provider-native" },
   },
+  skills: {
+    entries: {},
+    allowBundled: [],
+  },
 };
 
 mock.module("../util/logger.js", () => ({
@@ -51,7 +56,36 @@ mock.module("../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
+mock.module("../skills/catalog-cache.js", () => ({
+  getCatalog: async () => [],
+}));
+
+mock.module("../memory/embedding-backend.js", () => ({
+  embedWithBackend: async (_config: unknown, inputs: unknown[]) => ({
+    provider: "local",
+    model: "test-model",
+    vectors: inputs.map(() => [0.1, 0.2, 0.3]),
+  }),
+  generateSparseEmbedding: () => ({ indices: [1], values: [1] }),
+}));
+
+mock.module("../memory/v2/qdrant.js", () => ({
+  upsertConceptPageEmbedding: async (params: { slug: string }) => {
+    seedUpsertSlugs.push(params.slug);
+  },
+  pruneSlugsWithPrefixExcept: async () => {},
+}));
+
+mock.module("../daemon/skill-memory-refresh.js", () => ({
+  refreshSkillCapabilityMemories: mock(() => {}),
+}));
+
 import { loadSkillCatalog } from "../config/skills.js";
+import {
+  _resetSkillStoreForTests,
+  getSkillCapability,
+  seedV2SkillEntries,
+} from "../memory/v2/skill-store.js";
 import { executeDeleteManagedSkill } from "../tools/skills/delete-managed.js";
 import { SkillLoadTool } from "../tools/skills/load.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
@@ -68,9 +102,69 @@ function makeContext(): ToolContext {
 beforeEach(() => {
   TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
   mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
+  seedUpsertSlugs.length = 0;
+  _resetSkillStoreForTests();
 });
 
 describe("managed skill lifecycle: scaffold → catalog → prompt → delete", () => {
+  test("valid managed skill without SKILLS.md works across catalog, skill_load, and Memory V2 seeding", async () => {
+    const skillId = "e2e-custom-skill";
+    const skillSlug = `skills/${skillId}`;
+    const skillDir = join(TEST_DIR, "skills", skillId);
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(
+      join(skillDir, "SKILL.md"),
+      `---
+name: "E2E Custom Skill"
+description: "Exercises custom managed skill loading."
+metadata:
+  vellum:
+    activation-hints:
+      - user asks for custom lifecycle verification
+---
+
+Run the custom lifecycle verification procedure.
+`,
+      "utf-8",
+    );
+
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+
+    const catalog = loadSkillCatalog();
+    const catalogSkill = catalog.find((s) => s.id === skillId);
+    expect(catalogSkill).toBeDefined();
+    expect(catalogSkill!.source).toBe("managed");
+    expect(catalogSkill!.displayName).toBe("E2E Custom Skill");
+
+    const skillLoadTool = new (SkillLoadTool as any)() as InstanceType<
+      typeof SkillLoadTool
+    >;
+    const loadResult = await skillLoadTool.execute(
+      { skill: skillId },
+      makeContext(),
+    );
+    expect(loadResult.isError).not.toBe(true);
+    expect(loadResult.content as string).toContain("Skill: E2E Custom Skill");
+    expect(loadResult.content as string).toContain("ID: e2e-custom-skill");
+    expect(loadResult.content as string).toContain(
+      "Run the custom lifecycle verification procedure.",
+    );
+
+    await seedV2SkillEntries();
+
+    expect(seedUpsertSlugs).toContain(skillSlug);
+    const capability = getSkillCapability(skillSlug);
+    expect(capability).not.toBeNull();
+    expect(capability!.id).toBe("e2e-custom-skill");
+    expect(capability!.content).toContain('The "E2E Custom Skill" skill');
+    expect(capability!.content).toContain(
+      "Exercises custom managed skill loading.",
+    );
+    expect(capability!.content).toContain(
+      "Use when: user asks for custom lifecycle verification.",
+    );
+  }, 15_000);
+
   test("full lifecycle: create skill, verify in catalog and prompt, then delete", async () => {
     // Step 1: Scaffold a managed skill
     const scaffoldResult = await executeScaffoldManagedSkill(
@@ -87,9 +181,11 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     expect(scaffoldResult.isError).not.toBe(true);
     const scaffoldData = JSON.parse(scaffoldResult.content as string);
     expect(scaffoldData.created).toBe(true);
+    expect(scaffoldData).not.toHaveProperty("index_updated");
 
     // Step 2: Verify SKILL.md was written
-    const skillMdPath = join(TEST_DIR, "skills", "lifecycle-test", "SKILL.md");
+    const skillDir = join(TEST_DIR, "skills", "lifecycle-test");
+    const skillMdPath = join(skillDir, "SKILL.md");
     expect(existsSync(skillMdPath)).toBe(true);
     const skillContent = readFileSync(skillMdPath, "utf-8");
     expect(skillContent).toContain('name: "Lifecycle Test"');
@@ -102,6 +198,7 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     expect(found).toBeDefined();
     expect(found!.name).toBe("Lifecycle Test");
     expect(found!.description).toBe("Integration test skill.");
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
 
     // Step 4: Delete the skill
     const deleteResult = await executeDeleteManagedSkill(
@@ -114,20 +211,15 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     expect(deleteResult.isError).not.toBe(true);
     const deleteData = JSON.parse(deleteResult.content as string);
     expect(deleteData.deleted).toBe(true);
+    expect(deleteData).not.toHaveProperty("index_updated");
 
-    // Step 5: Verify skill is gone from filesystem
-    expect(existsSync(skillMdPath)).toBe(false);
+    // Step 5: Verify skill directory is gone from filesystem
+    expect(existsSync(skillDir)).toBe(false);
 
     // Step 6: Verify skill no longer in catalog
     const catalogAfter = loadSkillCatalog();
     expect(catalogAfter.find((s) => s.id === "lifecycle-test")).toBeUndefined();
-
-    // Step 7: Verify SKILLS.md index no longer has the entry
-    const indexPath = join(TEST_DIR, "skills", "SKILLS.md");
-    if (existsSync(indexPath)) {
-      const indexContent = readFileSync(indexPath, "utf-8");
-      expect(indexContent).not.toContain("lifecycle-test");
-    }
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
   });
 
   test("scaffold with overwrite replaces existing skill", async () => {
@@ -166,13 +258,12 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     expect(skillContent).toContain("Updated body.");
     expect(skillContent).not.toContain("Original body.");
 
-    // Index should still have exactly one entry
-    const indexContent = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    const matches = indexContent.match(/overwrite-test/g);
-    expect(matches?.length).toBe(1);
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+
+    const catalog = loadSkillCatalog();
+    const skill = catalog.find((s) => s.id === "overwrite-test");
+    expect(skill).toBeDefined();
+    expect(skill!.name).toBe("V2");
   });
 
   test("delete non-existent skill returns error", async () => {

package/src/__tests__/managed-store.test.ts

@@ -34,9 +34,6 @@ import {
   buildSkillMarkdown,
   createManagedSkill,
   deleteManagedSkill,
-  readSkillVersion,
-  removeSkillsIndexEntry,
-  upsertSkillsIndexEntry,
   validateManagedSkillId,
 } from "../skills/managed-store.js";
 
@@ -48,6 +45,22 @@ afterEach(() => {
   rmSync(join(TEST_DIR, "skills"), { recursive: true, force: true });
 });
 
+interface TestInstallMeta {
+  origin?: string;
+  version?: string;
+  installedAt?: string;
+  installedBy?: string;
+}
+
+function readInstallMetaFile(skillId: string): TestInstallMeta {
+  return JSON.parse(
+    readFileSync(
+      join(TEST_DIR, "skills", skillId, "install-meta.json"),
+      "utf-8",
+    ),
+  );
+}
+
 describe("validateManagedSkillId", () => {
   test("accepts valid slug IDs", () => {
     expect(validateManagedSkillId("my-skill")).toBeNull();
@@ -142,7 +155,7 @@ describe("buildSkillMarkdown", () => {
     });
 
     // Load it back via loadSkillCatalog (which uses parseFrontmatter)
-    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const catalog = loadSkillCatalog();
     const skill = catalog.find((s) => s.id === "roundtrip-test");
     expect(skill).toBeDefined();
     expect(skill!.name).toBe('Say "hello" & back\\slash');
@@ -159,7 +172,7 @@ describe("buildSkillMarkdown", () => {
       bodyMarkdown: "Body.",
     });
 
-    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const catalog = loadSkillCatalog();
     const skill = catalog.find((s) => s.id === "backslash-n-test");
     expect(skill).toBeDefined();
     expect(skill!.name).toBe("path\\name");
@@ -205,7 +218,7 @@ describe("buildSkillMarkdown", () => {
       includes: ["child-x", "child-y"],
     });
 
-    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const catalog = loadSkillCatalog();
     const skill = catalog.find((s) => s.id === "roundtrip-includes");
     expect(skill).toBeDefined();
     expect(skill!.includes).toEqual(["child-x", "child-y"]);
@@ -231,113 +244,6 @@ describe("buildSkillMarkdown", () => {
   });
 });
 
-describe("SKILLS.md index management", () => {
-  test("SKILLS.md is created when absent", () => {
-    upsertSkillsIndexEntry("my-skill");
-    const indexPath = join(TEST_DIR, "skills", "SKILLS.md");
-    expect(existsSync(indexPath)).toBe(true);
-    const content = readFileSync(indexPath, "utf-8");
-    expect(content).toContain("- my-skill");
-  });
-
-  test("index add is idempotent", () => {
-    upsertSkillsIndexEntry("my-skill");
-    upsertSkillsIndexEntry("my-skill");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    const matches = content.match(/- my-skill/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  test("delete removes directory and index entry", () => {
-    // Set up a skill
-    const skillDir = join(TEST_DIR, "skills", "doomed");
-    mkdirSync(skillDir, { recursive: true });
-    writeFileSync(join(skillDir, "SKILL.md"), "test");
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "- doomed\n- survivor\n",
-    );
-
-    const result = deleteManagedSkill("doomed");
-    expect(result.deleted).toBe(true);
-    expect(result.indexUpdated).toBe(true);
-    expect(existsSync(skillDir)).toBe(false);
-
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(content).not.toContain("doomed");
-    expect(content).toContain("survivor");
-  });
-
-  test("upsert recognizes * bullet entries", () => {
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "* existing-skill\n");
-    upsertSkillsIndexEntry("existing-skill");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    const matches = content.match(/existing-skill/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  test("remove handles * bullet entries", () => {
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "* doomed\n- survivor\n",
-    );
-    removeSkillsIndexEntry("doomed");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(content).not.toContain("doomed");
-    expect(content).toContain("survivor");
-  });
-
-  test("remove handles markdown link entries", () => {
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "- [My Skill](my-skill/SKILL.md)\n- survivor\n",
-    );
-    removeSkillsIndexEntry("my-skill");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(content).not.toContain("my-skill");
-    expect(content).toContain("survivor");
-  });
-
-  test("upsert recognizes markdown link entries as existing", () => {
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "- [My Skill](my-skill/SKILL.md)\n",
-    );
-    upsertSkillsIndexEntry("my-skill");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    const matches = content.match(/my-skill/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  test("remove from index handles missing entry gracefully", () => {
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- other-skill\n");
-    removeSkillsIndexEntry("nonexistent");
-    const content = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(content).toContain("other-skill");
-  });
-});
-
 describe("createManagedSkill", () => {
   test("creates skill and writes to expected path", () => {
     const result = createManagedSkill({
@@ -429,35 +335,20 @@ describe("createManagedSkill", () => {
     expect(result.error).toContain("description is required");
   });
 
-  test("updates SKILLS.md index", () => {
+  test("does not create SKILLS.md and is discovered through SKILL.md directory", () => {
     createManagedSkill({
-      id: "indexed-skill",
-      name: "Indexed",
-      description: "Gets indexed",
+      id: "discovered-skill",
+      name: "Discovered",
+      description: "Found by directory discovery",
       bodyMarkdown: "Body.",
     });
 
-    const indexContent = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(indexContent).toContain("- indexed-skill");
-  });
-
-  test("skips index when addToIndex=false", () => {
-    createManagedSkill({
-      id: "no-index",
-      name: "No Index",
-      description: "Not indexed",
-      bodyMarkdown: "Body.",
-      addToIndex: false,
-    });
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
 
-    const indexPath = join(TEST_DIR, "skills", "SKILLS.md");
-    if (existsSync(indexPath)) {
-      const content = readFileSync(indexPath, "utf-8");
-      expect(content).not.toContain("no-index");
-    }
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const skill = catalog.find((s) => s.id === "discovered-skill");
+    expect(skill).toBeDefined();
+    expect(skill!.name).toBe("Discovered");
   });
 });
 
@@ -564,6 +455,9 @@ describe("deleteManagedSkill", () => {
     const result = deleteManagedSkill("to-delete");
     expect(result.deleted).toBe(true);
     expect(existsSync(join(TEST_DIR, "skills", "to-delete"))).toBe(false);
+
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    expect(catalog.find((s) => s.id === "to-delete")).toBeUndefined();
   });
 
   test("returns error for non-existent skill", () => {
@@ -578,75 +472,60 @@ describe("deleteManagedSkill", () => {
     expect(result.error).toContain("traversal");
   });
 
-  test("skips index removal when removeFromIndex=false", () => {
+  test("delete leaves a stale SKILLS.md index unchanged", () => {
     createManagedSkill({
       id: "keep-index",
       name: "Keep Index",
       description: "Index stays",
       bodyMarkdown: "Body.",
     });
+    writeFileSync(
+      join(TEST_DIR, "skills", "SKILLS.md"),
+      "- keep-index\n- survivor\n",
+    );
 
-    const result = deleteManagedSkill("keep-index", false);
+    const result = deleteManagedSkill("keep-index");
     expect(result.deleted).toBe(true);
-    expect(result.indexUpdated).toBe(false);
 
     const indexContent = readFileSync(
       join(TEST_DIR, "skills", "SKILLS.md"),
       "utf-8",
     );
     expect(indexContent).toContain("- keep-index");
+    expect(indexContent).toContain("- survivor");
+
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    expect(catalog.find((s) => s.id === "keep-index")).toBeUndefined();
   });
 
-  test("succeeds even when index cleanup throws", () => {
+  test("delete does not create or edit SKILLS.md", () => {
     createManagedSkill({
-      id: "index-fail",
-      name: "Index Fail",
-      description: "Index removal will throw",
+      id: "delete-no-index",
+      name: "Delete No Index",
+      description: "No index write",
       bodyMarkdown: "Body.",
     });
 
-    // Intercept the atomic write (.tmp- file) used by removeSkillsIndexEntry
     const skillsDir = join(TEST_DIR, "skills");
-    const originalWrite = fs.writeFileSync;
-    const spy = spyOn(fs, "writeFileSync").mockImplementation(((
-      path: fs.PathOrFileDescriptor,
-      data: string | NodeJS.ArrayBufferView,
-      options?: fs.WriteFileOptions,
-    ) => {
-      if (
-        typeof path === "string" &&
-        path.startsWith(skillsDir) &&
-        path.includes(".tmp-")
-      ) {
-        throw new Error("Simulated write failure");
-      }
-      return originalWrite(path, data, options);
-    }) as typeof fs.writeFileSync);
-
-    try {
-      const result = deleteManagedSkill("index-fail");
-      expect(result.deleted).toBe(true);
-      expect(result.indexUpdated).toBe(false);
-      expect(existsSync(join(skillsDir, "index-fail"))).toBe(false);
-    } finally {
-      spy.mockRestore();
-    }
+    const result = deleteManagedSkill("delete-no-index");
+    expect(result.deleted).toBe(true);
+    expect(existsSync(join(skillsDir, "delete-no-index"))).toBe(false);
+    expect(existsSync(join(skillsDir, "SKILLS.md"))).toBe(false);
   });
 });
 
 describe("version metadata", () => {
-  test("readSkillVersion returns null for non-existent skill", () => {
-    expect(readSkillVersion("nonexistent")).toBeNull();
-  });
-
-  test("readSkillVersion returns null when skill exists but has no version.json", () => {
+  test("createManagedSkill writes install-meta.json without version when version is omitted", () => {
     createManagedSkill({
       id: "no-version",
       name: "No Version",
       description: "Created without version",
       bodyMarkdown: "Body.",
     });
-    expect(readSkillVersion("no-version")).toBeNull();
+
+    const meta = readInstallMetaFile("no-version");
+    expect(meta.origin).toBe("custom");
+    expect(meta.version).toBeUndefined();
   });
 
   test("createManagedSkill writes install-meta.json when version is provided", () => {
@@ -658,8 +537,8 @@ describe("version metadata", () => {
       version: "v1:abc123",
     });
 
-    const version = readSkillVersion("versioned");
-    expect(version).toBe("v1:abc123");
+    const meta = readInstallMetaFile("versioned");
+    expect(meta.version).toBe("v1:abc123");
   });
 
   test("install-meta.json contains valid JSON with origin, version, and installedAt", () => {
@@ -678,10 +557,13 @@ describe("version metadata", () => {
       "install-meta.json",
     );
     expect(existsSync(metaPath)).toBe(true);
-    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    const meta = readInstallMetaFile("version-meta");
     expect(meta.origin).toBe("custom");
     expect(meta.version).toBe("v1:deadbeef");
     expect(typeof meta.installedAt).toBe("string");
+    if (typeof meta.installedAt !== "string") {
+      throw new Error("installedAt must be a string");
+    }
     // installedAt should be a valid ISO date
     expect(new Date(meta.installedAt).toISOString()).toBe(meta.installedAt);
   });
@@ -702,7 +584,7 @@ describe("version metadata", () => {
       "install-meta.json",
     );
     expect(existsSync(metaPath)).toBe(true);
-    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    const meta = readInstallMetaFile("with-contact");
     expect(meta.origin).toBe("custom");
     expect(meta.installedBy).toBe("contact-uuid-456");
   });
@@ -715,7 +597,8 @@ describe("version metadata", () => {
       bodyMarkdown: "Body.",
       version: "v1:first",
     });
-    expect(readSkillVersion("update-version")).toBe("v1:first");
+
+    expect(readInstallMetaFile("update-version").version).toBe("v1:first");
 
     createManagedSkill({
       id: "update-version",
@@ -725,28 +608,37 @@ describe("version metadata", () => {
       version: "v1:second",
       overwrite: true,
     });
-    expect(readSkillVersion("update-version")).toBe("v1:second");
+    expect(readInstallMetaFile("update-version").version).toBe("v1:second");
   });
 
-  test("readSkillVersion returns null for corrupted install-meta.json", () => {
+  test("overwrite removes legacy version.json", () => {
     createManagedSkill({
-      id: "corrupt-version",
-      name: "Corrupt",
-      description: "Will corrupt meta file",
+      id: "legacy-version",
+      name: "Legacy",
+      description: "Has legacy metadata",
       bodyMarkdown: "Body.",
-      version: "v1:valid",
+      version: "v1:first",
     });
 
-    // Corrupt the install-meta.json
-    const metaPath = join(
+    const legacyMetaPath = join(
       TEST_DIR,
       "skills",
-      "corrupt-version",
-      "install-meta.json",
+      "legacy-version",
+      "version.json",
     );
-    writeFileSync(metaPath, "{invalid json!!!", "utf-8");
+    writeFileSync(legacyMetaPath, '{"version":"legacy"}', "utf-8");
+    expect(existsSync(legacyMetaPath)).toBe(true);
+
+    createManagedSkill({
+      id: "legacy-version",
+      name: "Legacy Updated",
+      description: "Has current metadata",
+      bodyMarkdown: "Body.",
+      version: "v1:second",
+      overwrite: true,
+    });
 
-    expect(readSkillVersion("corrupt-version")).toBeNull();
+    expect(existsSync(legacyMetaPath)).toBe(false);
   });
 });
 

package/src/__tests__/media-generate-image.test.ts

@@ -81,7 +81,7 @@ let mockManagedProxyContext = {
   assistantApiKey: "",
 };
 
-mock.module("../providers/managed-proxy/context.js", () => ({
+mock.module("../providers/platform-proxy/context.js", () => ({
   buildManagedBaseUrl: async () => mockManagedBaseUrl,
   resolveManagedProxyContext: async () => mockManagedProxyContext,
 }));

package/src/__tests__/memory-retrieval-pipeline.test.ts

@@ -273,7 +273,6 @@ describe("memoryRetrieval pipeline — default vs custom plugin", () => {
       manifest: {
         name: "custom-memory-retrieval",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", memoryApi: "v1" },
       },
       middleware: { memoryRetrieval: customMiddleware },
     };
@@ -318,7 +317,6 @@ describe("memoryRetrieval pipeline — default vs custom plugin", () => {
       manifest: {
         name: "hanging-memory-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", memoryApi: "v1" },
       },
       middleware: { memoryRetrieval: hanging },
     };