@vellumai/assistant 0.6.4 → 0.6.5

package/src/__tests__/secret-ingress-http.test.ts

@@ -7,6 +7,34 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 const BASE_CONFIG = {
   contextWindow: { maxInputTokens: 100000 },
   services: { inference: { model: "test-model", provider: "test-provider" } },
+  llm: {
+    default: {
+      provider: "anthropic",
+      model: "claude-opus-4-7",
+      maxTokens: 64000,
+      effort: "max" as const,
+      speed: "standard" as const,
+      temperature: null,
+      thinking: { enabled: true, streamThinking: true },
+      contextWindow: {
+        enabled: true,
+        maxInputTokens: 200000,
+        targetBudgetRatio: 0.3,
+        compactThreshold: 0.8,
+        summaryBudgetRatio: 0.05,
+        overflowRecovery: {
+          enabled: true,
+          safetyMarginRatio: 0.05,
+          maxAttempts: 3,
+          interactiveLatestTurnCompression: "summarize",
+          nonInteractiveLatestTurnCompression: "truncate",
+        },
+      },
+    },
+    profiles: {},
+    callSites: {},
+    pricingOverrides: [],
+  },
 };
 
 let mockConfig: Record<string, unknown> = {

package/src/__tests__/secret-prompter-channel-fallback.test.ts

@@ -0,0 +1,125 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type {
+  SecretRequest,
+  ServerMessage,
+} from "../daemon/message-protocol.js";
+
+// Use a tiny timeout so the setTimeout branch fires quickly in tests
+const mockConfig = {
+  timeouts: { permissionTimeoutSec: 0.01 },
+  secretDetection: { allowOneTimeSend: false },
+};
+mock.module("../config/loader.js", () => ({
+  getConfig: () => mockConfig,
+  loadConfig: () => mockConfig,
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+    child: () => ({
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      debug: () => {},
+    }),
+  }),
+}));
+
+const { SecretPrompter } = await import("../permissions/secret-prompter.js");
+
+describe("secret prompter channel fallback", () => {
+  let sentMessages: ServerMessage[];
+  let broadcastMessages: ServerMessage[];
+
+  beforeEach(() => {
+    sentMessages = [];
+    broadcastMessages = [];
+  });
+
+  test("fails fast with unsupported_channel error when channel lacks dynamic UI and no broadcast available", async () => {
+    const prompter = new SecretPrompter((msg) => sentMessages.push(msg));
+    prompter.setChannelContext({
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await prompter.prompt("myservice", "apikey", "API Key");
+
+    expect(result.value).toBeNull();
+    expect(result.error).toBe("unsupported_channel");
+    // No message should have been sent since we failed fast
+    expect(sentMessages).toHaveLength(0);
+  });
+
+  test("broadcasts secret_request via SSE hub when channel lacks dynamic UI but broadcast is available", async () => {
+    const prompter = new SecretPrompter(
+      (msg) => sentMessages.push(msg),
+      (msg) => broadcastMessages.push(msg),
+    );
+    prompter.setChannelContext({
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const promise = prompter.prompt("myservice", "apikey", "API Key");
+
+    // Should have broadcast the message, not sent via per-channel sender
+    expect(sentMessages).toHaveLength(0);
+    expect(broadcastMessages).toHaveLength(1);
+    expect(broadcastMessages[0]!.type).toBe("secret_request");
+
+    // Resolve the prompt so it doesn't hang
+    const requestId = (broadcastMessages[0] as SecretRequest).requestId;
+    prompter.resolveSecret(requestId, "test-secret", "store");
+    const result = await promise;
+    expect(result.value).toBe("test-secret");
+    expect(result.error).toBeUndefined();
+  });
+
+  test("uses sendToClient when channel supports dynamic UI", async () => {
+    const prompter = new SecretPrompter(
+      (msg) => sentMessages.push(msg),
+      (msg) => broadcastMessages.push(msg),
+    );
+    prompter.setChannelContext({
+      channel: "macos",
+      supportsDynamicUi: true,
+    });
+
+    const promise = prompter.prompt("myservice", "apikey", "API Key");
+
+    // Should use per-channel sender, not broadcast
+    expect(sentMessages).toHaveLength(1);
+    expect(broadcastMessages).toHaveLength(0);
+    expect(sentMessages[0]!.type).toBe("secret_request");
+
+    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    prompter.resolveSecret(requestId, "test-secret", "store");
+    await promise;
+  });
+
+  test("uses sendToClient when no channel context is set (desktop default)", async () => {
+    const prompter = new SecretPrompter(
+      (msg) => sentMessages.push(msg),
+      (msg) => broadcastMessages.push(msg),
+    );
+    // No setChannelContext call — desktop default
+
+    const promise = prompter.prompt("myservice", "apikey", "API Key");
+
+    expect(sentMessages).toHaveLength(1);
+    expect(broadcastMessages).toHaveLength(0);
+
+    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    prompter.resolveSecret(requestId, "val", "store");
+    await promise;
+  });
+});

package/src/__tests__/secret-routes-managed-proxy.test.ts

@@ -11,7 +11,7 @@ let providerRefreshCalls = 0;
 const PLATFORM_BASE_URL = "https://platform.example.com";
 const ASSISTANT_API_KEY_PATH = credentialKey("vellum", "assistant_api_key");
 const PLATFORM_BASE_URL_PATH = credentialKey("vellum", "platform_base_url");
-const MANAGED_PROVIDERS = ["anthropic", "gemini"] as const;
+const MANAGED_PROVIDERS = ["anthropic", "openai", "gemini"] as const;
 
 let platformBaseUrlOverride: string | undefined;
 
@@ -19,8 +19,6 @@ const mockConfig = {
   services: {
     inference: {
       mode: "your-own" as const,
-      provider: "anthropic",
-      model: "test-model",
     },
     "image-generation": {
       mode: "your-own" as const,
@@ -32,6 +30,7 @@ const mockConfig = {
       provider: "inference-provider-native",
     },
   },
+  llm: { default: { provider: "anthropic", model: "test-model" } },
 };
 
 mock.module("@google/genai", () => ({

package/src/__tests__/secret-scanner-executor.test.ts

@@ -50,7 +50,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../permissions/checker.js", () => ({
-  classifyRisk: () => "low",
+  classifyRisk: () => ({ level: "low" }),
   check: () => ({ decision: "allow" }),
   generateAllowlistOptions: () => [],
   generateScopeOptions: () => [],

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

@@ -39,11 +39,39 @@ mock.module("../config/loader.js", () => ({
     rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
     contextWindow: { maxInputTokens: 200000 },
+    llm: {
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        maxTokens: 64000,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: true, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 200000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
     services: {
       inference: {
         mode: "your-own",
         provider: "anthropic",
-        model: "claude-opus-4-6",
+        model: "claude-opus-4-7",
       },
       "image-generation": {
         mode: "your-own",

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

@@ -332,6 +332,37 @@ describe("renderHistoryContent", () => {
     expect(output.textSegments).toEqual(["Now let me try something else."]);
     expect(output.contentOrder).toEqual(["tool:0", "text:0", "tool:1"]);
   });
+
+  test("drops Anthropic placeholder sentinel text blocks from history", () => {
+    // Sentinels are injected into outbound API requests for role alternation
+    // and must never render to the UI. Guards against any leak path that
+    // bypasses cleanAssistantContent (bug-prone stored rows, historical
+    // data predating migration 222, future regressions).
+    const output = renderHistoryContent([
+      { type: "text", text: "Real response before." },
+      { type: "text", text: "\x00__PLACEHOLDER__[empty assistant turn]" },
+      { type: "text", text: "__PLACEHOLDER__[empty assistant turn]" },
+      { type: "text", text: "\x00__PLACEHOLDER__[internal blocks omitted]" },
+      { type: "text", text: "__PLACEHOLDER__[internal blocks omitted]" },
+      { type: "text", text: "Real response after." },
+    ]);
+
+    expect(output.text).toBe("Real response before. Real response after.");
+    expect(output.textSegments).toEqual([
+      "Real response before. Real response after.",
+    ]);
+    expect(output.contentOrder).toEqual(["text:0"]);
+  });
+
+  test("yields empty output when content is only a placeholder sentinel", () => {
+    const output = renderHistoryContent([
+      { type: "text", text: "\x00__PLACEHOLDER__[empty assistant turn]" },
+    ]);
+
+    expect(output.text).toBe("");
+    expect(output.textSegments).toEqual([]);
+    expect(output.contentOrder).toEqual([]);
+  });
 });
 
 describe("getAttachmentsForMessage", () => {

package/src/__tests__/shell-parser-property.test.ts

@@ -68,7 +68,7 @@ describe("Shell parser property-based tests", () => {
           async (program, args) => {
             const command = [program, ...args].join(" ");
             const risk = await classifyRisk("bash", { command });
-            expect(risk).toBe(RiskLevel.High);
+            expect(risk.level).toBe(RiskLevel.High);
           },
         ),
         { numRuns: 200, ...FC_OPTS },
@@ -83,7 +83,7 @@ describe("Shell parser property-based tests", () => {
           async (flag, target) => {
             const command = `rm ${flag} ${target}`;
             const risk = await classifyRisk("bash", { command });
-            expect(risk).toBe(RiskLevel.High);
+            expect(risk.level).toBe(RiskLevel.High);
           },
         ),
         { numRuns: 100, ...FC_OPTS },
@@ -95,7 +95,7 @@ describe("Shell parser property-based tests", () => {
         fc.asyncProperty(fc.constantFrom("/", "~", "$HOME"), async (target) => {
           const command = `rm ${target}`;
           const risk = await classifyRisk("bash", { command });
-          expect(risk).toBe(RiskLevel.High);
+          expect(risk.level).toBe(RiskLevel.High);
         }),
         { numRuns: 10, ...FC_OPTS },
       );
@@ -112,7 +112,7 @@ describe("Shell parser property-based tests", () => {
           async (program, args) => {
             const command = ["sudo", program, ...args].join(" ");
             const risk = await classifyRisk("bash", { command });
-            expect(risk).toBe(RiskLevel.High);
+            expect(risk.level).toBe(RiskLevel.High);
           },
         ),
         { numRuns: 100, ...FC_OPTS },
@@ -133,7 +133,7 @@ describe("Shell parser property-based tests", () => {
             const args = kvPairs.map(([k, v]) => `${k}=${v}`);
             const command = ["dd", ...args].join(" ");
             const risk = await classifyRisk("bash", { command });
-            expect(risk).toBe(RiskLevel.High);
+            expect(risk.level).toBe(RiskLevel.High);
           },
         ),
         { numRuns: 50, ...FC_OPTS },
@@ -180,7 +180,7 @@ describe("Shell parser property-based tests", () => {
           async (program, args) => {
             const command = [program, ...args].join(" ");
             const risk = await classifyRisk("bash", { command });
-            expect(risk).toBe(RiskLevel.Low);
+            expect(risk.level).toBe(RiskLevel.Low);
           },
         ),
         { numRuns: 200, ...FC_OPTS },
@@ -208,7 +208,7 @@ describe("Shell parser property-based tests", () => {
           async (subcommand) => {
             const command = `git ${subcommand}`;
             const risk = await classifyRisk("bash", { command });
-            expect(risk).toBe(RiskLevel.Low);
+            expect(risk.level).toBe(RiskLevel.Low);
           },
         ),
         { numRuns: 100, ...FC_OPTS },
@@ -227,7 +227,7 @@ describe("Shell parser property-based tests", () => {
           async (safe, dangerous) => {
             const command = `${safe} something | ${dangerous}`;
             const risk = await classifyRisk("bash", { command });
-            expect(risk).toBe(RiskLevel.High);
+            expect(risk.level).toBe(RiskLevel.High);
           },
         ),
         { numRuns: 50, ...FC_OPTS },
@@ -242,7 +242,7 @@ describe("Shell parser property-based tests", () => {
           async (safe, dangerous) => {
             const command = `${safe} && ${dangerous}`;
             const risk = await classifyRisk("bash", { command });
-            expect(risk).toBe(RiskLevel.High);
+            expect(risk.level).toBe(RiskLevel.High);
           },
         ),
         { numRuns: 50, ...FC_OPTS },
@@ -289,7 +289,7 @@ describe("Shell parser property-based tests", () => {
           async (commands) => {
             const command = commands.join(" | ");
             const risk = await classifyRisk("bash", { command });
-            expect(risk).toBe(RiskLevel.Low);
+            expect(risk.level).toBe(RiskLevel.Low);
           },
         ),
         { numRuns: 100, ...FC_OPTS },
@@ -340,7 +340,7 @@ describe("Shell parser property-based tests", () => {
           async (input) => {
             const risk = await classifyRisk("bash", { command: input });
             expect([RiskLevel.Low, RiskLevel.Medium, RiskLevel.High]).toContain(
-              risk,
+              risk.level,
             );
           },
         ),
@@ -417,7 +417,7 @@ describe("Shell parser property-based tests", () => {
 
     test("empty command classifies as low risk", async () => {
       const risk = await classifyRisk("bash", { command: "" });
-      expect(risk).toBe(RiskLevel.Low);
+      expect(risk.level).toBe(RiskLevel.Low);
     });
 
     test("whitespace-only commands classify as low risk (trimmed to empty)", async () => {
@@ -429,7 +429,7 @@ describe("Shell parser property-based tests", () => {
           }),
           async (ws) => {
             const risk = await classifyRisk("bash", { command: ws });
-            expect(risk).toBe(RiskLevel.Low);
+            expect(risk.level).toBe(RiskLevel.Low);
           },
         ),
         { numRuns: 50, ...FC_OPTS },

package/src/__tests__/skill-cache-store.test.ts

@@ -0,0 +1,182 @@
+import { afterEach, describe, expect, test } from "bun:test";
+
+import {
+  _internals,
+  clearCacheForTests,
+  deleteCacheEntry,
+  getCacheEntry,
+  setCacheEntry,
+} from "../skills/skill-cache-store.js";
+
+afterEach(() => {
+  clearCacheForTests();
+});
+
+describe("setCacheEntry", () => {
+  test("auto-generated key is a 16-char lowercase hex string", () => {
+    const { key } = setCacheEntry("hello");
+    expect(key).toHaveLength(16);
+    expect(key).toMatch(/^[0-9a-f]{16}$/);
+  });
+
+  test("each auto-generated key is unique", () => {
+    const keys = new Set<string>();
+    for (let i = 0; i < 20; i++) {
+      keys.add(setCacheEntry(i).key);
+    }
+    expect(keys.size).toBe(20);
+  });
+
+  test("explicit key stores and retrieves correctly", () => {
+    setCacheEntry({ foo: "bar" }, { key: "my-key" });
+    const result = getCacheEntry("my-key");
+    expect(result).toEqual({ data: { foo: "bar" } });
+  });
+
+  test("explicit key upsert overwrites existing value", () => {
+    setCacheEntry("v1", { key: "same" });
+    setCacheEntry("v2", { key: "same" });
+    const result = getCacheEntry("same");
+    expect(result).toEqual({ data: "v2" });
+    // Only one entry in the store for this key.
+    let count = 0;
+    for (const k of _internals.store.keys()) {
+      if (k === "same") count++;
+    }
+    expect(count).toBe(1);
+  });
+
+  test("upsert refreshes insertion order (LRU position)", () => {
+    setCacheEntry("a", { key: "first" });
+    setCacheEntry("b", { key: "second" });
+    // Upsert 'first' — it should move to the end.
+    setCacheEntry("a-updated", { key: "first" });
+
+    const keys = [..._internals.store.keys()];
+    expect(keys).toEqual(["second", "first"]);
+  });
+
+  test("upsert resets expiry timestamp", () => {
+    setCacheEntry("v1", { key: "k", ttlMs: 1000 });
+    const expiryBefore = _internals.store.get("k")!.expiresAt;
+
+    // Small delay to ensure Date.now() advances.
+    const start = Date.now();
+    while (Date.now() === start) {
+      /* busy-wait for at least 1ms */
+    }
+
+    setCacheEntry("v2", { key: "k", ttlMs: 5000 });
+    const expiryAfter = _internals.store.get("k")!.expiresAt;
+    expect(expiryAfter).toBeGreaterThan(expiryBefore);
+  });
+});
+
+describe("getCacheEntry", () => {
+  test("returns data for a valid key", () => {
+    const { key } = setCacheEntry(42);
+    expect(getCacheEntry(key)).toEqual({ data: 42 });
+  });
+
+  test("returns null for an unknown key", () => {
+    expect(getCacheEntry("nonexistent")).toBeNull();
+  });
+
+  test("refreshes LRU position on access", () => {
+    setCacheEntry("a", { key: "k1" });
+    setCacheEntry("b", { key: "k2" });
+    setCacheEntry("c", { key: "k3" });
+
+    // Access k1 — should move to the end.
+    getCacheEntry("k1");
+
+    const keys = [..._internals.store.keys()];
+    expect(keys).toEqual(["k2", "k3", "k1"]);
+  });
+});
+
+describe("TTL expiry (lazy eviction)", () => {
+  test("expired entry returns null and is removed from the store", () => {
+    setCacheEntry("ephemeral", { key: "ttl-test", ttlMs: 1 });
+
+    // Wait for the TTL to elapse.
+    const deadline = Date.now() + 2;
+    while (Date.now() < deadline) {
+      /* busy-wait */
+    }
+
+    expect(getCacheEntry("ttl-test")).toBeNull();
+    expect(_internals.store.has("ttl-test")).toBe(false);
+  });
+
+  test("non-expired entry is still accessible", () => {
+    setCacheEntry("durable", { key: "long-lived", ttlMs: 60_000 });
+    expect(getCacheEntry("long-lived")).toEqual({ data: "durable" });
+  });
+
+  test("default TTL is 30 minutes", () => {
+    expect(_internals.DEFAULT_TTL_MS).toBe(30 * 60_000);
+  });
+});
+
+describe("LRU eviction at capacity", () => {
+  test("evicts oldest entry when at max capacity", () => {
+    const maxEntries = _internals.DEFAULT_MAX_ENTRIES; // 64
+
+    // Fill the store to capacity.
+    for (let i = 0; i < maxEntries; i++) {
+      setCacheEntry(i, { key: `entry-${i}` });
+    }
+    expect(_internals.store.size).toBe(maxEntries);
+
+    // One more insert should evict the oldest (entry-0).
+    setCacheEntry("overflow", { key: "new-entry" });
+    expect(_internals.store.size).toBe(maxEntries);
+    expect(getCacheEntry("entry-0")).toBeNull();
+    expect(getCacheEntry("new-entry")).toEqual({ data: "overflow" });
+  });
+
+  test("default max entries is 64", () => {
+    expect(_internals.DEFAULT_MAX_ENTRIES).toBe(64);
+  });
+
+  test("upsert at capacity does not evict (key already exists)", () => {
+    const maxEntries = _internals.DEFAULT_MAX_ENTRIES;
+    for (let i = 0; i < maxEntries; i++) {
+      setCacheEntry(i, { key: `entry-${i}` });
+    }
+
+    // Upsert an existing key — should not evict anything.
+    setCacheEntry("updated", { key: "entry-0" });
+    expect(_internals.store.size).toBe(maxEntries);
+    expect(getCacheEntry("entry-0")).toEqual({ data: "updated" });
+    expect(getCacheEntry("entry-1")).toEqual({ data: 1 });
+  });
+});
+
+describe("deleteCacheEntry", () => {
+  test("returns true when deleting an existing key", () => {
+    setCacheEntry("x", { key: "del" });
+    expect(deleteCacheEntry("del")).toBe(true);
+    expect(getCacheEntry("del")).toBeNull();
+  });
+
+  test("returns false for an unknown key (idempotent)", () => {
+    expect(deleteCacheEntry("ghost")).toBe(false);
+  });
+
+  test("double delete is idempotent", () => {
+    setCacheEntry("x", { key: "once" });
+    expect(deleteCacheEntry("once")).toBe(true);
+    expect(deleteCacheEntry("once")).toBe(false);
+  });
+});
+
+describe("clearCacheForTests", () => {
+  test("empties the entire store", () => {
+    setCacheEntry("a", { key: "k1" });
+    setCacheEntry("b", { key: "k2" });
+    clearCacheForTests();
+    expect(_internals.store.size).toBe(0);
+  });
+});

package/src/__tests__/skills.test.ts

@@ -520,9 +520,16 @@ describe("includes frontmatter parsing", () => {
   });
 });
 
-describe("bundled browser skill", () => {
+describe("managed browser skill", () => {
+  const BROWSER_SKILL_MD = readFileSync(
+    join(import.meta.dirname, "../../../skills/vellum-browser-use/SKILL.md"),
+    "utf-8",
+  );
+
   beforeEach(() => {
-    mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
+    const skillDir = join(TEST_DIR, "skills", "vellum-browser-use");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), BROWSER_SKILL_MD);
   });
 
   afterEach(() => {
@@ -531,51 +538,30 @@ describe("bundled browser skill", () => {
       rmSync(skillsDir, { recursive: true, force: true });
   });
 
-  test("browser skill appears in full catalog (including bundled)", () => {
+  test("browser skill appears in full catalog", () => {
     const catalog = loadSkillCatalog();
-    const browserSkill = catalog.find((s) => s.id === "browser");
+    const browserSkill = catalog.find((s) => s.id === "vellum-browser-use");
     expect(browserSkill).toBeDefined();
-    expect(browserSkill!.name).toBe("browser");
+    expect(browserSkill!.name).toBe("vellum-browser-use");
     expect(browserSkill!.displayName).toBe("Browser");
-    expect(browserSkill!.bundled).toBe(true);
   });
 
   test("browser skill has correct metadata", () => {
     const catalog = loadSkillCatalog();
-    const browserSkill = catalog.find((s) => s.id === "browser");
+    const browserSkill = catalog.find((s) => s.id === "vellum-browser-use");
     expect(browserSkill).toBeDefined();
     expect(browserSkill!.description).toBe(
-      "Navigate and interact with web pages using a headless browser",
+      "Browse the web using `assistant browser` CLI commands",
     );
   });
 
-  test("browser skill has a valid tool manifest with all browser tools", () => {
+  test("browser skill has no tool manifest", () => {
     const catalog = loadSkillCatalog();
-    const browserSkill = catalog.find((s) => s.id === "browser");
+    const browserSkill = catalog.find((s) => s.id === "vellum-browser-use");
     expect(browserSkill).toBeDefined();
-    expect(browserSkill!.toolManifest).toBeDefined();
-    expect(browserSkill!.toolManifest!.present).toBe(true);
-    expect(browserSkill!.toolManifest!.valid).toBe(true);
-    expect(browserSkill!.toolManifest!.toolCount).toBe(17);
-    expect(browserSkill!.toolManifest!.toolNames).toEqual([
-      "browser_navigate",
-      "browser_snapshot",
-      "browser_screenshot",
-      "browser_close",
-      "browser_attach",
-      "browser_detach",
-      "browser_click",
-      "browser_type",
-      "browser_press_key",
-      "browser_scroll",
-      "browser_select_option",
-      "browser_hover",
-      "browser_wait_for",
-      "browser_extract",
-      "browser_wait_for_download",
-      "browser_fill_credential",
-      "browser_status",
-    ]);
+    // Browser tools are dispatched via skill_execute and do not use
+    // a skill-tool manifest.
+    expect(browserSkill!.toolManifest).toBeUndefined();
   });
 });
 

package/src/__tests__/slack-app-setup-skill-regression.test.ts

@@ -19,7 +19,9 @@ describe("slack-app-setup skill regression", () => {
 
   test("forbids plaintext forms and chat-pasted secrets", () => {
     expect(skillContent).toContain("Do NOT use `ui_show`");
-    expect(skillContent).toContain("Do NOT ask the user to paste them in chat");
+    expect(skillContent).toContain(
+      "Do NOT ask the user to paste tokens in chat",
+    );
   });
 
   test("does not instruct the agent to reimplement Slack validation in shell", () => {