@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/bundled-asset.test.ts

@@ -101,18 +101,18 @@ describe("resolveBundledDir", () => {
       const macosDir = join(tempDir, "Contents", "MacOS");
       const resourcesDir = join(tempDir, "Contents", "Resources");
       mkdirSync(macosDir, { recursive: true });
-      mkdirSync(join(resourcesDir, "compact-prompts"), { recursive: true });
+      mkdirSync(join(resourcesDir, "templates"), { recursive: true });
       // Also create at execDir level
-      mkdirSync(join(macosDir, "compact-prompts"), { recursive: true });
+      mkdirSync(join(macosDir, "templates"), { recursive: true });
 
       process.execPath = join(macosDir, "vellum-daemon");
 
       const result = resolveBundledDir(
-        "/$bunfs/root/src/context/prompts",
-        "..",
-        "compact-prompts",
+        "/$bunfs/root/src/prompts",
+        "templates",
+        "templates",
       );
-      expect(result).toBe(join(resourcesDir, "compact-prompts"));
+      expect(result).toBe(join(resourcesDir, "templates"));
     });
 
     test("works with different bundleName values", () => {

package/src/__tests__/channel-availability-routes.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Tests for `assistant/src/runtime/routes/channel-availability-routes.ts`.
+ *
+ * The handler returns a fixed base list (`slack`, `telegram`, `phone`) and
+ * appends `email` when the platform reports at least one registered email
+ * address for this assistant. Platform failures fall back to base-only.
+ *
+ * Each entry is hydrated with display metadata from `CHANNEL_METADATA`
+ * (label, subtitle, icon, supportsVerification, setupMessages) so clients
+ * never need to carry per-channel switches.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { CHANNEL_METADATA } from "../channels/types.js";
+
+// ---------------------------------------------------------------------------
+// Mock state — flipped per-test
+// ---------------------------------------------------------------------------
+
+let mockPlatformAssistantId: string | null = "assistant-test-id";
+let mockEmailAddressesResponse: {
+  ok: boolean;
+  status: number;
+  body: unknown;
+} = {
+  ok: true,
+  status: 200,
+  body: { count: 0, results: [] },
+};
+let mockFetchThrows = false;
+
+mock.module("../platform/client.js", () => ({
+  VellumPlatformClient: {
+    create: async () => ({
+      platformAssistantId: mockPlatformAssistantId,
+      fetch: async (_path: string) => {
+        if (mockFetchThrows) {
+          throw new Error("platform unreachable");
+        }
+        return {
+          ok: mockEmailAddressesResponse.ok,
+          status: mockEmailAddressesResponse.status,
+          json: async () => mockEmailAddressesResponse.body,
+        };
+      },
+    }),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { ROUTES } from "../runtime/routes/channel-availability-routes.js";
+
+const handler = ROUTES[0]!.handler;
+
+interface ChannelEntry {
+  id: string;
+  label: string;
+  subtitle: string;
+  icon: string;
+  supportsVerification: boolean;
+  setupMessages: { guardian: string; contact: string };
+}
+interface HandlerResult {
+  channels: ChannelEntry[];
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("channels/available", () => {
+  beforeEach(() => {
+    mockPlatformAssistantId = "assistant-test-id";
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { count: 0, results: [] },
+    };
+    mockFetchThrows = false;
+  });
+
+  test("base list only when no email address registered", async () => {
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+    ]);
+  });
+
+  test("appends email when at least one address registered (count field)", async () => {
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { count: 1, results: [{ id: "addr-1", address: "hi@bot" }] },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+      "email",
+    ]);
+  });
+
+  test("appends email when results non-empty even without count field", async () => {
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { results: [{ id: "addr-1", address: "hi@bot" }] },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toContain("email");
+  });
+
+  test("base list only when platform returns non-ok", async () => {
+    mockEmailAddressesResponse = {
+      ok: false,
+      status: 500,
+      body: { detail: "boom" },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+    ]);
+  });
+
+  test("base list only when platform fetch throws (best-effort)", async () => {
+    mockFetchThrows = true;
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+    ]);
+  });
+
+  test("base list only when no platformAssistantId on client", async () => {
+    mockPlatformAssistantId = null;
+
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.map((c) => c.id)).toEqual([
+      "slack",
+      "telegram",
+      "phone",
+    ]);
+  });
+
+  test("each channel entry carries display metadata from CHANNEL_METADATA", async () => {
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { count: 1, results: [{ id: "addr-1", address: "hi@bot" }] },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+
+    for (const channel of result.channels) {
+      const expected = (CHANNEL_METADATA as any)[channel.id];
+      expect(expected).toBeDefined();
+      expect(channel).toEqual(expected);
+    }
+  });
+
+  test("email metadata: not verification-capable, mail icon", async () => {
+    mockEmailAddressesResponse = {
+      ok: true,
+      status: 200,
+      body: { count: 1, results: [{ id: "addr-1", address: "hi@bot" }] },
+    };
+
+    const result = (await handler({})) as HandlerResult;
+    const email = result.channels.find((c) => c.id === "email");
+
+    expect(email).toBeDefined();
+    expect(email!.icon).toBe("mail");
+    expect(email!.label).toBe("Email");
+    expect(email!.supportsVerification).toBe(false);
+  });
+
+  test("slack/telegram/phone are all verification-capable", async () => {
+    const result = (await handler({})) as HandlerResult;
+    for (const id of ["slack", "telegram", "phone"]) {
+      const ch = result.channels.find((c) => c.id === id);
+      expect(ch).toBeDefined();
+      expect(ch!.supportsVerification).toBe(true);
+      expect(ch!.setupMessages.guardian.length).toBeGreaterThan(0);
+      expect(ch!.setupMessages.contact.length).toBeGreaterThan(0);
+    }
+  });
+});

package/src/__tests__/channel-delivery-store.test.ts

@@ -30,6 +30,11 @@ import {
   recordProcessingFailure,
   replayDeadLetters,
 } from "../memory/delivery-status.js";
+import {
+  getBindingByChannelChat,
+  getBindingByChannelChatThread,
+  upsertBinding,
+} from "../memory/external-conversation-store.js";
 import { RETRY_MAX_ATTEMPTS } from "../memory/job-utils.js";
 import {
   channelInboundEvents,
@@ -37,6 +42,7 @@ import {
   externalConversationBindings,
   messages,
 } from "../memory/schema.js";
+import { buildConversationDetailResponse } from "../runtime/services/conversation-serializer.js";
 import { handleDeleteConversation } from "./helpers/channel-test-adapter.js";
 
 initializeDb();
@@ -50,7 +56,11 @@ function resetTables() {
 }
 
 /** Insert a message row so FK constraints on channel_inbound_events.message_id pass. */
-function insertMessage(id: string, conversationId: string): void {
+function insertMessage(
+  id: string,
+  conversationId: string,
+  metadata?: Record<string, unknown>,
+): void {
   const db = getDb();
   db.insert(messages)
     .values({
@@ -59,6 +69,7 @@ function insertMessage(id: string, conversationId: string): void {
       role: "user",
       content: "test message",
       createdAt: Date.now(),
+      metadata: metadata ? JSON.stringify(metadata) : null,
     })
     .run();
 }
@@ -116,6 +127,226 @@ describe("channel-delivery-store", () => {
     expect(r1.conversationId).toBe(r2.conversationId);
   });
 
+  test("same Slack channel and thread reuses the same conversation", () => {
+    const r1 = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+    const r2 = recordInbound("slack", "C0123ABCDEF", "msg-2", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    expect(r1.conversationId).toBe(r2.conversationId);
+  });
+
+  test("different Slack threads in one channel get different conversations", () => {
+    const r1 = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+    const r2 = recordInbound("slack", "C0123ABCDEF", "msg-2", {
+      sourceThreadId: "1710000000.000200",
+    });
+
+    expect(r1.conversationId).not.toBe(r2.conversationId);
+  });
+
+  test("legacy Slack channel key with matching inbound root ts gets aliased to the threaded key", () => {
+    const channelId = "C0123ABCDEF";
+    const threadTs = "1710000000.000100";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: threadTs,
+    });
+
+    const threaded = recordInbound("slack", channelId, "thread-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000001.000100",
+    });
+
+    expect(threaded.conversationId).toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(`asst:self:slack:${channelId}:thread:${threadTs}`)
+        ?.conversationId,
+    ).toBe(legacy.conversationId);
+  });
+
+  test("legacy Slack channel key with matching slackMeta.threadTs evidence gets aliased to the threaded key", () => {
+    const channelId = "C0123ABCDEF";
+    const threadTs = "1710000000.000200";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: "1710000000.999999",
+    });
+    insertMessage("legacy-thread-message", legacy.conversationId, {
+      slackMeta: JSON.stringify({
+        source: "slack",
+        channelId,
+        channelTs: "1710000001.000200",
+        threadTs,
+        eventKind: "message",
+      }),
+    });
+
+    const threaded = recordInbound("slack", channelId, "thread-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000002.000200",
+    });
+
+    expect(threaded.conversationId).toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(`asst:self:slack:${channelId}:thread:${threadTs}`)
+        ?.conversationId,
+    ).toBe(legacy.conversationId);
+  });
+
+  test("legacy Slack thread evidence scan is bounded when metadata does not prove the thread", () => {
+    const channelId = "C0123ABCDEF";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: "1710000000.000100",
+    });
+    for (let i = 0; i < 550; i++) {
+      insertMessage(`legacy-thread-message-${i}`, legacy.conversationId, {
+        slackMeta: JSON.stringify({
+          source: "slack",
+          channelId,
+          channelTs: `1710000001.${String(i).padStart(6, "0")}`,
+          threadTs: "1710000000.000100",
+          eventKind: "message",
+        }),
+      });
+    }
+    insertMessage("legacy-thread-message-target", legacy.conversationId, {
+      slackMeta: JSON.stringify({
+        source: "slack",
+        channelId,
+        channelTs: "1710000002.000600",
+        threadTs: "1710000000.000600",
+        eventKind: "message",
+      }),
+    });
+
+    const threaded = recordInbound("slack", channelId, "thread-reply", {
+      sourceThreadId: "1710000000.000600",
+      sourceMessageId: "1710000003.000600",
+    });
+
+    expect(threaded.conversationId).not.toBe(legacy.conversationId);
+  });
+
+  test("legacy Slack channel key without evidence for the requested thread is not reused", () => {
+    const channelId = "C0123ABCDEF";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: "1710000000.000100",
+    });
+    insertMessage("legacy-other-thread-message", legacy.conversationId, {
+      slackMeta: JSON.stringify({
+        source: "slack",
+        channelId,
+        channelTs: "1710000001.000100",
+        threadTs: "1710000000.000100",
+        eventKind: "message",
+      }),
+    });
+
+    const threaded = recordInbound("slack", channelId, "new-thread-reply", {
+      sourceThreadId: "1710000000.000300",
+      sourceMessageId: "1710000001.000300",
+    });
+
+    expect(threaded.conversationId).not.toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(
+        `asst:self:slack:${channelId}:thread:1710000000.000300`,
+      )?.conversationId,
+    ).toBe(threaded.conversationId);
+  });
+
+  test("aliasing a proven legacy Slack thread does not collapse different thread IDs", () => {
+    const channelId = "C0123ABCDEF";
+    const legacyThreadTs = "1710000000.000100";
+    const newThreadTs = "1710000000.000200";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: legacyThreadTs,
+    });
+
+    const aliased = recordInbound("slack", channelId, "legacy-thread-reply", {
+      sourceThreadId: legacyThreadTs,
+      sourceMessageId: "1710000001.000100",
+    });
+    const separate = recordInbound("slack", channelId, "new-thread-reply", {
+      sourceThreadId: newThreadTs,
+      sourceMessageId: "1710000001.000200",
+    });
+
+    expect(aliased.conversationId).toBe(legacy.conversationId);
+    expect(separate.conversationId).not.toBe(legacy.conversationId);
+    expect(separate.conversationId).not.toBe(aliased.conversationId);
+  });
+
+  test("reset legacy-aliased Slack thread does not reattach to old legacy conversation", async () => {
+    const channelId = "C0123ABCDEF";
+    const threadTs = "1710000000.000100";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: threadTs,
+    });
+    const aliased = recordInbound("slack", channelId, "legacy-thread-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000001.000100",
+    });
+    expect(aliased.conversationId).toBe(legacy.conversationId);
+
+    const req = new Request("http://localhost/channels/conversation", {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sourceChannel: "slack",
+        conversationExternalId: channelId,
+        sourceThreadId: threadTs,
+      }),
+    });
+    const res = await handleDeleteConversation(req);
+    expect(res.status).toBe(200);
+
+    const afterReset = recordInbound("slack", channelId, "after-reset-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000002.000100",
+    });
+
+    expect(afterReset.conversationId).not.toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(`asst:self:slack:${channelId}:thread:${threadTs}`)
+        ?.conversationId,
+    ).toBe(afterReset.conversationId);
+  });
+
+  test("reset legacy Slack thread before alias exists does not reattach to old legacy conversation", async () => {
+    const channelId = "C0123ABCDEF";
+    const threadTs = "1710000000.000100";
+    const legacy = recordInbound("slack", channelId, "legacy-event", {
+      sourceMessageId: threadTs,
+    });
+
+    const req = new Request("http://localhost/channels/conversation", {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sourceChannel: "slack",
+        conversationExternalId: channelId,
+        sourceThreadId: threadTs,
+      }),
+    });
+    const res = await handleDeleteConversation(req);
+    expect(res.status).toBe(200);
+
+    const afterReset = recordInbound("slack", channelId, "after-reset-reply", {
+      sourceThreadId: threadTs,
+      sourceMessageId: "1710000002.000100",
+    });
+
+    expect(afterReset.conversationId).not.toBe(legacy.conversationId);
+    expect(
+      getConversationByKey(`asst:self:slack:${channelId}:thread:${threadTs}`)
+        ?.conversationId,
+    ).toBe(afterReset.conversationId);
+  });
+
   test("different chats get different conversations", () => {
     const r1 = recordInbound("telegram", "chat-1", "msg-1");
     const r2 = recordInbound("telegram", "chat-2", "msg-1");
@@ -149,6 +380,63 @@ describe("channel-delivery-store", () => {
     expect(r1.conversationId).toBe(r2.conversationId);
   });
 
+  test("external bindings allow multiple Slack thread anchors per channel", () => {
+    const r1 = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+    const r2 = recordInbound("slack", "C0123ABCDEF", "msg-2", {
+      sourceThreadId: "1710000000.000200",
+    });
+
+    upsertBinding({
+      conversationId: r1.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+    });
+    upsertBinding({
+      conversationId: r2.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000200",
+    });
+
+    expect(
+      getBindingByChannelChatThread("slack", "C0123ABCDEF", "1710000000.000100")
+        ?.conversationId,
+    ).toBe(r1.conversationId);
+    expect(
+      getBindingByChannelChatThread("slack", "C0123ABCDEF", "1710000000.000200")
+        ?.conversationId,
+    ).toBe(r2.conversationId);
+    expect(getBindingByChannelChat("slack", "C0123ABCDEF")).toBeNull();
+  });
+
+  test("conversation detail exposes Slack thread anchor from binding", () => {
+    const result = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+    });
+
+    const detail = buildConversationDetailResponse(result.conversationId);
+
+    expect(detail?.conversation.channelBinding).toMatchObject({
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+      slackThread: {
+        channelId: "C0123ABCDEF",
+        threadTs: "1710000000.000100",
+      },
+    });
+  });
+
   // ── Deduplication ─────────────────────────────────────────────────
 
   test("duplicate inbound returns duplicate: true with same eventId", () => {

package/src/__tests__/circuit-breaker-pipeline.test.ts

@@ -377,7 +377,6 @@ describe("circuit-breaker pipeline", () => {
       manifest: {
         name: "observer",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1", circuitBreakerApi: "v1" },
       },
       middleware: {
         circuitBreaker: async (args, next) => {

package/src/__tests__/clawhub.test.ts

@@ -30,52 +30,111 @@ import type { SkillInstallMeta } from "../skills/install-meta.js";
 // ---------------------------------------------------------------------------
 
 describe("clawhubInstall slug validation", () => {
+  function expectInstallError(
+    result: Awaited<ReturnType<typeof clawhubInstall>>,
+  ): string {
+    expect(result.success).toBe(false);
+    if (result.success) throw new Error("Expected clawhubInstall to fail");
+    return result.error;
+  }
+
   test("rejects empty slug", async () => {
     const result = await clawhubInstall("");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Invalid skill slug");
+    expect(expectInstallError(result)).toContain("Invalid skill slug");
   });
 
   test("rejects slug starting with a dot", async () => {
     const result = await clawhubInstall(".hidden");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Invalid skill slug");
+    expect(expectInstallError(result)).toContain("Invalid skill slug");
   });
 
   test("rejects slug starting with a hyphen", async () => {
     const result = await clawhubInstall("-dashed");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Invalid skill slug");
+    expect(expectInstallError(result)).toContain("Invalid skill slug");
   });
 
   test("rejects slug with path traversal", async () => {
     const result = await clawhubInstall("../escape");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Invalid skill slug");
+    expect(expectInstallError(result)).toContain("Invalid skill slug");
   });
 
   test("rejects slug with spaces", async () => {
     const result = await clawhubInstall("my skill");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Invalid skill slug");
+    expect(expectInstallError(result)).toContain("Invalid skill slug");
   });
 
   test("rejects slug with double slash", async () => {
     const result = await clawhubInstall("ns//skill");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Invalid skill slug");
+    expect(expectInstallError(result)).toContain("Invalid skill slug");
   });
 
   test("rejects slug ending with slash", async () => {
     const result = await clawhubInstall("skill/");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Invalid skill slug");
+    expect(expectInstallError(result)).toContain("Invalid skill slug");
   });
 
   test("rejects slug with special characters", async () => {
     const result = await clawhubInstall("skill@latest");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Invalid skill slug");
+    expect(expectInstallError(result)).toContain("Invalid skill slug");
+  });
+});
+
+describe("clawhubInstall staging", () => {
+  test("runs clawhub in a staging project root without touching the managed skill", async () => {
+    const originalSpawn = Bun.spawn;
+    const projectRoot = join(TEST_DIR, "clawhub-staging-project");
+    const finalSkillDir = join(TEST_DIR, "skills", "demo-skill");
+    const stagedSkillDir = join(projectRoot, "skills", "demo-skill");
+
+    rmSync(projectRoot, { recursive: true, force: true });
+    rmSync(finalSkillDir, { recursive: true, force: true });
+    mkdirSync(finalSkillDir, { recursive: true });
+    writeFileSync(join(finalSkillDir, "SKILL.md"), "# Old Skill\n", "utf-8");
+
+    const spawnMock = mock((cmd: string[], opts: { cwd?: string }) => {
+      expect(cmd).toEqual([
+        "npx",
+        "clawhub",
+        "install",
+        "demo-skill",
+        "--force",
+      ]);
+      expect(opts.cwd).toBe(projectRoot);
+      mkdirSync(stagedSkillDir, { recursive: true });
+      writeFileSync(
+        join(stagedSkillDir, "SKILL.md"),
+        "# Staged Skill\n",
+        "utf-8",
+      );
+      return {
+        stdout: new Response("").body!,
+        stderr: new Response("").body!,
+        exited: Promise.resolve(0),
+        kill: () => {},
+      };
+    });
+
+    Bun.spawn = spawnMock as unknown as typeof Bun.spawn;
+    try {
+      const result = await clawhubInstall("demo-skill", { projectRoot });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.skillId).toBe("demo-skill");
+        expect(result.skillDir).toBe(stagedSkillDir);
+      }
+      expect(readFileSync(join(finalSkillDir, "SKILL.md"), "utf-8")).toBe(
+        "# Old Skill\n",
+      );
+      expect(readFileSync(join(stagedSkillDir, "SKILL.md"), "utf-8")).toBe(
+        "# Staged Skill\n",
+      );
+      expect(existsSync(join(stagedSkillDir, "install-meta.json"))).toBe(true);
+    } finally {
+      Bun.spawn = originalSpawn;
+      rmSync(projectRoot, { recursive: true, force: true });
+      rmSync(finalSkillDir, { recursive: true, force: true });
+    }
   });
 });