@vellumai/assistant 0.4.41 → 0.4.43

package/src/__tests__/integration-status.test.ts

@@ -31,7 +31,7 @@ describe("integration-status", () => {
         { name: "Gmail", category: "email", connected: false },
         { name: "Twitter", category: "social", connected: false },
         { name: "Slack", category: "messaging", connected: false },
-        { name: "SMS", category: "messaging", connected: false },
+        { name: "Twilio", category: "telephony", connected: false },
         { name: "Telegram", category: "messaging", connected: false },
       ]);
     });
@@ -66,7 +66,7 @@ describe("integration-status", () => {
       );
 
       expect(connected.map((s: { name: string }) => s.name)).toEqual([
-        "SMS",
+        "Twilio",
         "Telegram",
       ]);
       expect(disconnected.map((s: { name: string }) => s.name)).toEqual([
@@ -76,12 +76,12 @@ describe("integration-status", () => {
       ]);
     });
 
-    test("SMS disconnected when only account_sid is set (missing auth_token)", () => {
+    test("Twilio disconnected when only account_sid is set (missing auth_token)", () => {
       mockTwilioAccountSid = "sid";
 
       const summary = getIntegrationSummary();
-      const sms = summary.find((s: { name: string }) => s.name === "SMS");
-      expect(sms?.connected).toBe(false);
+      const twilio = summary.find((s: { name: string }) => s.name === "Twilio");
+      expect(twilio?.connected).toBe(false);
     });
 
     test("Telegram disconnected when only bot_token is set (missing webhook_secret)", () => {
@@ -104,14 +104,14 @@ describe("integration-status", () => {
 
       const result = formatIntegrationSummary();
       expect(result).toBe(
-        "Gmail \u2717 | Twitter \u2717 | Slack \u2717 | SMS \u2713 | Telegram \u2713",
+        "Gmail \u2717 | Twitter \u2717 | Slack \u2717 | Twilio \u2713 | Telegram \u2713",
       );
     });
 
     test("all disconnected", () => {
       const result = formatIntegrationSummary();
       expect(result).toBe(
-        "Gmail \u2717 | Twitter \u2717 | Slack \u2717 | SMS \u2717 | Telegram \u2717",
+        "Gmail \u2717 | Twitter \u2717 | Slack \u2717 | Twilio \u2717 | Telegram \u2717",
       );
     });
 
@@ -126,7 +126,7 @@ describe("integration-status", () => {
 
       const result = formatIntegrationSummary();
       expect(result).toBe(
-        "Gmail \u2713 | Twitter \u2713 | Slack \u2713 | SMS \u2713 | Telegram \u2713",
+        "Gmail \u2713 | Twitter \u2713 | Slack \u2713 | Twilio \u2713 | Telegram \u2713",
       );
     });
   });

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

@@ -24,7 +24,7 @@ mock.module("../util/platform.js", () => ({
   getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
   getHistoryPath: () => join(TEST_DIR, "history"),
   getHooksDir: () => join(TEST_DIR, "hooks"),
-  getIpcBlobDir: () => join(TEST_DIR, "ipc-blobs"),
+
   getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
   getSandboxWorkingDir: () => TEST_DIR,
   getInterfacesDir: () => join(TEST_DIR, "interfaces"),
@@ -34,10 +34,6 @@ mock.module("../util/platform.js", () => ({
   getPlatformName: () => process.platform,
   getClipboardCommand: () => null,
   readSessionToken: () => null,
-  removeSocketFile: () => {},
-  migratePath: () => {},
-  migrateToWorkspaceLayout: () => {},
-  migrateToDataLayout: () => {},
 }));
 
 const noopLogger = new Proxy({} as Record<string, unknown>, {
@@ -76,7 +72,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 // ── Import after mocks ───────────────────────────────────────────────
-const { buildSystemPrompt } = await import("../config/system-prompt.js");
+const { buildSystemPrompt } = await import("../prompts/system-prompt.js");
 
 // Load task_list_add description from the bundled skill TOOLS.json
 const tasksToolsJson = JSON.parse(
@@ -301,9 +297,10 @@ describe("Guardian verification routing section in system prompt", () => {
     expect(prompt).toContain("verify guardian");
   });
 
-  test("routing section does not include SMS trigger phrase", () => {
+  test("routing section does not include legacy channel trigger phrases", () => {
     const prompt = buildSystemPrompt();
-    expect(prompt).not.toContain("set guardian for SMS");
+    // Verify no legacy channel trigger phrases remain in the routing section
+    expect(prompt).not.toContain("set guardian for");
   });
 
   test('routing section includes trigger phrase "verify my Telegram account"', () => {
@@ -311,9 +308,9 @@ describe("Guardian verification routing section in system prompt", () => {
     expect(prompt).toContain("verify my Telegram account");
   });
 
-  test('routing section includes trigger phrase "verify voice channel"', () => {
+  test('routing section includes trigger phrase "verify phone channel"', () => {
     const prompt = buildSystemPrompt();
-    expect(prompt).toContain("verify voice channel");
+    expect(prompt).toContain("verify phone channel");
   });
 
   test('routing section includes trigger phrase "verify my phone number"', () => {
@@ -331,13 +328,12 @@ describe("Guardian verification routing section in system prompt", () => {
     expect(prompt).toContain("guardian-verify-setup");
   });
 
-  test("routing section mentions voice and telegram channels but not sms", () => {
+  test("routing section mentions phone and telegram channels but not legacy channels", () => {
     const prompt = buildSystemPrompt();
     const routingStart = prompt.indexOf("## Routing: Guardian Verification");
     const routingSection = prompt.substring(routingStart, routingStart + 1000);
-    expect(routingSection).toContain("voice");
+    expect(routingSection).toContain("phone");
     expect(routingSection).toContain("telegram");
-    expect(routingSection).not.toContain("sms");
   });
 
   test("routing section contains exclusivity wording", () => {

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

@@ -206,7 +206,7 @@ describe("invite-redemption-service", () => {
 
     const outcome = redeemInvite({
       rawToken,
-      sourceChannel: "sms",
+      sourceChannel: "phone",
       externalUserId: "user-1",
     });
 
@@ -324,7 +324,7 @@ describe("invite-redemption-service", () => {
   });
 
   test("channel enforcement blocks cross-channel redemption (voice invite via slack)", () => {
-    const { rawToken } = createInvite({ sourceChannel: "voice", maxUses: 1 });
+    const { rawToken } = createInvite({ sourceChannel: "phone", maxUses: 1 });
 
     const outcome = redeemInvite({
       rawToken,
@@ -379,9 +379,9 @@ describe("invite-redemption-service", () => {
   });
 
   test("returns channel_mismatch for an active member with a valid token for a different channel", () => {
-    // Create an invite for SMS
+    // Create an invite for voice
     const { rawToken } = createInvite({
-      sourceChannel: "sms",
+      sourceChannel: "phone",
       maxUses: 5,
     });
 

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

@@ -299,7 +299,7 @@ describe("voice invite HTTP routes", () => {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        sourceChannel: "voice",
+        sourceChannel: "phone",
         expectedExternalUserId: "+15551234567",
         friendName: "Alice",
         guardianName: "Bob",
@@ -313,7 +313,7 @@ describe("voice invite HTTP routes", () => {
     expect(res.status).toBe(201);
     expect(body.ok).toBe(true);
     const invite = body.invite as Record<string, unknown>;
-    expect(invite.sourceChannel).toBe("voice");
+    expect(invite.sourceChannel).toBe("phone");
     // Voice code should be returned (6 digits by default)
     expect(typeof invite.voiceCode).toBe("string");
     expect((invite.voiceCode as string).length).toBe(6);
@@ -335,7 +335,7 @@ describe("voice invite HTTP routes", () => {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        sourceChannel: "voice",
+        sourceChannel: "phone",
         friendName: "Alice",
         guardianName: "Bob",
       }),
@@ -354,7 +354,7 @@ describe("voice invite HTTP routes", () => {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        sourceChannel: "voice",
+        sourceChannel: "phone",
         expectedExternalUserId: "not-a-phone-number",
         friendName: "Alice",
         guardianName: "Bob",
@@ -374,7 +374,7 @@ describe("voice invite HTTP routes", () => {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        sourceChannel: "voice",
+        sourceChannel: "phone",
         expectedExternalUserId: "+15551234567",
         guardianName: "Bob",
       }),
@@ -393,7 +393,7 @@ describe("voice invite HTTP routes", () => {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        sourceChannel: "voice",
+        sourceChannel: "phone",
         expectedExternalUserId: "+15551234567",
         friendName: "Alice",
       }),
@@ -412,7 +412,7 @@ describe("voice invite HTTP routes", () => {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        sourceChannel: "voice",
+        sourceChannel: "phone",
         expectedExternalUserId: "+15551234567",
         friendName: "Alice",
         guardianName: "Bob",
@@ -435,7 +435,7 @@ describe("voice invite HTTP routes", () => {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        sourceChannel: "voice",
+        sourceChannel: "phone",
         expectedExternalUserId: "+15551234567",
         friendName: "Alice",
         guardianName: "Bob",
@@ -459,7 +459,7 @@ describe("voice invite HTTP routes", () => {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          sourceChannel: "voice",
+          sourceChannel: "phone",
           expectedExternalUserId: "+15551234567",
           friendName: "Alice",
           guardianName: "Bob",
@@ -516,7 +516,7 @@ describe("voice invite HTTP routes", () => {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          sourceChannel: "voice",
+          sourceChannel: "phone",
           expectedExternalUserId: "+15551234567",
           friendName: "Alice",
           guardianName: "Bob",

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

@@ -284,10 +284,15 @@ describe("getUsageTotals", () => {
     expect(totals.unpricedEventCount).toBe(0);
   });
 
-  test("sums tokens and cost across priced events", () => {
+  test("sums direct input, cache tokens, and cost across priced events", () => {
     insertEventAt(
       1000,
-      { inputTokens: 100, outputTokens: 50 },
+      {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheCreationInputTokens: 25,
+        cacheReadInputTokens: 50,
+      },
       {
         estimatedCostUsd: 0.01,
         pricingStatus: "priced",
@@ -295,7 +300,12 @@ describe("getUsageTotals", () => {
     );
     insertEventAt(
       2000,
-      { inputTokens: 200, outputTokens: 100 },
+      {
+        inputTokens: 200,
+        outputTokens: 100,
+        cacheCreationInputTokens: 75,
+        cacheReadInputTokens: 125,
+      },
       {
         estimatedCostUsd: 0.02,
         pricingStatus: "priced",
@@ -305,6 +315,8 @@ describe("getUsageTotals", () => {
     const totals = getUsageTotals({ from: 0, to: 5000 });
     expect(totals.totalInputTokens).toBe(300);
     expect(totals.totalOutputTokens).toBe(150);
+    expect(totals.totalCacheCreationTokens).toBe(100);
+    expect(totals.totalCacheReadTokens).toBe(175);
     expect(totals.totalEstimatedCostUsd).toBeCloseTo(0.03);
     expect(totals.eventCount).toBe(2);
     expect(totals.pricedEventCount).toBe(2);
@@ -375,14 +387,24 @@ describe("getUsageDayBuckets", () => {
     expect(buckets).toHaveLength(0);
   });
 
-  test("groups events into correct day buckets", () => {
+  test("groups direct input into correct day buckets without double-counting cache tokens", () => {
     const day1Start = utcMs(2025, 3, 1, 0);
     const day1Mid = utcMs(2025, 3, 1, 12);
     const day2Start = utcMs(2025, 3, 2, 6);
 
     insertEventAt(day1Start, { inputTokens: 100, outputTokens: 10 });
-    insertEventAt(day1Mid, { inputTokens: 200, outputTokens: 20 });
-    insertEventAt(day2Start, { inputTokens: 300, outputTokens: 30 });
+    insertEventAt(day1Mid, {
+      inputTokens: 200,
+      outputTokens: 20,
+      cacheCreationInputTokens: 50,
+      cacheReadInputTokens: 100,
+    });
+    insertEventAt(day2Start, {
+      inputTokens: 300,
+      outputTokens: 30,
+      cacheCreationInputTokens: 20,
+      cacheReadInputTokens: 30,
+    });
 
     const buckets = getUsageDayBuckets({
       from: utcMs(2025, 3, 1),
@@ -463,10 +485,15 @@ describe("getUsageGroupBreakdown", () => {
     expect(groups).toHaveLength(0);
   });
 
-  test("groups by actor", () => {
+  test("groups by actor with direct input and cache totals kept separate", () => {
     insertEventAt(
       1000,
-      { actor: "main_agent", inputTokens: 100 },
+      {
+        actor: "main_agent",
+        inputTokens: 100,
+        cacheCreationInputTokens: 30,
+        cacheReadInputTokens: 50,
+      },
       {
         estimatedCostUsd: 0.01,
         pricingStatus: "priced",
@@ -474,7 +501,12 @@ describe("getUsageGroupBreakdown", () => {
     );
     insertEventAt(
       2000,
-      { actor: "main_agent", inputTokens: 200 },
+      {
+        actor: "main_agent",
+        inputTokens: 200,
+        cacheCreationInputTokens: 20,
+        cacheReadInputTokens: 25,
+      },
       {
         estimatedCostUsd: 0.02,
         pricingStatus: "priced",
@@ -495,11 +527,15 @@ describe("getUsageGroupBreakdown", () => {
     // Ordered by cost descending
     expect(groups[0].group).toBe("main_agent");
     expect(groups[0].totalInputTokens).toBe(300);
+    expect(groups[0].totalCacheCreationTokens).toBe(50);
+    expect(groups[0].totalCacheReadTokens).toBe(75);
     expect(groups[0].totalEstimatedCostUsd).toBeCloseTo(0.03);
     expect(groups[0].eventCount).toBe(2);
 
     expect(groups[1].group).toBe("title_generator");
     expect(groups[1].totalInputTokens).toBe(50);
+    expect(groups[1].totalCacheCreationTokens).toBe(0);
+    expect(groups[1].totalCacheReadTokens).toBe(0);
     expect(groups[1].eventCount).toBe(1);
   });
 

package/src/__tests__/local-gateway-health.test.ts

@@ -0,0 +1,209 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let mockGatewayInternalBaseUrl = "http://127.0.0.1:7830";
+let mockIsContainerized = false;
+let mockLockfile: Record<string, unknown> | null = null;
+let mockBaseDataDir: string | undefined;
+
+mock.module("../config/env.js", () => ({
+  getGatewayInternalBaseUrl: () => mockGatewayInternalBaseUrl,
+}));
+
+mock.module("../config/env-registry.js", () => ({
+  getIsContainerized: () => mockIsContainerized,
+  getBaseDataDir: () => mockBaseDataDir,
+}));
+
+mock.module("../util/platform.js", () => ({
+  readLockfile: () => mockLockfile,
+}));
+
+import {
+  ensureLocalGatewayReady,
+  probeLocalGatewayHealth,
+} from "../runtime/local-gateway-health.js";
+
+describe("local gateway health", () => {
+  beforeEach(() => {
+    mockGatewayInternalBaseUrl = "http://127.0.0.1:7830";
+    mockIsContainerized = false;
+    mockBaseDataDir = undefined;
+    mockLockfile = {
+      assistants: [
+        {
+          assistantId: "local-dev",
+          cloud: "local",
+          hatchedAt: "2026-03-07T00:00:00.000Z",
+        },
+      ],
+    };
+  });
+
+  test("probeLocalGatewayHealth returns healthy result when /healthz succeeds", async () => {
+    const requests: string[] = [];
+    const fetchImpl: typeof fetch = (async (
+      input: string | URL | Request,
+    ): Promise<Response> => {
+      requests.push(
+        typeof input === "string"
+          ? input
+          : input instanceof URL
+            ? input.toString()
+            : input.url,
+      );
+      return new Response("ok", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    const result = await probeLocalGatewayHealth({
+      fetchImpl,
+      timeoutMs: 50,
+    });
+
+    expect(requests).toEqual(["http://127.0.0.1:7830/healthz"]);
+    expect(result).toEqual({
+      target: "http://127.0.0.1:7830",
+      healthy: true,
+      localDeployment: true,
+    });
+  });
+
+  test("probeLocalGatewayHealth returns an unhealthy result when /healthz fails", async () => {
+    const fetchImpl: typeof fetch = (async (): Promise<Response> => {
+      return new Response("unavailable", { status: 503 });
+    }) as unknown as typeof fetch;
+
+    const result = await probeLocalGatewayHealth({
+      fetchImpl,
+      timeoutMs: 50,
+    });
+
+    expect(result).toEqual({
+      target: "http://127.0.0.1:7830",
+      healthy: false,
+      localDeployment: true,
+      error: "Gateway health check returned HTTP 503",
+    });
+  });
+
+  test("ensureLocalGatewayReady runs recovery for local assistants until the gateway becomes healthy", async () => {
+    const healthStatuses = [503, 503, 200];
+    const fetchImpl: typeof fetch = (async (): Promise<Response> => {
+      const status = healthStatuses.shift() ?? 200;
+      return new Response(status === 200 ? "ok" : "unavailable", { status });
+    }) as unknown as typeof fetch;
+
+    const wakeCalls: number[] = [];
+    const result = await ensureLocalGatewayReady({
+      fetchImpl,
+      timeoutMs: 50,
+      pollTimeoutMs: 100,
+      pollIntervalMs: 0,
+      sleepImpl: async () => {},
+      runWakeCommand: async () => {
+        wakeCalls.push(Date.now());
+        return { exitCode: 0, stdout: "Wake complete.", stderr: "" };
+      },
+    });
+
+    expect(wakeCalls).toHaveLength(1);
+    expect(result).toEqual({
+      target: "http://127.0.0.1:7830",
+      healthy: true,
+      localDeployment: true,
+      recovered: true,
+      recoveryAttempted: true,
+      recoverySkipped: false,
+    });
+  });
+
+  test("ensureLocalGatewayReady skips recovery for non-local assistants", async () => {
+    mockLockfile = {
+      assistants: [
+        {
+          assistantId: "remote-prod",
+          cloud: "gcp",
+          hatchedAt: "2026-03-07T00:00:00.000Z",
+        },
+      ],
+    };
+
+    const fetchImpl: typeof fetch = (async (): Promise<Response> => {
+      return new Response("unavailable", { status: 503 });
+    }) as unknown as typeof fetch;
+
+    let wakeCallCount = 0;
+    const result = await ensureLocalGatewayReady({
+      fetchImpl,
+      timeoutMs: 50,
+      runWakeCommand: async () => {
+        wakeCallCount++;
+        return { exitCode: 0, stdout: "", stderr: "" };
+      },
+    });
+
+    expect(wakeCallCount).toBe(0);
+    expect(result).toEqual({
+      target: "http://127.0.0.1:7830",
+      healthy: false,
+      localDeployment: false,
+      error: "Gateway health check returned HTTP 503",
+      recovered: false,
+      recoveryAttempted: false,
+      recoverySkipped: true,
+    });
+  });
+
+  test("ensureLocalGatewayReady derives assistant name from BASE_DATA_DIR when lockfile lacks assistants", async () => {
+    mockBaseDataDir = "/home/user/.local/share/vellum/assistants/alice";
+    mockLockfile = null;
+
+    const healthStatuses = [503, 200];
+    const fetchImpl: typeof fetch = (async (): Promise<Response> => {
+      const status = healthStatuses.shift() ?? 200;
+      return new Response(status === 200 ? "ok" : "unavailable", { status });
+    }) as unknown as typeof fetch;
+
+    let wakeCalled = false;
+    const result = await ensureLocalGatewayReady({
+      fetchImpl,
+      timeoutMs: 50,
+      pollTimeoutMs: 100,
+      pollIntervalMs: 0,
+      sleepImpl: async () => {},
+      runWakeCommand: async () => {
+        wakeCalled = true;
+        return { exitCode: 0, stdout: "Wake complete.", stderr: "" };
+      },
+    });
+
+    expect(wakeCalled).toBe(true);
+    expect(result.recovered).toBe(true);
+  });
+
+  test("ensureLocalGatewayReady handles BASE_DATA_DIR with trailing slash", async () => {
+    mockBaseDataDir = "/home/user/.local/share/vellum/assistants/alice/";
+    mockLockfile = null;
+
+    const healthStatuses = [503, 200];
+    const fetchImpl: typeof fetch = (async (): Promise<Response> => {
+      const status = healthStatuses.shift() ?? 200;
+      return new Response(status === 200 ? "ok" : "unavailable", { status });
+    }) as unknown as typeof fetch;
+
+    let wakeCalled = false;
+    const result = await ensureLocalGatewayReady({
+      fetchImpl,
+      timeoutMs: 50,
+      pollTimeoutMs: 100,
+      pollIntervalMs: 0,
+      sleepImpl: async () => {},
+      runWakeCommand: async () => {
+        wakeCalled = true;
+        return { exitCode: 0, stdout: "Wake complete.", stderr: "" };
+      },
+    });
+
+    expect(wakeCalled).toBe(true);
+    expect(result.recovered).toBe(true);
+  });
+});

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

@@ -36,13 +36,16 @@ mock.module("../util/logger.js", () => ({
 
 // Mock global fetch
 let lastFetchArgs: [string, RequestInit] | null = null;
-let fetchResponse: { ok: boolean; status: number; json: () => Promise<unknown> } = {
+let fetchResponse: {
+  ok: boolean;
+  status: number;
+  json: () => Promise<unknown>;
+} = {
   ok: true,
   status: 200,
   json: async () => ({}),
 };
 
-const originalFetch = globalThis.fetch;
 globalThis.fetch = (async (url: string, init: RequestInit) => {
   lastFetchArgs = [url, init];
   return fetchResponse;
@@ -50,15 +53,14 @@ globalThis.fetch = (async (url: string, init: RequestInit) => {
 
 // Import after mocking
 import {
-  isManagedAvailable,
-  generateManagedAvatar,
-  getAssistantApiKey,
-} from "../media/managed-avatar-client.js";
-import {
-  ManagedAvatarError,
-  AVATAR_PROMPT_MAX_LENGTH,
   AVATAR_MAX_DECODED_BYTES,
+  AVATAR_PROMPT_MAX_LENGTH,
+  ManagedAvatarError,
 } from "../media/avatar-types.js";
+import {
+  generateManagedAvatar,
+  isManagedAvailable,
+} from "../media/managed-avatar-client.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -195,7 +197,10 @@ describe("generateManagedAvatar", () => {
       status: 200,
       json: async () => ({
         ...successResponse(),
-        image: { ...successResponse().image, bytes: AVATAR_MAX_DECODED_BYTES + 1 },
+        image: {
+          ...successResponse().image,
+          bytes: AVATAR_MAX_DECODED_BYTES + 1,
+        },
       }),
     };
 
@@ -213,13 +218,19 @@ describe("generateManagedAvatar", () => {
   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
-    const oversizedBase64 = "A".repeat(Math.ceil((AVATAR_MAX_DECODED_BYTES + 100) * 4 / 3));
+    const oversizedBase64 = "A".repeat(
+      Math.ceil(((AVATAR_MAX_DECODED_BYTES + 100) * 4) / 3),
+    );
     fetchResponse = {
       ok: true,
       status: 200,
       json: async () => ({
         ...successResponse(),
-        image: { ...successResponse().image, data_base64: oversizedBase64, bytes: 1024 },
+        image: {
+          ...successResponse().image,
+          data_base64: oversizedBase64,
+          bytes: 1024,
+        },
       }),
     };
 

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

@@ -42,7 +42,6 @@ mock.module("../util/platform.js", () => ({
   isWindows: () => process.platform === "win32",
   getPlatformName: () => process.platform,
   getClipboardCommand: () => null,
-  removeSocketFile: () => {},
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -72,7 +71,7 @@ mock.module("../tools/terminal/sandbox.js", () => ({
 }));
 
 import { loadSkillCatalog } from "../config/skills.js";
-import { buildSystemPrompt } from "../config/system-prompt.js";
+import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { DeleteManagedSkillTool } from "../tools/skills/delete-managed.js";
 import { SkillLoadTool } from "../tools/skills/load.js";
 import { ScaffoldManagedSkillTool } from "../tools/skills/scaffold-managed.js";