@vellumai/assistant 0.12.0 → 0.12.1-staging.1

package/src/__tests__/model-intents.test.ts

@@ -28,6 +28,9 @@ describe("model intents", () => {
     expect(resolveModelIntent("openai", "latency-optimized")).toBe(
       "gpt-5.6-luna",
     );
+    expect(resolveModelIntent("gemini", "cost-optimized")).toBe(
+      "gemini-3.1-flash-lite",
+    );
     expect(resolveModelIntent("gemini", "latency-optimized")).toBe(
       "gemini-3.1-flash-lite",
     );

package/src/__tests__/outlook-messaging-provider.test.ts

@@ -429,7 +429,7 @@ describe("Outlook messaging provider", () => {
   describe("sendMessage", () => {
     test("sends a new message with correct recipient, subject, and body", async () => {
       const conn = createMockConnection();
-      const result = await outlookMessagingProvider.sendMessage(
+      const result = await outlookMessagingProvider.sendMessage!(
         conn,
         "recipient@example.com",
         "Hello!",
@@ -452,7 +452,7 @@ describe("Outlook messaging provider", () => {
 
     test("uses empty string for subject when not provided", async () => {
       const conn = createMockConnection();
-      await outlookMessagingProvider.sendMessage(
+      await outlookMessagingProvider.sendMessage!(
         conn,
         "recipient@example.com",
         "Hello!",
@@ -471,7 +471,7 @@ describe("Outlook messaging provider", () => {
 
     test("calls replyToMessage when inReplyTo is provided", async () => {
       const conn = createMockConnection();
-      const result = await outlookMessagingProvider.sendMessage(
+      const result = await outlookMessagingProvider.sendMessage!(
         conn,
         "conv-id",
         "Reply text",
@@ -493,7 +493,7 @@ describe("Outlook messaging provider", () => {
 
     test("attaches files to a new message as Graph file attachments", async () => {
       const conn = createMockConnection();
-      await outlookMessagingProvider.sendMessage(
+      await outlookMessagingProvider.sendMessage!(
         conn,
         "recipient@example.com",
         "See attached",
@@ -530,7 +530,7 @@ describe("Outlook messaging provider", () => {
 
     test("forwards attachments to replyToMessage when replying", async () => {
       const conn = createMockConnection();
-      await outlookMessagingProvider.sendMessage(
+      await outlookMessagingProvider.sendMessage!(
         conn,
         "conv-id",
         "Reply body",
@@ -563,7 +563,7 @@ describe("Outlook messaging provider", () => {
 
     test("throws when connection is undefined", async () => {
       await expect(
-        outlookMessagingProvider.sendMessage(
+        outlookMessagingProvider.sendMessage!(
           undefined,
           "recipient@example.com",
           "Hello!",

package/src/__tests__/platform-client-verify-credential.test.ts

@@ -19,7 +19,9 @@ mock.module("../providers/platform-proxy/context.js", () => ({
   }),
 }));
 
+const actualEnv = await import("../config/env.js");
 mock.module("../config/env.js", () => ({
+  ...actualEnv,
   getPlatformAssistantId: () => platformAssistantId,
 }));
 

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -129,6 +129,9 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../daemon/embedding-reconcile.js",
     "../../../../daemon/trust-context.js",
     "../../../../daemon/turn-latency-sub-spans.js",
+    // mcp-setup capability cards list configured server names from the
+    // workspace mcp.json document. No plugin-api equivalent.
+    "../../../../mcp/workspace-mcp-config.js",
     "../../../../notifications/background-failure-signal.js",
     "../../../../persistence/checkpoints.js",
     "../../../../persistence/conversation-types.js",
@@ -210,6 +213,16 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../persistence/job-handlers/message-lexical.js",
     "../../../persistence/job-utils.js",
     "../../../persistence/jobs-store.js",
+    // The retrospective cursor is a `(createdAt, id)` bound that must keep
+    // working after its message row is deleted. The resolver lives beside
+    // the persistence after-reads it also drives, so the plugin's
+    // accounting imports it rather than re-deriving the bound. No
+    // plugin-api equivalent.
+    "../../../persistence/message-cursor.js",
+    // Named any-state `createdAt` lookup the cursor bookkeeping uses for
+    // forks and the timestamp backfill; the messages-read boundary guard
+    // requires the read to live in persistence. No plugin-api equivalent.
+    "../../../persistence/message-reads.js",
     "../../../persistence/raw-query.js",
     "../../../persistence/schema/index.js",
     "../../../prompts/persona-resolver.js",

package/src/__tests__/resolve-app.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Tests for resolving an app query by name, slug, or id.
+ */
+
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { createApp } from "../apps/app-store.js";
+import { resolveAppQuery } from "../apps/resolve-app.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+
+let workspaceDir: string;
+let previousWorkspaceDir: string | undefined;
+
+function freshWorkspace(): string {
+  return join(
+    tmpdir(),
+    `vellum-resolve-app-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+}
+
+function installPlugin(name: string): string {
+  const pluginDir = join(getWorkspacePluginsDir(), name);
+  mkdirSync(pluginDir, { recursive: true });
+  writeFileSync(
+    join(pluginDir, "package.json"),
+    JSON.stringify({ name, version: "1.0.0" }),
+  );
+  return pluginDir;
+}
+
+function bundleApp(pluginDir: string, app: string): void {
+  const appDir = join(pluginDir, "apps", app);
+  mkdirSync(appDir, { recursive: true });
+  writeFileSync(join(appDir, "index.html"), "<h1>Plugin app</h1>");
+}
+
+beforeEach(() => {
+  previousWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+  workspaceDir = freshWorkspace();
+  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+  if (previousWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceDir;
+  }
+});
+
+describe("resolveAppQuery", () => {
+  test("resolves a workspace app by display name, slug, and id", () => {
+    const created = createApp({
+      name: "Budget",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>Budget</h1>",
+    });
+
+    const byName = resolveAppQuery("Budget");
+    expect(byName.ok).toBe(true);
+    if (byName.ok) {
+      expect(byName.app.id).toBe(created.id);
+    }
+
+    const byNameCase = resolveAppQuery("budget");
+    expect(byNameCase.ok).toBe(true);
+    if (byNameCase.ok) {
+      expect(byNameCase.app.id).toBe(created.id);
+    }
+
+    const slug = created.dirName ?? "";
+    expect(slug.length).toBeGreaterThan(0);
+    const bySlug = resolveAppQuery(slug);
+    expect(bySlug.ok).toBe(true);
+    if (bySlug.ok) {
+      expect(bySlug.app.id).toBe(created.id);
+    }
+
+    const byId = resolveAppQuery(created.id);
+    expect(byId.ok).toBe(true);
+    if (byId.ok) {
+      expect(byId.app.id).toBe(created.id);
+    }
+  });
+
+  test("returns not_found for an unknown name", () => {
+    const result = resolveAppQuery("missing");
+    expect(result).toEqual({
+      ok: false,
+      reason: "not_found",
+      query: "missing",
+    });
+  });
+
+  test("returns ambiguous when two apps share a display name", () => {
+    const first = createApp({
+      name: "Notes",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>One</h1>",
+    });
+    const second = createApp({
+      name: "Notes",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>Two</h1>",
+    });
+
+    const result = resolveAppQuery("Notes");
+    expect(result.ok).toBe(false);
+    if (!result.ok && result.reason === "ambiguous") {
+      const ids = result.matches.map((m) => m.id).sort();
+      expect(ids).toEqual([first.id, second.id].sort());
+    } else {
+      throw new Error("expected ambiguous resolution");
+    }
+  });
+
+  test("resolves a plugin app by directory name", () => {
+    const pluginDir = installPlugin("charts");
+    bundleApp(pluginDir, "viewer");
+
+    const result = resolveAppQuery("viewer");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.app.origin).toEqual({
+        kind: "plugin",
+        pluginName: "charts",
+      });
+      expect(result.app.id).toBe("plugins~charts~viewer");
+    }
+  });
+});

package/src/__tests__/script-proxy-certs.test.ts

@@ -8,6 +8,7 @@ import {
   getCAPath,
   issueLeafCert,
 } from "../outbound-proxy/index.js";
+import { writeCombinedCABundle } from "../util/ca-bundle.js";
 
 let dataDir: string;
 
@@ -19,6 +20,40 @@ afterAll(async () => {
   await rm(dataDir, { recursive: true, force: true });
 });
 
+test("combined trust verifies certificates from both CA sources", async () => {
+  const roots = [join(dataDir, "system"), join(dataDir, "extra")];
+  const leaves: string[] = [];
+  for (const root of roots) {
+    await ensureLocalCA(root);
+    const caDir = join(root, "proxy-ca");
+    await issueLeafCert(caDir, "example.com");
+    leaves.push(join(caDir, "issued", "example.com.pem"));
+  }
+  const bundle = join(dataDir, "combined.pem");
+  await writeCombinedCABundle(
+    getCAPath(roots[0]!),
+    getCAPath(roots[1]!),
+    bundle,
+  );
+  const verify = Bun.spawn(
+    ["openssl", "verify", "-CAfile", bundle, ...leaves],
+    {
+      stdout: "pipe",
+      stderr: "pipe",
+      windowsHide: true,
+    },
+  );
+  const [code, output, error] = await Promise.all([
+    verify.exited,
+    new Response(verify.stdout).text(),
+    new Response(verify.stderr).text(),
+  ]);
+  expect({ code, error }).toEqual({ code: 0, error: "" });
+  for (const leaf of leaves) {
+    expect(output).toContain(`${leaf}: OK`);
+  }
+});
+
 describe("ensureLocalCA", () => {
   test("creates CA cert and key with correct permissions", async () => {
     await ensureLocalCA(dataDir);

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

@@ -60,7 +60,7 @@ function makeConfig(overrides: Partial<AssistantConfig> = {}): AssistantConfig {
   return {
     skills: {
       entries: {},
-      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+      load: { extraDirs: [] },
       install: { nodeManager: "npm" },
       allowBundled: null,
       remoteProviders: {

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

@@ -28,7 +28,7 @@ function makeConfig(overrides: Partial<AssistantConfig> = {}): AssistantConfig {
   return {
     skills: {
       entries: {},
-      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+      load: { extraDirs: [] },
       install: { nodeManager: "npm" },
       allowBundled: null,
       remoteProviders: {
@@ -233,7 +233,7 @@ describe("resolveSkillStates with feature flags", () => {
     const config = makeConfig({
       skills: {
         entries: { [DECLARED_SKILL_ID]: { enabled: true } },
-        load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+        load: { extraDirs: [] },
         install: { nodeManager: "npm" },
         allowBundled: null,
         remoteProviders: {

package/src/__tests__/source-fingerprint.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Tests for app source fingerprinting: walk exclusions, comparison, inspect
+ * statuses, and the compile-time sidecar format.
+ */
+
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  compareAppSourceFingerprint,
+  computeAppSourceFingerprint,
+  inspectAppSource,
+  parseAppSourceFingerprint,
+  SOURCE_FINGERPRINT_FILENAME,
+  writeAppSourceFingerprint,
+} from "../apps/source-fingerprint.js";
+
+let root: string;
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "app-source-fingerprint-"));
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+function write(rel: string, contents: string): void {
+  const abs = join(root, rel);
+  mkdirSync(join(abs, ".."), { recursive: true });
+  writeFileSync(abs, contents);
+}
+
+describe("computeAppSourceFingerprint", () => {
+  test("digests source files with POSIX-relative keys", () => {
+    write("src/main.tsx", "export const x = 1;");
+    write("src/index.html", "<html></html>");
+
+    const fp = computeAppSourceFingerprint(root);
+
+    expect(Object.keys(fp.files).sort()).toEqual([
+      "src/index.html",
+      "src/main.tsx",
+    ]);
+    expect(fp.algorithm).toBe("sha256");
+    expect(fp.files["src/main.tsx"]).toMatch(/^[0-9a-f]{64}$/);
+  });
+
+  test("skips dist, records, node_modules, and .git", () => {
+    write("src/main.tsx", "src");
+    write("dist/main.js", "compiled");
+    write("records/rec-1.json", "{}");
+    write("node_modules/pkg/index.js", "dep");
+    write("src/node_modules/nested/index.js", "nested");
+    write(".git/HEAD", "ref");
+    write("src/.git/config", "nope");
+
+    const fp = computeAppSourceFingerprint(root);
+
+    expect(Object.keys(fp.files)).toEqual(["src/main.tsx"]);
+  });
+
+  test("skips symlinks", () => {
+    write("src/real.tsx", "hello");
+    mkdirSync(join(root, "src"), { recursive: true });
+    symlinkSync(join(root, "src/real.tsx"), join(root, "src/link.tsx"));
+
+    const fp = computeAppSourceFingerprint(root);
+
+    expect(Object.keys(fp.files)).toEqual(["src/real.tsx"]);
+  });
+});
+
+describe("compareAppSourceFingerprint", () => {
+  test("reports modified, added, and removed paths", () => {
+    write("src/main.tsx", "one");
+    write("src/keep.tsx", "keep");
+    const baseline = computeAppSourceFingerprint(root);
+
+    write("src/main.tsx", "two");
+    write("src/new.tsx", "new");
+    rmSync(join(root, "src/keep.tsx"));
+
+    const diff = compareAppSourceFingerprint(root, baseline);
+    expect(diff.clean).toBe(false);
+    expect(diff.modified).toEqual(["src/main.tsx"]);
+    expect(diff.added).toEqual(["src/new.tsx"]);
+    expect(diff.removed).toEqual(["src/keep.tsx"]);
+  });
+
+  test("is clean when source matches the baseline", () => {
+    write("src/main.tsx", "same");
+    const baseline = computeAppSourceFingerprint(root);
+    const diff = compareAppSourceFingerprint(root, baseline);
+    expect(diff.clean).toBe(true);
+    expect(diff.modified).toEqual([]);
+    expect(diff.added).toEqual([]);
+    expect(diff.removed).toEqual([]);
+  });
+});
+
+describe("inspectAppSource", () => {
+  test("reports never_compiled when dist index is missing even if a fingerprint exists", () => {
+    write("src/main.tsx", "src");
+    mkdirSync(join(root, "dist"), { recursive: true });
+    writeAppSourceFingerprint(root, join(root, "dist"));
+
+    const result = inspectAppSource(root);
+    expect(result.status).toBe("never_compiled");
+  });
+
+  test("reports unknown_baseline when dist exists without a fingerprint", () => {
+    write("src/main.tsx", "src");
+    write("dist/index.html", "<html></html>");
+    const result = inspectAppSource(root);
+    expect(result.status).toBe("unknown_baseline");
+  });
+
+  test("reports clean after writing a fingerprint that matches source", () => {
+    write("src/main.tsx", "src");
+    mkdirSync(join(root, "dist"), { recursive: true });
+    writeFileSync(join(root, "dist", "index.html"), "<html></html>");
+    writeAppSourceFingerprint(root, join(root, "dist"));
+
+    const result = inspectAppSource(root);
+    expect(result.status).toBe("clean");
+    expect(result.compiledAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+
+  test("reports stale after a source edit", () => {
+    write("src/main.tsx", "before");
+    mkdirSync(join(root, "dist"), { recursive: true });
+    writeFileSync(join(root, "dist", "index.html"), "<html></html>");
+    writeAppSourceFingerprint(root, join(root, "dist"));
+    write("src/main.tsx", "after");
+
+    const result = inspectAppSource(root);
+    expect(result.status).toBe("stale");
+    expect(result.modified).toEqual(["src/main.tsx"]);
+  });
+});
+
+describe("parseAppSourceFingerprint", () => {
+  test("accepts a compile sidecar with compiledAt", () => {
+    const parsed = parseAppSourceFingerprint({
+      algorithm: "sha256",
+      compiledAt: "2026-09-09T00:00:00.000Z",
+      files: { "src/main.tsx": "abc" },
+    });
+    expect(parsed).toEqual({
+      algorithm: "sha256",
+      compiledAt: "2026-09-09T00:00:00.000Z",
+      files: { "src/main.tsx": "abc" },
+    });
+  });
+
+  test("returns null for an invalid sidecar", () => {
+    expect(parseAppSourceFingerprint({ algorithm: "md5", files: {} })).toBe(
+      null,
+    );
+    expect(parseAppSourceFingerprint(null)).toBeNull();
+  });
+
+  test("writeAppSourceFingerprint records a sidecar the parser accepts", () => {
+    write("src/main.tsx", "src");
+    mkdirSync(join(root, "dist"), { recursive: true });
+    writeAppSourceFingerprint(root, join(root, "dist"));
+    const raw = JSON.parse(
+      readFileSync(join(root, "dist", SOURCE_FINGERPRINT_FILENAME), "utf-8"),
+    );
+    expect(parseAppSourceFingerprint(raw)?.files["src/main.tsx"]).toMatch(
+      /^[0-9a-f]{64}$/,
+    );
+  });
+});

package/src/__tests__/subagent-tool-gate-mode.test.ts

@@ -249,14 +249,23 @@ describe("createResolveToolsCallback — toolContextPin", () => {
     });
   }
 
-  test("control: without a pin, a clientless fork drops every client-gated tool from the wire", () => {
+  test("control: without a pin, a clientless fork drops client-gated tools but keeps host and UI tools", () => {
     projectedSkillToolNames = [];
     const resolve = createResolveToolsCallback(
       CLIENT_GATED_DEFS,
       clientlessExecutionCtx(),
     )!;
 
-    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual(["remember"]);
+    // Host tool definitions stay on the wire for background turns, and
+    // ui_show stays because background UI surfaces persist and return. The
+    // executor rejects host tools on explicitly non-interactive turns before
+    // dispatch; ask_question and request_system_permission remain
+    // client-gated at resolution.
+    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual([
+      "remember",
+      "host_bash",
+      "ui_show",
+    ]);
   });
 
   test("a desktop-source pin restores the host/UI/client tool defs on the wire", () => {
@@ -291,7 +300,14 @@ describe("createResolveToolsCallback — toolContextPin", () => {
       }),
     )!;
 
-    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual(["remember"]);
+    // Host tool definitions stay on the wire for background turns, and
+    // ui_show survives the clientless pin: it persists and returns. The
+    // executor rejects host tools on explicitly non-interactive turns.
+    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual([
+      "remember",
+      "host_bash",
+      "ui_show",
+    ]);
   });
 
   test("invariant: a pinned-in tool is on the wire but can never execute", async () => {

package/src/__tests__/subagent-tools.test.ts

@@ -3447,8 +3447,9 @@ describe("Subagent advisor-role consult", () => {
   });
 
   test("advisor consults still run when the parent conversation is gone", async () => {
-    // The parent is looked up only for its warm skill catalog, so an evicted
-    // conversation costs a section of the context pack, not the consult.
+    // Advisor consults do not look up the parent conversation for a skill
+    // catalog snapshot. An evicted parent still gets a consult; the context
+    // pack loads the catalog from disk independently.
     mockFindConversation = () => undefined;
     const { captured, restore } = stubSpawn();
     try {

package/src/__tests__/telephony-tts-guard.test.ts

@@ -455,10 +455,11 @@ describe("resolveCallTtsProvider with requiresPcmAudio", () => {
     expect(result.provider?.id).toBe("elevenlabs");
   });
 
-  test("without requiresPcmAudio the configured provider is not swapped", async () => {
+  test("without requiresPcmAudio the configured provider is not swapped for playability", async () => {
     testConfig.services.tts.provider = "deepgram";
-    // No credentials at all — the CR transport path does not consult the
-    // media-stream playability capability.
+    storedKeys["deepgram"] = "dg-key";
+    // The CR transport path does not consult the media-stream playability
+    // capability.
     registerStubProvider("deepgram", async () => {
       return { audio: Buffer.from("x"), contentType: "audio/mpeg" };
     });
@@ -468,6 +469,37 @@ describe("resolveCallTtsProvider with requiresPcmAudio", () => {
     expect(result.useSynthesizedPath).toBe(true);
     expect(result.audioFormat).toBe("mp3");
   });
+
+  test("managed speech stands in for a configured provider whose credential is missing", async () => {
+    testConfig.services.tts.provider = "deepgram";
+    // No deepgram key, managed speech available: the phone speaks through
+    // managed speech, the same substitution live voice makes.
+    registerStubProvider("deepgram", async () => {
+      throw new Error("should not be used");
+    });
+    registerStubProvider("vellum", async () => {
+      return { audio: Buffer.from("x"), contentType: "audio/mpeg" };
+    });
+
+    const result = await resolveCallTtsProvider();
+    expect(result.provider?.id).toBe("vellum");
+    expect(result.useSynthesizedPath).toBe(true);
+  });
+
+  test("without managed speech a credential-less configured provider is kept", async () => {
+    mockManagedSpeechAvailable = false;
+    try {
+      testConfig.services.tts.provider = "deepgram";
+      registerStubProvider("deepgram", async () => {
+        return { audio: Buffer.from("x"), contentType: "audio/mpeg" };
+      });
+
+      const result = await resolveCallTtsProvider();
+      expect(result.provider?.id).toBe("deepgram");
+    } finally {
+      mockManagedSpeechAvailable = true;
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -584,6 +616,7 @@ describe("speakSystemPrompt mid-stream failure after audio started", () => {
   test("non-PCM transport: skips the native text fallback — no full-prompt re-speak", async () => {
     testConfig.services.tts.provider = "fish-audio";
     testConfig.services.tts.providers["fish-audio"].referenceId = "ref-123";
+    storedKeys["fish-audio"] = "fa-key";
 
     const fishStream = jest.fn(failAfterFirstChunk());
     registerStreamingStubProvider("fish-audio", fishStream);
@@ -657,6 +690,7 @@ describe("speakSystemPrompt aborted synthesis", () => {
   test("non-PCM transport with native-fallback provider: abort skips the text fallback and end-of-turn", async () => {
     testConfig.services.tts.provider = "fish-audio";
     testConfig.services.tts.providers["fish-audio"].referenceId = "ref-123";
+    storedKeys["fish-audio"] = "fa-key";
 
     const controller = new AbortController();
     controller.abort();
@@ -742,6 +776,7 @@ describe("speakSystemPrompt aborted synthesis", () => {
   test("provider AbortError without any signal is a failure — non-PCM native fallback still runs", async () => {
     testConfig.services.tts.provider = "fish-audio";
     testConfig.services.tts.providers["fish-audio"].referenceId = "ref-123";
+    storedKeys["fish-audio"] = "fa-key";
 
     const fishSynthesize = jest.fn(async () => {
       throw new DOMException("socket torn down", "AbortError");

package/src/__tests__/vellum-self-knowledge-inline-command.test.ts

@@ -136,6 +136,10 @@ describe("vellum-self-knowledge skill", () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
     expect(result.content).toContain("## Critical Rule");
     expect(result.content).toContain("Never answer from memory");
+    expect(result.content).toContain("distinct, legacy Vellum product");
+    expect(result.content).toContain(
+      "Never use it to answer questions about this Vellum",
+    );
   });
 
   // ── Resolution order ─────────────────────────────────────────────────