@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/send-endpoint-busy.test.ts

@@ -136,13 +136,9 @@ function makeCompletingConversation(): Conversation {
   const messages: unknown[] = [];
   return {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      requestId?: string,
-    ) => {
+    persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
-      return requestId ?? "msg-1";
+      return { id: options.requestId ?? "msg-1", deduplicated: false };
     },
     memoryPolicy: {
       scopeId: "default",
@@ -188,18 +184,14 @@ function makeHangingConversation(): Conversation {
   const messages: unknown[] = [];
   const enqueuedMessages: Array<{
     content: string;
-    onEvent: (msg: ServerMessage) => void;
-    requestId: string;
+    onEvent?: (msg: ServerMessage) => void;
+    requestId?: string;
   }> = [];
   return {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      requestId?: string,
-    ) => {
+    persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
-      return requestId ?? "msg-1";
+      return { id: options.requestId ?? "msg-1", deduplicated: false };
     },
     memoryPolicy: {
       scopeId: "default",
@@ -223,14 +215,20 @@ function makeHangingConversation(): Conversation {
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
     getQueueDepth: () => enqueuedMessages.length,
-    enqueueMessage: (
-      content: string,
-      _attachments: unknown[],
-      onEvent: (msg: ServerMessage) => void,
-      requestId: string,
-    ) => {
-      enqueuedMessages.push({ content, onEvent, requestId });
-      return { queued: true, requestId };
+    enqueueMessage: (options: {
+      content: string;
+      onEvent?: (msg: ServerMessage) => void;
+      requestId?: string;
+    }) => {
+      enqueuedMessages.push({
+        content: options.content,
+        onEvent: options.onEvent,
+        requestId: options.requestId,
+      });
+      return {
+        queued: true,
+        requestId: options.requestId ?? "hanging-req",
+      };
     },
     runAgentLoop: async () => {
       // Hang forever
@@ -259,14 +257,9 @@ function makePendingApprovalConversation(
   const messages: unknown[] = [];
   const runAgentLoopMock = mock(async () => {});
   const enqueueMessageMock = mock(
-    (
-      _content: string,
-      _attachments: unknown[],
-      _onEvent: (msg: ServerMessage) => void,
-      queuedRequestId: string,
-    ) => ({
+    (options: { content: string; requestId?: string }) => ({
       queued: true,
-      requestId: queuedRequestId,
+      requestId: options.requestId ?? "queued-req",
     }),
   );
   const denyAllPendingConfirmationsMock = mock(() => {
@@ -278,11 +271,10 @@ function makePendingApprovalConversation(
 
   const conversation = {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      reqId?: string,
-    ) => reqId ?? "msg-1",
+    persistUserMessage: (options: { requestId?: string }) => ({
+      id: options.requestId ?? "msg-1",
+      deduplicated: false,
+    }),
     memoryPolicy: {
       scopeId: "default",
       includeDefaultFallback: false,
@@ -895,7 +887,7 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
     await stopServer();
   });
 
-  test("accepts message when conversationKey is omitted (defaults to stable channel key)", async () => {
+  test("accepts message when conversationKey is omitted (vellum channel mints fresh)", async () => {
     await startServer(() => makeCompletingConversation());
 
     const res = await fetch(messagesUrl(), {
@@ -908,14 +900,24 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       }),
     });
     expect(res.status).toBe(202);
+    const body = (await res.json()) as {
+      accepted: boolean;
+      conversationId: string;
+    };
+    expect(body.accepted).toBe(true);
+    expect(body.conversationId).toBeTruthy();
+
+    // The vellum channel never falls through to the shared
+    // `default:vellum:<interface>` thread: each empty-handed send mints
+    // a fresh conversation so the first-message id surfaces to the client.
+    expect(getConversationByKey("default:vellum:macos")).toBeNull();
 
     await stopServer();
   });
 
-  test("two calls without conversationKey use the same conversation", async () => {
+  test("two empty-handed vellum sends each mint distinct conversations", async () => {
     await startServer(() => makeCompletingConversation());
 
-    // First message — no conversationKey
     const res1 = await fetch(messagesUrl(), {
       method: "POST",
       headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
@@ -926,8 +928,8 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       }),
     });
     expect(res1.status).toBe(202);
+    const body1 = (await res1.json()) as { conversationId: string };
 
-    // Second message — same channel/interface, still no conversationKey
     const res2 = await fetch(messagesUrl(), {
       method: "POST",
       headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
@@ -938,12 +940,49 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       }),
     });
     expect(res2.status).toBe(202);
+    const body2 = (await res2.json()) as { conversationId: string };
+
+    expect(body1.conversationId).toBeTruthy();
+    expect(body2.conversationId).toBeTruthy();
+    expect(body1.conversationId).not.toBe(body2.conversationId);
+
+    await stopServer();
+  });
+
+  test("two empty-handed phone sends share the default channel thread", async () => {
+    await startServer(() => makeCompletingConversation());
+
+    const res1 = await fetch(messagesUrl(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+      body: JSON.stringify({
+        content: "First",
+        sourceChannel: "phone",
+        interface: "phone",
+      }),
+    });
+    expect(res1.status).toBe(202);
+    const body1 = (await res1.json()) as { conversationId: string };
+
+    const res2 = await fetch(messagesUrl(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+      body: JSON.stringify({
+        content: "Second",
+        sourceChannel: "phone",
+        interface: "phone",
+      }),
+    });
+    expect(res2.status).toBe(202);
+    const body2 = (await res2.json()) as { conversationId: string };
 
-    // Both should have resolved to the same default conversation key
-    // ("default:vellum:macos"), which maps to the same conversationId.
-    const mapping = getConversationByKey("default:vellum:macos");
+    // Non-vellum channels keep the legacy `default:<channel>:<interface>`
+    // co-location so repeated inbound messages from the same external
+    // channel/interface land on a single thread.
+    expect(body1.conversationId).toBe(body2.conversationId);
+    const mapping = getConversationByKey("default:phone:phone");
     expect(mapping).not.toBeNull();
-    expect(mapping!.conversationId).toBeTruthy();
+    expect(mapping!.conversationId).toBe(body1.conversationId);
 
     await stopServer();
   });

package/src/__tests__/server-history-render.test.ts

@@ -578,7 +578,10 @@ describe("getAttachmentsForMessage", () => {
     db.run("DELETE FROM conversations");
   });
 
-  async function createMessage(role: string, content: string): Promise<string> {
+  async function createMessage(
+    role: "user" | "assistant" | "system",
+    content: string,
+  ): Promise<string> {
     const conv = createConversation("test");
     const msg = await addMessage(conv.id, role, content);
     return msg.id;

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -7,17 +7,15 @@
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import {
-  _setOverridesForTesting,
-  isAssistantFeatureFlagEnabled,
-} from "../config/assistant-feature-flags.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 beforeEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 import type { AssistantConfig } from "../config/schema.js";
 import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
@@ -150,7 +148,7 @@ describe("frontmatter feature-flag integration", () => {
   });
 
   test("resolveSkillStates includes skill with featureFlag when flag is ON", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "email-channel": true,
     });
     const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG)!;
@@ -174,7 +172,7 @@ describe("frontmatter feature-flag integration", () => {
   test("resolveSkillStates never gates skill without featureFlag", () => {
     const skill = buildSkillSummary("plain-skill", SKILL_MD_WITHOUT_FLAG)!;
     // Even with an explicit false override for this skill ID, it should pass through
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "plain-skill": false,
     });
     const config = makeConfig();
@@ -210,7 +208,7 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedDefault.length).toBe(0);
 
     // Step 6: With override enabled, skill passes through
-    _setOverridesForTesting({ [key!]: true });
+    setOverridesForTesting({ [key!]: true });
     const configOn = makeConfig();
     expect(isAssistantFeatureFlagEnabled(key!, configOn)).toBe(true);
 
@@ -219,7 +217,7 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedOn[0].summary.id).toBe("email-setup");
 
     // Step 7: With override disabled, skill is filtered out
-    _setOverridesForTesting({ [key!]: false });
+    setOverridesForTesting({ [key!]: false });
     const configOff = makeConfig();
     expect(isAssistantFeatureFlagEnabled(key!, configOff)).toBe(false);
 

package/src/__tests__/skill-feature-flags.test.ts

@@ -1,19 +1,17 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import {
-  _setOverridesForTesting,
-  isAssistantFeatureFlagEnabled,
-} from "../config/assistant-feature-flags.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
 import type { SkillSummary } from "../config/skills.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 beforeEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 const DECLARED_FLAG_ID = "email-channel";
@@ -103,7 +101,7 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   });
 
   test("returns true when skill key is explicitly true", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
     const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled(
@@ -114,7 +112,7 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   });
 
   test("returns false when skill key is explicitly false", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled(
@@ -136,7 +134,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
   });
 
   test("file-based override overrides registry default", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const config = makeConfig();
     expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
       false,
@@ -152,7 +150,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
   });
 
   test("respects persisted overrides for undeclared keys", () => {
-    _setOverridesForTesting({ "some-undeclared-flag": false });
+    setOverridesForTesting({ "some-undeclared-flag": false });
     const config = makeConfig();
     expect(isAssistantFeatureFlagEnabled("some-undeclared-flag", config)).toBe(
       false,
@@ -166,7 +164,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
 describe("resolveSkillStates with feature flags", () => {
   test("flag OFF skill does not appear in resolved list", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       [DECLARED_FLAG_KEY]: false,
       [ENABLED_UNDECLARED_FLAG_KEY]: true,
     });
@@ -188,7 +186,7 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("flag ON skill appears normally", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       [DECLARED_FLAG_KEY]: true,
       [ENABLED_UNDECLARED_FLAG_KEY]: true,
     });
@@ -230,7 +228,7 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("feature flag OFF takes precedence over user-enabled config entry", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig({
       skills: {
@@ -256,7 +254,7 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("multiple skills with mixed flags — persisted overrides respected", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       [DECLARED_FLAG_KEY]: false,
       [ENABLED_UNDECLARED_FLAG_KEY]: true,
       deploy: false,
@@ -296,7 +294,7 @@ describe("resolveSkillStates with frontmatter featureFlag", () => {
   });
 
   test("skill with featureFlag is included when override enables it", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig();
 
@@ -320,7 +318,7 @@ describe("resolveSkillStates with frontmatter featureFlag", () => {
     // This proves the implicit skillId→flag mapping is gone:
     // setting feature_flags.my-skill.enabled = false has no effect
     // when the skill itself does not declare a featureFlag.
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "my-skill": false,
     });
     const catalog = [makeSkill("my-skill")];

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -6,7 +6,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
@@ -89,11 +89,11 @@ describe("skill_load feature flag enforcement", () => {
   beforeEach(() => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
     currentConfig = {};
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   afterEach(() => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   test("returns deterministic error for flag OFF skill", async () => {
@@ -104,7 +104,7 @@ describe("skill_load feature flag enforcement", () => {
       "Use the feature.",
     );
 
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
@@ -121,7 +121,7 @@ describe("skill_load feature flag enforcement", () => {
       "Use the feature.",
     );
 
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -45,6 +45,10 @@ mock.module("../config/skill-state.js", () => ({
 
 // Mock assistant-feature-flags to avoid loading the real module (which
 // triggers file I/O and env-registry imports that hang in test context).
+// The seed-state backdoor is the test-only helper module — we mirror
+// production's design: tests reach into `feature-flag-cache.ts` (or its
+// test-helper wrapper) to seed cached overrides, never through the
+// resolver module itself.
 let _mockOverrides: Record<string, boolean> = {};
 mock.module("../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string, _config: unknown): boolean => {
@@ -55,10 +59,12 @@ mock.module("../config/assistant-feature-flags.js", () => ({
   clearFeatureFlagOverridesCache: () => {
     _mockOverrides = {};
   },
-  _setOverridesForTesting: (overrides: Record<string, boolean>) => {
+  getAssistantFeatureFlagDefaults: () => ({}),
+}));
+mock.module("./feature-flag-test-helpers.js", () => ({
+  setOverridesForTesting: (overrides: Record<string, boolean>) => {
     _mockOverrides = { ...overrides };
   },
-  getAssistantFeatureFlagDefaults: () => ({}),
 }));
 
 mock.module("../skills/active-skill-tools.js", () => {
@@ -109,12 +115,13 @@ mock.module("../skills/tool-manifest.js", () => ({
 }));
 
 mock.module("../tools/skills/skill-tool-factory.js", () => ({
+  // Mirrors the real factory: no skillId in/out — ownership is recorded by
+  // the registry at `registerSkillTools(skillId, tools)` time.
   createSkillToolsFromManifest: (
     entries: SkillToolManifest["tools"],
-    skillId: string,
     _skillDir: string,
-    versionHash: string,
-    bundled?: boolean,
+    _versionHash: string,
+    _bundled?: boolean,
   ): Tool[] => {
     return entries.map((entry) => ({
       name: entry.name,
@@ -122,10 +129,6 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
       executionTarget: "sandbox" as const,
-      origin: "skill" as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled ?? undefined,
       input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     }));
@@ -133,18 +136,14 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
 }));
 
 mock.module("../tools/registry.js", () => ({
-  registerSkillTools: (tools: Tool[]) => {
-    const skillIds = new Set<string>();
-    for (const tool of tools) {
-      const skillId = tool.ownerSkillId!;
-      skillIds.add(skillId);
-      const existing = mockRegisteredTools.get(skillId) ?? [];
-      existing.push(tool);
-      mockRegisteredTools.set(skillId, existing);
-    }
-    for (const id of skillIds) {
-      mockSkillRefCount.set(id, (mockSkillRefCount.get(id) ?? 0) + 1);
-    }
+  // Matches the new signature: `registerSkillTools(skillId, tools)`. The
+  // skillId comes from the caller (conversation-skill-tools) and is the
+  // sole source of truth for ownership.
+  registerSkillTools: (skillId: string, tools: Tool[]) => {
+    const existing = mockRegisteredTools.get(skillId) ?? [];
+    existing.push(...tools);
+    mockRegisteredTools.set(skillId, existing);
+    mockSkillRefCount.set(skillId, (mockSkillRefCount.get(skillId) ?? 0) + 1);
     return tools;
   },
   unregisterSkillTools: (skillId: string) => {
@@ -166,6 +165,23 @@ mock.module("../tools/registry.js", () => ({
     }
     return found;
   },
+  // Mirrors the registry's `ownersByName` accessor: derives the owning
+  // skillId from `mockRegisteredTools` keying so the production
+  // `getToolOwner(name)` call in `conversation-skill-tools.ts` resolves to
+  // the same shape the real registry would return.
+  getToolOwner: (
+    name: string,
+  ): { kind: "skill" | "plugin" | "mcp"; id: string } | undefined => {
+    let ownerSkillId: string | undefined;
+    for (const [skillId, tools] of mockRegisteredTools.entries()) {
+      for (const tool of tools) {
+        if (tool.name === name) ownerSkillId = skillId;
+      }
+    }
+    return ownerSkillId === undefined
+      ? undefined
+      : { kind: "skill", id: ownerSkillId };
+  },
   getSkillToolNames: () => {
     const names: string[] = [];
     for (const tools of mockRegisteredTools.values()) {
@@ -212,10 +228,8 @@ mock.module("../util/logger.js", () => ({
 
 const { projectSkillTools, resetSkillToolProjection } =
   await import("../daemon/conversation-skill-tools.js");
-const { _setOverridesForTesting } =
-  (await import("../config/assistant-feature-flags.js")) as {
-    _setOverridesForTesting: (o: Record<string, boolean>) => void;
-  };
+const { setOverridesForTesting } =
+  await import("./feature-flag-test-helpers.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -289,12 +303,12 @@ describe("projectSkillTools feature flag enforcement", () => {
     mockUnregisteredSkillIds = [];
     mockSkillRefCount = new Map();
     currentConfig = {};
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
     resetSkillToolProjection();
   });
 
   afterEach(() => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   test("no skill tools projected for flag OFF skill even with old markers", () => {
@@ -308,7 +322,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Feature flag is OFF — use protected directory override
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,
@@ -329,7 +343,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Feature flag is ON — use protected directory override
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,
@@ -420,7 +434,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Declared skill is OFF; plain-skill has no featureFlag so remains ON.
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,

package/src/__tests__/skill-projection.benchmark.test.ts

@@ -102,18 +102,15 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
     entries: Array<{ name: string; description: string; input_schema: object }>,
     skillId: string,
     _skillDir: string,
-    versionHash: string,
-    bundled?: boolean,
+    _versionHash: string,
+    _bundled?: boolean,
   ) =>
     entries.map((e) => ({
       name: e.name,
       description: e.description,
       category: "skill",
       defaultRiskLevel: "low",
-      origin: "skill" as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled,
+      owner: { kind: "skill" as const, id: skillId },
       input_schema: e.input_schema,
       execute: async () => ({ content: "", isError: false }),
     })),
@@ -166,7 +163,8 @@ mock.module("../tools/registry.js", () => ({
   },
   unregisterSkillTools: (skillId: string) => {
     for (const [name, t] of benchmarkRegistry) {
-      if ((t as { ownerSkillId?: string }).ownerSkillId === skillId)
+      const owner = (t as { owner?: { kind: string; id: string } }).owner;
+      if (owner?.kind === "skill" && owner.id === skillId)
         benchmarkRegistry.delete(name);
     }
   },