@vellumai/assistant 0.4.43 → 0.4.45

package/src/__tests__/intent-routing.test.ts

@@ -18,7 +18,6 @@ mock.module("../util/platform.js", () => ({
   getWorkspaceHooksDir: () => join(TEST_DIR, "hooks"),
   getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
   ensureDataDir: () => {},
-  getSocketPath: () => join(TEST_DIR, "vellum.sock"),
   getPidPath: () => join(TEST_DIR, "vellum.pid"),
   getDbPath: () => join(TEST_DIR, "data", "assistant.db"),
   getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
@@ -85,17 +84,6 @@ const taskListAddDef = tasksToolsJson.tools.find(
   (t: { name: string }) => t.name === "task_list_add",
 );
 
-// Load reminder_create description from the bundled skill TOOLS.json
-const reminderToolsJson = JSON.parse(
-  readFileSync(
-    join(import.meta.dirname, "../config/bundled-skills/reminder/TOOLS.json"),
-    "utf-8",
-  ),
-);
-const reminderCreateDef = reminderToolsJson.tools.find(
-  (t: { name: string }) => t.name === "reminder_create",
-);
-
 // Load schedule_create description from the bundled skill TOOLS.json
 const scheduleToolsJson = JSON.parse(
   readFileSync(
@@ -111,7 +99,7 @@ const scheduleCreateDef = scheduleToolsJson.tools.find(
 // 1. System prompt: buildTaskScheduleReminderRoutingSection
 // =====================================================================
 
-describe("Task/Schedule/Reminder routing section in system prompt", () => {
+describe("Task/Schedule routing section in system prompt", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
   });
@@ -125,15 +113,14 @@ describe("Task/Schedule/Reminder routing section in system prompt", () => {
   test("system prompt includes the routing section heading", () => {
     const prompt = buildSystemPrompt();
     expect(prompt).toContain(
-      "## Tool Routing: Tasks vs Schedules vs Reminders vs Notifications",
+      "## Tool Routing: Tasks vs Schedules vs Notifications",
     );
   });
 
-  test("routing section lists all four tools in the summary table", () => {
+  test("routing section lists all three tools in the summary table", () => {
     const prompt = buildSystemPrompt();
     expect(prompt).toContain("`task_list_add`");
     expect(prompt).toContain("`schedule_create`");
-    expect(prompt).toContain("`reminder_create`");
     expect(prompt).toContain("`send_notification`");
   });
 
@@ -168,7 +155,7 @@ describe("Task/Schedule/Reminder routing section in system prompt", () => {
   test("routing section is present in the system prompt", () => {
     const prompt = buildSystemPrompt();
     const taskRoutingIdx = prompt.indexOf(
-      "## Tool Routing: Tasks vs Schedules vs Reminders vs Notifications",
+      "## Tool Routing: Tasks vs Schedules vs Notifications",
     );
     expect(taskRoutingIdx).toBeGreaterThanOrEqual(0);
   });
@@ -231,44 +218,18 @@ describe("schedule_create tool description", () => {
   });
 });
 
-describe("reminder tool description", () => {
-  test("mentions time-based reminders", () => {
-    expect(reminderCreateDef.description).toContain("time-based reminder");
-  });
-
-  test("scopes to time-triggered notifications only", () => {
-    expect(reminderCreateDef.description).toContain(
-      "ONLY when the user wants a time-triggered notification",
-    );
-  });
-
-  test('warns against using for "add to my tasks" requests', () => {
-    expect(reminderCreateDef.description).toContain(
-      'Do NOT use this for "add to my tasks"',
-    );
-  });
-
-  test("redirects to task_list_add for task queue items", () => {
-    expect(reminderCreateDef.description).toContain("task_list_add");
-  });
-});
-
 // =====================================================================
-// 3. Cross-tool consistency: all three tools agree on routing boundaries
+// 3. Cross-tool consistency: schedule and task tools agree on routing boundaries
 // =====================================================================
 
 describe("cross-tool routing consistency", () => {
-  test("all three tools reference task_list_add as the task-queue tool", () => {
-    // task_list_add is the canonical name in all three descriptions
+  test("both tools reference task_list_add as the task-queue tool", () => {
     expect(taskListAddDef.name).toBe("task_list_add");
     expect(scheduleCreateDef.description).toContain("task_list_add");
-    expect(reminderCreateDef.description).toContain("task_list_add");
   });
 
-  test('schedule_create and reminder both reject "add to my queue" usage', () => {
-    // Both should redirect away from task-queue requests
+  test('schedule_create rejects "add to my queue" usage', () => {
     expect(scheduleCreateDef.description).toContain("add to my queue");
-    expect(reminderCreateDef.description).toContain("add to my queue");
   });
 });
 

package/src/__tests__/invite-redemption-service.test.ts

@@ -10,7 +10,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/invite-routes-http.test.ts

@@ -10,7 +10,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/llm-usage-store.test.ts

@@ -10,7 +10,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/managed-avatar-client.test.ts

@@ -1,5 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { createHash } from "crypto";
+
 // ---------------------------------------------------------------------------
 // Mock dependencies — must be before importing the module under test
 // ---------------------------------------------------------------------------
@@ -40,10 +42,12 @@ let fetchResponse: {
   ok: boolean;
   status: number;
   json: () => Promise<unknown>;
+  text: () => Promise<string>;
 } = {
   ok: true,
   status: 200,
   json: async () => ({}),
+  text: async () => "",
 };
 
 globalThis.fetch = (async (url: string, init: RequestInit) => {
@@ -56,6 +60,7 @@ import {
   AVATAR_MAX_DECODED_BYTES,
   AVATAR_PROMPT_MAX_LENGTH,
   ManagedAvatarError,
+  VERTEX_IMAGE_DEFAULT_MODEL,
 } from "../media/avatar-types.js";
 import {
   generateManagedAvatar,
@@ -66,18 +71,16 @@ import {
 // Helpers
 // ---------------------------------------------------------------------------
 
+const SMALL_PNG_BASE64 = "iVBORw0KGgo=";
+
 function successResponse() {
   return {
-    image: {
-      mime_type: "image/png",
-      data_base64: "iVBORw0KGgo=",
-      bytes: 1024,
-      sha256: "abc123",
-    },
-    usage: { billable: true, class_name: "avatar" },
-    generation_source: "managed",
-    profile: "default",
-    correlation_id: "test-corr-id",
+    predictions: [
+      {
+        bytesBase64Encoded: SMALL_PNG_BASE64,
+        mimeType: "image/png",
+      },
+    ],
   };
 }
 
@@ -94,6 +97,7 @@ beforeEach(() => {
     ok: true,
     status: 200,
     json: async () => successResponse(),
+    text: async () => JSON.stringify(successResponse()),
   };
 });
 
@@ -102,9 +106,57 @@ describe("generateManagedAvatar", () => {
     const result = await generateManagedAvatar("a friendly robot avatar");
 
     expect(result.image.mime_type).toBe("image/png");
-    expect(result.image.data_base64).toBe("iVBORw0KGgo=");
-    expect(result.image.bytes).toBe(1024);
-    expect(result.generation_source).toBe("managed");
+    expect(result.image.data_base64).toBe(SMALL_PNG_BASE64);
+    // bytes is computed from base64 length, not from the server response
+    const padding = SMALL_PNG_BASE64.endsWith("==")
+      ? 2
+      : SMALL_PNG_BASE64.endsWith("=")
+        ? 1
+        : 0;
+    const expectedBytes =
+      Math.ceil((SMALL_PNG_BASE64.length * 3) / 4) - padding;
+    expect(result.image.bytes).toBe(expectedBytes);
+    const expectedSha256 = createHash("sha256")
+      .update(Buffer.from(SMALL_PNG_BASE64, "base64"))
+      .digest("hex");
+    expect(result.image.sha256).toBe(expectedSha256);
+    expect(result.correlation_id).toBeDefined();
+  });
+
+  test("fetch URL matches runtime proxy Vertex endpoint with default model", async () => {
+    await generateManagedAvatar("test prompt");
+
+    expect(lastFetchArgs).not.toBeNull();
+    const url = lastFetchArgs![0];
+    expect(url).toBe(
+      `https://platform.vellum.ai/v1/runtime-proxy/vertex/v1/models/${VERTEX_IMAGE_DEFAULT_MODEL}:predict`,
+    );
+  });
+
+  test("custom model is used in the URL path", async () => {
+    const customModel = "imagen-3.0-fast-generate-001";
+    await generateManagedAvatar("test prompt", { model: customModel });
+
+    expect(lastFetchArgs).not.toBeNull();
+    const url = lastFetchArgs![0];
+    expect(url).toBe(
+      `https://platform.vellum.ai/v1/runtime-proxy/vertex/v1/models/${customModel}:predict`,
+    );
+  });
+
+  test("request body uses Vertex Imagen format", async () => {
+    await generateManagedAvatar("a cool robot");
+
+    expect(lastFetchArgs).not.toBeNull();
+    const body = JSON.parse(lastFetchArgs![1].body as string);
+    expect(body).toEqual({
+      instances: [{ prompt: "a cool robot" }],
+      parameters: {
+        sampleCount: 1,
+        aspectRatio: "1:1",
+        outputOptions: { mimeType: "image/png" },
+      },
+    });
   });
 
   test("prompt exceeding max length throws ManagedAvatarError with code validation_error", async () => {
@@ -125,13 +177,8 @@ describe("generateManagedAvatar", () => {
     fetchResponse = {
       ok: false,
       status: 429,
-      json: async () => ({
-        code: "rate_limit",
-        subcode: "too_many_requests",
-        detail: "Rate limit exceeded",
-        retryable: true,
-        correlation_id: "corr-429",
-      }),
+      json: async () => ({}),
+      text: async () => "Rate limit exceeded",
     };
 
     try {
@@ -142,20 +189,17 @@ describe("generateManagedAvatar", () => {
       const avatarErr = err as ManagedAvatarError;
       expect(avatarErr.retryable).toBe(true);
       expect(avatarErr.statusCode).toBe(429);
+      expect(avatarErr.code).toBe("upstream_error");
+      expect(avatarErr.subcode).toBe("http_error");
     }
   });
 
-  test("HTTP 500 response throws ManagedAvatarError with upstream error details", async () => {
+  test("HTTP 500 response throws retryable ManagedAvatarError", async () => {
     fetchResponse = {
       ok: false,
       status: 500,
-      json: async () => ({
-        code: "internal_error",
-        subcode: "server_fault",
-        detail: "Internal server error",
-        retryable: true,
-        correlation_id: "corr-500",
-      }),
+      json: async () => ({}),
+      text: async () => "Internal server error",
     };
 
     try {
@@ -164,20 +208,19 @@ describe("generateManagedAvatar", () => {
     } catch (err) {
       expect(err).toBeInstanceOf(ManagedAvatarError);
       const avatarErr = err as ManagedAvatarError;
-      expect(avatarErr.code).toBe("internal_error");
-      expect(avatarErr.subcode).toBe("server_fault");
+      expect(avatarErr.code).toBe("upstream_error");
+      expect(avatarErr.subcode).toBe("http_error");
       expect(avatarErr.statusCode).toBe(500);
+      expect(avatarErr.retryable).toBe(true);
     }
   });
 
-  test("response with disallowed MIME type throws validation error", async () => {
+  test("HTTP 400 response throws non-retryable ManagedAvatarError", async () => {
     fetchResponse = {
-      ok: true,
-      status: 200,
-      json: async () => ({
-        ...successResponse(),
-        image: { ...successResponse().image, mime_type: "image/gif" },
-      }),
+      ok: false,
+      status: 400,
+      json: async () => ({}),
+      text: async () => "Model not allowed on this platform",
     };
 
     try {
@@ -186,22 +229,26 @@ describe("generateManagedAvatar", () => {
     } catch (err) {
       expect(err).toBeInstanceOf(ManagedAvatarError);
       const avatarErr = err as ManagedAvatarError;
-      expect(avatarErr.code).toBe("validation_error");
-      expect(avatarErr.subcode).toBe("disallowed_mime_type");
+      expect(avatarErr.code).toBe("upstream_error");
+      expect(avatarErr.subcode).toBe("http_error");
+      expect(avatarErr.statusCode).toBe(400);
+      expect(avatarErr.retryable).toBe(false);
     }
   });
 
-  test("response with oversized bytes throws validation error", async () => {
+  test("response with disallowed MIME type throws validation error", async () => {
     fetchResponse = {
       ok: true,
       status: 200,
       json: async () => ({
-        ...successResponse(),
-        image: {
-          ...successResponse().image,
-          bytes: AVATAR_MAX_DECODED_BYTES + 1,
-        },
+        predictions: [
+          {
+            bytesBase64Encoded: SMALL_PNG_BASE64,
+            mimeType: "image/gif",
+          },
+        ],
       }),
+      text: async () => "",
     };
 
     try {
@@ -211,13 +258,11 @@ describe("generateManagedAvatar", () => {
       expect(err).toBeInstanceOf(ManagedAvatarError);
       const avatarErr = err as ManagedAvatarError;
       expect(avatarErr.code).toBe("validation_error");
-      expect(avatarErr.subcode).toBe("oversized_image");
+      expect(avatarErr.subcode).toBe("disallowed_mime_type");
     }
   });
 
-  test("response with oversized base64 estimated decoded size throws validation error", async () => {
-    // Create a base64 string whose estimated decoded size exceeds the limit,
-    // even though the server-reported bytes field is under the limit
+  test("response with oversized image throws validation error", async () => {
     const oversizedBase64 = "A".repeat(
       Math.ceil(((AVATAR_MAX_DECODED_BYTES + 100) * 4) / 3),
     );
@@ -225,13 +270,14 @@ describe("generateManagedAvatar", () => {
       ok: true,
       status: 200,
       json: async () => ({
-        ...successResponse(),
-        image: {
-          ...successResponse().image,
-          data_base64: oversizedBase64,
-          bytes: 1024,
-        },
+        predictions: [
+          {
+            bytesBase64Encoded: oversizedBase64,
+            mimeType: "image/png",
+          },
+        ],
       }),
+      text: async () => "",
     };
 
     try {

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

@@ -32,7 +32,6 @@ mock.module("../util/platform.js", () => ({
   getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
   getDataDir: () => TEST_DIR,
   ensureDataDir: () => {},
-  getSocketPath: () => join(TEST_DIR, "vellum.sock"),
   getPidPath: () => join(TEST_DIR, "vellum.pid"),
   getDbPath: () => join(TEST_DIR, "data", "assistant.db"),
   getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
@@ -72,19 +71,11 @@ mock.module("../tools/terminal/sandbox.js", () => ({
 
 import { loadSkillCatalog } from "../config/skills.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
-import { DeleteManagedSkillTool } from "../tools/skills/delete-managed.js";
+import { executeDeleteManagedSkill } from "../tools/skills/delete-managed.js";
 import { SkillLoadTool } from "../tools/skills/load.js";
-import { ScaffoldManagedSkillTool } from "../tools/skills/scaffold-managed.js";
+import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
-const scaffoldTool = new (ScaffoldManagedSkillTool as any)() as InstanceType<
-  typeof ScaffoldManagedSkillTool
->;
-
-const deleteTool = new (DeleteManagedSkillTool as any)() as InstanceType<
-  typeof DeleteManagedSkillTool
->;
-
 function makeContext(): ToolContext {
   return {
     workingDir: "/tmp",
@@ -106,7 +97,7 @@ afterEach(() => {
 describe("managed skill lifecycle: scaffold → catalog → prompt → delete", () => {
   test("full lifecycle: create skill, verify in catalog and prompt, then delete", async () => {
     // Step 1: Scaffold a managed skill
-    const scaffoldResult = await scaffoldTool.execute(
+    const scaffoldResult = await executeScaffoldManagedSkill(
       {
         skill_id: "lifecycle-test",
         name: "Lifecycle Test",
@@ -143,7 +134,7 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     expect(prompt).toContain("## Dynamic Skill Authoring Workflow");
 
     // Step 5: Delete the skill
-    const deleteResult = await deleteTool.execute(
+    const deleteResult = await executeDeleteManagedSkill(
       {
         skill_id: "lifecycle-test",
       },
@@ -173,7 +164,7 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     const ctx = makeContext();
 
     // Create initial skill
-    await scaffoldTool.execute(
+    await executeScaffoldManagedSkill(
       {
         skill_id: "overwrite-test",
         name: "V1",
@@ -184,7 +175,7 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     );
 
     // Overwrite with updated content
-    const result = await scaffoldTool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "overwrite-test",
         name: "V2",
@@ -215,7 +206,7 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
   });
 
   test("delete non-existent skill returns error", async () => {
-    const result = await deleteTool.execute(
+    const result = await executeDeleteManagedSkill(
       {
         skill_id: "does-not-exist",
       },
@@ -233,7 +224,7 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     >;
 
     // Step 1: Scaffold a skill directly
-    const scaffoldResult = await scaffoldTool.execute(
+    const scaffoldResult = await executeScaffoldManagedSkill(
       {
         skill_id: "chain-test",
         name: "Chain Test",
@@ -262,7 +253,7 @@ describe("managed skill lifecycle: scaffold → catalog → prompt → delete",
     expect(loadContent).toContain("echo chain-test-ok");
 
     // Step 3: Clean up
-    const deleteResult = await deleteTool.execute(
+    const deleteResult = await executeDeleteManagedSkill(
       { skill_id: "chain-test" },
       ctx,
     );

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

@@ -20,6 +20,8 @@ import {
   test,
 } from "bun:test";
 
+import { parse as parseYaml } from "yaml";
+
 let TEST_DIR = "";
 
 mock.module("../util/platform.js", () => ({
@@ -104,11 +106,9 @@ describe("buildSkillMarkdown", () => {
       emoji: "🧪",
     });
     expect(result).toContain("metadata:");
-    const metadataLine = result
-      .split("\n")
-      .find((l) => l.startsWith("metadata:"));
-    const json = JSON.parse(metadataLine!.slice("metadata: ".length));
-    expect(json.vellum.emoji).toBe("🧪");
+    const fmMatch = result.match(/^---\n([\s\S]*?)\n---/);
+    const parsed = parseYaml(fmMatch![1]);
+    expect(parsed.metadata.vellum.emoji).toBe("🧪");
   });
 
   test("includes user-invocable=false in metadata.vellum", () => {
@@ -118,11 +118,9 @@ describe("buildSkillMarkdown", () => {
       bodyMarkdown: "Body.",
       userInvocable: false,
     });
-    const metadataLine = result
-      .split("\n")
-      .find((l) => l.startsWith("metadata:"));
-    const json = JSON.parse(metadataLine!.slice("metadata: ".length));
-    expect(json.vellum["user-invocable"]).toBe(false);
+    const fmMatch = result.match(/^---\n([\s\S]*?)\n---/);
+    const parsed = parseYaml(fmMatch![1]);
+    expect(parsed.metadata.vellum["user-invocable"]).toBe(false);
   });
 
   test("includes disable-model-invocation in metadata.vellum", () => {
@@ -132,11 +130,9 @@ describe("buildSkillMarkdown", () => {
       bodyMarkdown: "Body.",
       disableModelInvocation: true,
     });
-    const metadataLine = result
-      .split("\n")
-      .find((l) => l.startsWith("metadata:"));
-    const json = JSON.parse(metadataLine!.slice("metadata: ".length));
-    expect(json.vellum["disable-model-invocation"]).toBe(true);
+    const fmMatch = result.match(/^---\n([\s\S]*?)\n---/);
+    const parsed = parseYaml(fmMatch![1]);
+    expect(parsed.metadata.vellum["disable-model-invocation"]).toBe(true);
   });
 
   test("escapes double quotes in name and description", () => {
@@ -201,18 +197,16 @@ describe("buildSkillMarkdown", () => {
     expect(skill!.name).toBe("path\\name");
   });
 
-  test("includes field emits JSON array in metadata.vellum", () => {
+  test("includes field emits YAML list in metadata.vellum", () => {
     const result = buildSkillMarkdown({
       name: "Parent",
       description: "Has children",
       bodyMarkdown: "Body.",
       includes: ["child-a", "child-b"],
     });
-    const metadataLine = result
-      .split("\n")
-      .find((l) => l.startsWith("metadata:"));
-    const json = JSON.parse(metadataLine!.slice("metadata: ".length));
-    expect(json.vellum.includes).toEqual(["child-a", "child-b"]);
+    const fmMatch = result.match(/^---\n([\s\S]*?)\n---/);
+    const parsed = parseYaml(fmMatch![1]);
+    expect(parsed.metadata.vellum.includes).toEqual(["child-a", "child-b"]);
   });
 
   test("omits metadata when no vellum fields provided", () => {
@@ -788,3 +782,82 @@ describe("validateManagedSkillId edge cases", () => {
     expect(validateManagedSkillId("a1.b2-c3_d4")).toBeNull();
   });
 });
+
+describe("YAML metadata round-trip", () => {
+  test("all vellum fields round-trip through write and load", () => {
+    // Create a managed skill with every vellum metadata field populated
+    createManagedSkill({
+      id: "yaml-roundtrip-all",
+      name: "Full Metadata Skill",
+      description: "Tests all vellum fields round-trip correctly",
+      bodyMarkdown: "Full metadata body.",
+      emoji: "🔬",
+      userInvocable: false,
+      disableModelInvocation: true,
+      includes: ["child-a", "child-b"],
+    });
+
+    // Load it back via loadSkillCatalog
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const skill = catalog.find((s) => s.id === "yaml-roundtrip-all");
+    expect(skill).toBeDefined();
+
+    // Verify all fields are correctly preserved
+    expect(skill!.name).toBe("Full Metadata Skill");
+    expect(skill!.description).toBe(
+      "Tests all vellum fields round-trip correctly",
+    );
+    expect(skill!.emoji).toBe("🔬");
+    expect(skill!.userInvocable).toBe(false);
+    expect(skill!.disableModelInvocation).toBe(true);
+    expect(skill!.includes).toEqual(["child-a", "child-b"]);
+  });
+
+  test("hand-authored YAML nested metadata parses correctly", () => {
+    // Manually write a SKILL.md with YAML-style nested metadata matching
+    // the format used in skills/ directory (bundled skills format)
+    const skillDir = join(TEST_DIR, "skills", "yaml-nested-test");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(
+      join(skillDir, "SKILL.md"),
+      [
+        "---",
+        "name: yaml-nested-skill",
+        "description: Hand-authored YAML nested metadata test",
+        'compatibility: "Designed for Vellum personal assistants"',
+        "metadata:",
+        '  emoji: "🧪"',
+        "  vellum:",
+        '    display-name: "YAML Nested Skill"',
+        "    user-invocable: false",
+        "    disable-model-invocation: true",
+        "    os:",
+        `      - "${process.platform}"`,
+        "    includes:",
+        '      - "child-a"',
+        '      - "child-b"',
+        "---",
+        "",
+        "Hand-authored body content.",
+        "",
+      ].join("\n"),
+    );
+
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const skill = catalog.find((s) => s.id === "yaml-nested-test");
+    expect(skill).toBeDefined();
+
+    // Verify all nested vellum fields are correctly parsed
+    expect(skill!.name).toBe("yaml-nested-skill");
+    expect(skill!.description).toBe("Hand-authored YAML nested metadata test");
+    expect(skill!.displayName).toBe("YAML Nested Skill");
+    expect(skill!.userInvocable).toBe(false);
+    expect(skill!.disableModelInvocation).toBe(true);
+    expect(skill!.emoji).toBe("🧪");
+    expect(skill!.includes).toEqual(["child-a", "child-b"]);
+
+    // Verify os is parsed into metadata
+    expect(skill!.metadata).toBeDefined();
+    expect(skill!.metadata!.os).toEqual([process.platform]);
+  });
+});

package/src/__tests__/media-reuse-story.e2e.test.ts

@@ -32,7 +32,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),