@vellumai/assistant 0.12.0 → 0.12.1-dev.202609141913.5e16607

package/src/__tests__/service-account-token.test.ts

@@ -0,0 +1,247 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+// ── Mutable state for injected vault ────────────────────────────────────────
+
+const vaultStore = new Map<string, string>();
+const writtenKeys = new Map<string, string>();
+
+// ── Import under test ────────────────────────────────────────────────────────
+//
+// No mock.module — prevents all bun worker contamination. Vault access is
+// injected through _injectVaultAccessors / _resetVaultAccessors instead.
+
+const {
+  getValidServiceAccountToken,
+  parseServiceAccountKey,
+  _resetServiceAccountMutex,
+  _injectVaultAccessors,
+  _resetVaultAccessors,
+} = await import("../providers/inference/service-account-token.js");
+
+// ── Hooks ────────────────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  vaultStore.clear();
+  writtenKeys.clear();
+  _resetServiceAccountMutex();
+  _injectVaultAccessors(
+    async (key: string) => vaultStore.get(key),
+    async (key: string, value: string) => {
+      vaultStore.set(key, value);
+      writtenKeys.set(key, value);
+      return true;
+    },
+  );
+});
+
+afterEach(() => {
+  _resetVaultAccessors();
+});
+
+// ── Real 2048-bit RSA PKCS#8 key generated offline for unit tests only ───────
+
+const TEST_PRIVATE_KEY =
+  "-----BEGIN PRIVATE KEY-----\n" +
+  "MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDFnEC0wI/cNKyO\n" +
+  "XzkqOGAvsTTx4Q+DPjDBPVoy3yHVk7cGYIf5sg3nsrQlE4ARMEQ9MXKUvw+VY59c\n" +
+  "zzpy9/JnCN9v5ymZUrowF/87Xn0muklHOhYPFz+73BunncH0Dk0mgCRWEfd/xoGB\n" +
+  "bMI40mI2hPMN5aGU4moTmVzTsgvatp0tAk90oaUQBZ/Y3PVjoR+SHbKhQtZW8eiO\n" +
+  "zUGyBhzmlmMZcquWxHui8QbO//kEKg7jv2+7npkdW/S0meoDeKZzqRNACKci1CQB\n" +
+  "N/skFqy6B8qYekhVYtAaIQOLtuD+VdLL7azMBqIHZSVQQXD6KisN8XSj95k/Fyeb\n" +
+  "UEmhvlwrAgMBAAECggEALKr7PWBhpGcLskr4AwEnTOCDlUFIXmRKZQPXRbSGU17G\n" +
+  "elyLn/eNiRgt/EuCIWCFrEdnHRRrE1unhDUbgy1kz8GDsCnSj2PRzlk+Sk87fuuQ\n" +
+  "8NbCcbrRn0dLwQG5+87XxaIllIcPKQTX9Ud+R5XWuXgn8LY9Zggf7jo2b2vJnjBO\n" +
+  "2SIS4M24a8x/1hHLjrTKtyO1yF3TI/9z72z4+yYiXAHxBugCcg6kv27pMEtOl5hv\n" +
+  "HW6ogBIDKVIVp3DmjaWxPawy1ytxpI1mR1lfGKoNI3iutLNfuHl3MwinYL7oCiL/\n" +
+  "rejuz37rXicFZ40YTKHDqKy+brLS6Ahg0R7XxSNtcQKBgQD7i4oh4stD+geFoPoJ\n" +
+  "o/grtOazn2GKuMOrcbBSaTfs4PZfcSRT8Egzhl3Vf/3Z30T3ChugFKkpN9naDEL3\n" +
+  "0SEH5sR5oMhGzzE3ncwTPR4fClpiX61JIY6iVL5AQukXIK+v+hCuhRu9YepMbGWq\n" +
+  "ndl/uH4LofuEctJYaovnghKedwKBgQDJHC7NiqNhGB6YzwgvYK2GVrFLdPpcfLbl\n" +
+  "y5DZKaVYCs3cLFCH7qHEdsmVEWkQ9UkRhxNPGpgQadvYNAd9Bbf2au2lfNuCt0Kn\n" +
+  "dYDgkxHAo4PByEznOBgQYoG5IjF8bdubQJbJHQh/bj5EkzeKDggD37ED0fTdWIiJ\n" +
+  "Nhh0/q2Y7QKBgGlLMsoWbjGJMqbcCG4KpfJdqghcWe9Agh982mrUwmU0kczHxoYg\n" +
+  "WYi/4P1iszcE/5BNOd0baOfpChb89PdZIfN1xJ6JD+ycBCUct3UCK16g7c6p8BZh\n" +
+  "ppwKzwyFNZ7JvuDx0xPKgh8XIoVVBoWRx55v8ssZxffePHBoQSHqT7LnAoGAB1vO\n" +
+  "opq2C7F0PScmJ4WkE8xMRHSNTKELmDDwpeGOOUB789hzQeYLaULncVrnu0UeXVPR\n" +
+  "8w0ID2GwN6L/uyVga9XRyEJfTdMizznPc2guOBxDj+2iUruMtdzE3l9P7Dug03dz\n" +
+  "jPxQ+UixYpT4bUbCKFIhCgC+svKwXETsdCt1cqkCgYBVSSabJNSvFfqYz/VJbRK7\n" +
+  "cvxEr3mcV/I/+5BoyTmTKQGkIRl6xCMhqZk019hXbdN66jMQ9zg6wni4UKA43cXI\n" +
+  "/3NHY86IvdpLORlYqKVHycZsqSVQE6Z3V1G4C2wVKUZtWsoT6Wr+Ind+V+VzbDD2\n" +
+  "wHbW4FhxHN9iwdHfmJyq+g==\n" +
+  "-----END PRIVATE KEY-----\n";
+
+const TEST_SERVICE_ACCOUNT = JSON.stringify({
+  type: "service_account",
+  client_email: "test@example.com",
+  private_key: TEST_PRIVATE_KEY,
+  token_uri: "https://oauth2.googleapis.com/token",
+});
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("service-account-token", () => {
+  // -- parseServiceAccountKey ------------------------------------------------
+
+  describe("parseServiceAccountKey", () => {
+    test("returns null for empty string", () => {
+      expect(parseServiceAccountKey("")).toBeNull();
+    });
+
+    test("returns null for invalid JSON", () => {
+      expect(parseServiceAccountKey("not-json")).toBeNull();
+    });
+
+    test("returns null when required fields are missing", () => {
+      expect(
+        parseServiceAccountKey(
+          JSON.stringify({ client_email: "test@example.com" }),
+        ),
+      ).toBeNull();
+    });
+
+    test("returns the key when all required fields are present", () => {
+      const key = parseServiceAccountKey(TEST_SERVICE_ACCOUNT);
+      expect(key).not.toBeNull();
+      expect(key?.client_email).toBe("test@example.com");
+    });
+  });
+
+  // -- getValidServiceAccountToken -------------------------------------------
+
+  test("returns not_found when no credential is stored", async () => {
+    const result = await getValidServiceAccountToken("credential/vertex-ai");
+    expect(result).toEqual({ ok: false, reason: "not_found" });
+  });
+
+  test("returns invalid_config when credential is not valid JSON", async () => {
+    vaultStore.set("credential/vertex-ai", "not-json");
+    const result = await getValidServiceAccountToken("credential/vertex-ai");
+    expect(result).toEqual({ ok: false, reason: "invalid_config" });
+  });
+
+  test("returns invalid_config when credential JSON is missing required fields", async () => {
+    vaultStore.set(
+      "credential/vertex-ai",
+      JSON.stringify({ client_email: "missing-other-fields@example.com" }),
+    );
+    const result = await getValidServiceAccountToken("credential/vertex-ai");
+    expect(result).toEqual({ ok: false, reason: "invalid_config" });
+  });
+
+  test("returns cached token when the cache blob is still fresh", async () => {
+    const futureExpiry = Math.floor(Date.now() / 1000) + 7200;
+    vaultStore.set("credential/vertex-ai", TEST_SERVICE_ACCOUNT);
+    vaultStore.set(
+      "credential/vertex-ai/token_cache",
+      JSON.stringify({
+        access_token: "cached-token",
+        expires_at: futureExpiry,
+      }),
+    );
+
+    const result = await getValidServiceAccountToken("credential/vertex-ai");
+    expect(result).toEqual({ ok: true, token: "cached-token" });
+    // Nothing new should have been written (no exchange performed).
+    expect(writtenKeys.size).toBe(0);
+  });
+
+  test("returns cached token when cache blob has no expiry", async () => {
+    vaultStore.set("credential/vertex-ai", TEST_SERVICE_ACCOUNT);
+    vaultStore.set(
+      "credential/vertex-ai/token_cache",
+      JSON.stringify({ access_token: "no-expiry-token" }),
+    );
+
+    const result = await getValidServiceAccountToken("credential/vertex-ai");
+    expect(result).toEqual({ ok: true, token: "no-expiry-token" });
+  });
+
+  test("coalesces concurrent callers for the same credential onto one exchange", async () => {
+    const pastExpiry = Math.floor(Date.now() / 1000) - 600;
+    vaultStore.set("credential/vertex-ai", TEST_SERVICE_ACCOUNT);
+    vaultStore.set(
+      "credential/vertex-ai/token_cache",
+      JSON.stringify({ access_token: "stale-token", expires_at: pastExpiry }),
+    );
+
+    let fetchCallCount = 0;
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async () => {
+      fetchCallCount += 1;
+      return {
+        ok: true,
+        json: async () => ({ access_token: "new-token", expires_in: 3600 }),
+      } as Response;
+    }) as unknown as typeof fetch;
+
+    try {
+      const [r1, r2] = await Promise.all([
+        getValidServiceAccountToken("credential/vertex-ai"),
+        getValidServiceAccountToken("credential/vertex-ai"),
+      ]);
+
+      expect(r1).toEqual({ ok: true, token: "new-token" });
+      expect(r2).toEqual({ ok: true, token: "new-token" });
+      expect(fetchCallCount).toBe(1);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("concurrent callers for different credentials exchange independently", async () => {
+    vaultStore.set("credential/vertex-a", TEST_SERVICE_ACCOUNT);
+    vaultStore.set("credential/vertex-b", TEST_SERVICE_ACCOUNT);
+
+    let fetchCallCount = 0;
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async () => {
+      fetchCallCount += 1;
+      return {
+        ok: true,
+        json: async () => ({
+          access_token: `token-${fetchCallCount}`,
+          expires_in: 3600,
+        }),
+      } as Response;
+    }) as unknown as typeof fetch;
+
+    try {
+      const [r1, r2] = await Promise.all([
+        getValidServiceAccountToken("credential/vertex-a"),
+        getValidServiceAccountToken("credential/vertex-b"),
+      ]);
+
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
+      // Each credential triggers its own exchange.
+      expect(fetchCallCount).toBe(2);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("caches token+expiry as a single JSON blob", async () => {
+    vaultStore.set("credential/vertex-ai", TEST_SERVICE_ACCOUNT);
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async () => ({
+      ok: true,
+      json: async () => ({ access_token: "fresh-token", expires_in: 3600 }),
+    })) as unknown as typeof fetch;
+
+    try {
+      await getValidServiceAccountToken("credential/vertex-ai");
+
+      const blob = vaultStore.get("credential/vertex-ai/token_cache");
+      expect(blob).toBeDefined();
+      const parsed = JSON.parse(blob!) as {
+        access_token: string;
+        expires_at: number;
+      };
+      expect(parsed.access_token).toBe("fresh-token");
+      expect(typeof parsed.expires_at).toBe("number");
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});

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 ─────────────────────────────────────────────────

package/src/__tests__/watch-retro-tool-availability.test.ts

@@ -1,13 +1,10 @@
 /**
  * The gate that decides whether a watch retrospective can report at all.
  *
- * A retrospective runs as a `clientless` wake, which pins the turn
- * non-interactive. `conversation-tool-setup` gates the whole `ui_surface`
- * family on a client being present, so in that turn `ui_show` is not denied,
- * it is absent: a retrospective told to call it can only tell the user it
- * cannot. Nothing about the card's schema, its renderer, or the prompt's
- * wording reveals that, which is why it is asserted here against the real
- * registry rather than assumed anywhere else.
+ * A retrospective runs as a `clientless` wake, but its report continues to
+ * use the post-turn renderer so the report lands after its tool call has been
+ * persisted. The core UI tools remain available on that turn for other
+ * background work, so this file pins both contracts against the real registry.
  */
 
 import { afterAll, describe, expect, test } from "bun:test";
@@ -54,20 +51,14 @@ describe("watch retrospective tool availability", () => {
     ).toBe(true);
   });
 
-  test("ui_show is absent from a clientless turn", async () => {
+  test("core UI tools stay available on a clientless turn", async () => {
     await initializeTools();
     const ctx = clientlessContext();
 
-    // The reason the report does not go through `ui_show`. If this ever flips
-    // to true, the extra tool above can be reconsidered; while it is false,
-    // routing the retrospective's card through `ui_show` produces a turn that
-    // cannot report at all.
-    expect(isToolActiveForContext("ui_show", ctx)).toBe(false);
-    expect(isToolActiveForContext("ui_update", ctx)).toBe(false);
-    expect(isToolActiveForContext("ui_dismiss", ctx)).toBe(false);
+    for (const name of ["ui_show", "ui_update", "ui_dismiss"]) {
+      expect(isToolActiveForContext(name, ctx)).toBe(true);
+    }
 
-    // And the gate really is about the client, not about the tools being
-    // unregistered: with one attached, the same names are active.
     const withClient = clientfulContext();
     expect(isToolActiveForContext("ui_show", withClient)).toBe(true);
   });