@vellumai/assistant 0.12.2-staging.1 → 0.12.2-staging.3

package/src/__tests__/mcp-health-check.test.ts

@@ -1,23 +1,19 @@
 import { beforeEach, describe, expect, jest, mock, test } from "bun:test";
 
-const mockConnect = jest.fn();
-const mockDisconnect = jest.fn();
-let mockIsConnected = true;
-let mockLastError: Error | null = null;
+const getServerState = jest.fn();
 
 mock.module("../mcp/client.js", () => ({
   McpClient: class {
-    get isConnected() {
-      return mockIsConnected;
+    constructor() {
+      throw new Error("list route must not construct an MCP client");
     }
-    get lastError() {
-      return mockLastError;
-    }
-    connect = mockConnect;
-    disconnect = mockDisconnect;
   },
 }));
 
+mock.module("../mcp/manager.js", () => ({
+  getMcpServerManager: () => ({ getServerState }),
+}));
+
 import { setWorkspaceMcp } from "./helpers/set-workspace-mcp.js";
 
 // Seed the MCP server the list route reads from workspace mcp.json.
@@ -56,28 +52,22 @@ const listHandler = ROUTES.find(
   (r: { operationId: string }) => r.operationId === "internal_mcp_list",
 )!.handler;
 
-describe("checkServerHealth (via internal_mcp_list route)", () => {
+describe("internal_mcp_list runtime status", () => {
   beforeEach(() => {
-    mockConnect.mockReset();
-    mockDisconnect.mockReset();
-    mockIsConnected = true;
-    mockLastError = null;
+    getServerState.mockReset();
   });
 
-  test("returns connected when server connects successfully", async () => {
-    mockConnect.mockResolvedValue(undefined);
-    mockDisconnect.mockResolvedValue(undefined);
+  test("returns connected from the manager's recorded state", async () => {
+    getServerState.mockReturnValue("connected");
 
     const result = (await listHandler({})) as {
       servers: { status: string }[];
     };
     expect(result.servers[0].status).toBe("connected");
-    expect(mockDisconnect).toHaveBeenCalled();
   });
 
-  test("returns needs-auth when isConnected is false and no lastError", async () => {
-    mockConnect.mockResolvedValue(undefined);
-    mockIsConnected = false;
+  test("returns needs-auth from the manager's recorded state", async () => {
+    getServerState.mockReturnValue("needs-auth");
 
     const result = (await listHandler({})) as {
       servers: { status: string }[];
@@ -85,15 +75,25 @@ describe("checkServerHealth (via internal_mcp_list route)", () => {
     expect(result.servers[0].status).toBe("needs-auth");
   });
 
-  test("returns error when connect fails with lastError", async () => {
-    mockConnect.mockResolvedValue(undefined);
-    mockIsConnected = false;
-    mockLastError = new Error("Connection refused");
-    mockDisconnect.mockResolvedValue(undefined);
+  test.each([undefined, "connecting", "error"])(
+    "returns the legacy error status for runtime state %s",
+    async (runtimeState) => {
+      getServerState.mockReturnValue(runtimeState);
 
-    const result = (await listHandler({})) as {
-      servers: { status: string }[];
-    };
-    expect(result.servers[0].status).toBe("error");
+      const result = (await listHandler({})) as {
+        servers: { status: string }[];
+      };
+      expect(result.servers[0].status).toBe("error");
+    },
+  );
+
+  test("repeated reads do not connect or spawn a configured server", async () => {
+    getServerState.mockReturnValue("connected");
+
+    await listHandler({});
+    await listHandler({});
+
+    expect(getServerState).toHaveBeenCalledTimes(2);
+    expect(getServerState).toHaveBeenCalledWith("test", "workspace");
   });
 });

package/src/__tests__/mcp-list-plugin-servers.test.ts

@@ -8,38 +8,35 @@
  *
  * 1. A workspace entry of the same id wins. Getting precedence backwards
  *    would let a plugin redirect a server the user configured by hand.
- * 2. A plugin server is never health-checked. `McpClient.connect` resolves
- *    `mcp:<serverId>:headers` and `mcp:<serverId>:tokens` from the
- *    credential store, and a plugin controls both its server key and its
- *    URL, so probing one would send a workspace credential to an endpoint
- *    the plugin chose whenever an id happens to match a stored key.
+ * 2. A plugin server is never health-checked as a side effect of listing.
+ *    OAuth status is read from the plugin and endpoint-scoped credential
+ *    identity, while workspace static headers remain isolated.
  */
 
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, jest, mock, test } from "bun:test";
 
-const mockConnect = jest.fn();
-const mockDisconnect = jest.fn();
-/** Server ids the route actually constructed an MCP client for. */
-const connectedServerIds: string[] = [];
+const getServerState = jest.fn();
+const hasMcpOAuthTokens = jest.fn(async (target: any) => {
+  if (target.source === "plugin" && target.url === "not a url") {
+    throw new TypeError("invalid URL");
+  }
+  return true;
+});
 
 mock.module("../mcp/client.js", () => ({
   McpClient: class {
-    constructor(serverId: string) {
-      connectedServerIds.push(serverId);
-    }
-    get isConnected() {
-      return true;
+    constructor() {
+      throw new Error("list route must not construct an MCP client");
     }
-    get lastError() {
-      return null;
-    }
-    connect = mockConnect;
-    disconnect = mockDisconnect;
   },
 }));
 
+mock.module("../mcp/manager.js", () => ({
+  getMcpServerManager: () => ({ getServerState }),
+}));
+
 mock.module("../mcp/mcp-auth-orchestrator.js", () => ({
   orchestrateMcpOAuthConnect: async () => ({
     auth_url: "",
@@ -52,9 +49,7 @@ mock.module("../mcp/mcp-auth-state.js", () => ({
 }));
 
 mock.module("../mcp/mcp-oauth-provider.js", () => ({
-  // Stand in for a credential store that holds tokens for every id, which
-  // is the condition under which a leak would be observable.
-  hasMcpOAuthTokens: async () => true,
+  hasMcpOAuthTokens,
   deleteMcpOAuthCredentials: async () => ({ ok: true, failedKeys: [] }),
 }));
 
@@ -108,6 +103,19 @@ function writePlugin(name: string, mcpJson: unknown): void {
   writeFileSync(join(dir, "mcp.json"), JSON.stringify(mcpJson));
 }
 
+function writeStandardPlugin(name: string, mcpJson: unknown): void {
+  const dir = join(getWorkspacePluginsDir(), name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "plugin.json"),
+    JSON.stringify({
+      $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+      name,
+    }),
+  );
+  writeFileSync(join(dir, "mcp.json"), JSON.stringify(mcpJson));
+}
+
 function unabyssManifest(): unknown {
   return {
     mcpServers: {
@@ -123,9 +131,8 @@ async function listServers(): Promise<ListedServer[]> {
 
 describe("internal_mcp_list, plugin-declared servers", () => {
   beforeEach(() => {
-    mockConnect.mockReset();
-    mockDisconnect.mockReset();
-    connectedServerIds.length = 0;
+    getServerState.mockReset();
+    hasMcpOAuthTokens.mockClear();
     rmSync(getWorkspacePluginsDir(), { recursive: true, force: true });
     mkdirSync(getWorkspacePluginsDir(), { recursive: true });
   });
@@ -138,6 +145,14 @@ describe("internal_mcp_list, plugin-declared servers", () => {
     expect(ids).toContain("unabyss");
   });
 
+  test("a standard-only plugin keeps its server identity", async () => {
+    writeStandardPlugin("unabyss", unabyssManifest());
+
+    const plugin = (await listServers()).find((s) => s.id === "unabyss")!;
+    expect(plugin.source).toBe("plugin");
+    expect(plugin.pluginName).toBe("unabyss");
+  });
+
   test("plugin servers are labelled with their origin, workspace servers are not", async () => {
     writePlugin("unabyss", unabyssManifest());
 
@@ -171,20 +186,36 @@ describe("internal_mcp_list, plugin-declared servers", () => {
     const servers = await listServers();
 
     expect(servers.find((s) => s.id === "unabyss")!.status).toEqual("declared");
-    // The credential mocks above return a token and an Authorization header
-    // for every id. Constructing a client for the plugin server is what
-    // would ship them to the plugin-declared URL.
-    expect(connectedServerIds).toContain("from-workspace");
-    expect(connectedServerIds).not.toContain("unabyss");
+    expect(getServerState).toHaveBeenCalledWith("from-workspace", "workspace");
+    expect(getServerState).toHaveBeenCalledWith("unabyss", "plugin");
   });
 
-  test("plugin servers report no assistant-owned auth even when the store has some", async () => {
+  test("plugin status uses only state recorded for the plugin source", async () => {
+    writePlugin("unabyss", unabyssManifest());
+    getServerState.mockImplementation(
+      (serverId: string, source: "workspace" | "plugin") =>
+        serverId === "unabyss" && source === "plugin" ? "connected" : undefined,
+    );
+
+    const plugin = (await listServers()).find((s) => s.id === "unabyss")!;
+    expect(plugin.status).toBe("connected");
+  });
+
+  test("plugin servers report endpoint-scoped OAuth without static auth", async () => {
     writePlugin("unabyss", unabyssManifest());
 
     const plugin = (await listServers()).find((s) => s.id === "unabyss")!;
-    expect(plugin.hasOAuth).toBe(false);
+    expect(plugin.hasOAuth).toBe(true);
     expect(plugin.hasStaticAuth).toBe(false);
     expect(plugin.authType).toEqual("none");
+    expect(hasMcpOAuthTokens).toHaveBeenCalledWith(
+      expect.objectContaining({
+        source: "plugin",
+        pluginName: "unabyss",
+        serverKey: "unabyss",
+        url: "https://mcp.unabyss.com",
+      }),
+    );
   });
 
   test("workspace servers keep reporting their auth state", async () => {
@@ -225,6 +256,20 @@ describe("internal_mcp_list, plugin-declared servers", () => {
     expect(ids).toContain("from-workspace");
   });
 
+  test("an invalid plugin transport URL does not break the listing", async () => {
+    writePlugin("bad-url", {
+      mcpServers: {
+        remote: { type: "streamable-http", url: "not a url" },
+      },
+    });
+
+    const servers = await listServers();
+    expect(servers.find((s) => s.id === "bad-url__remote")?.hasOAuth).toBe(
+      false,
+    );
+    expect(servers.some((s) => s.id === "from-workspace")).toBe(true);
+  });
+
   test("no plugins installed leaves the listing unchanged", async () => {
     const servers = await listServers();
     expect(servers.every((s) => s.source === "workspace")).toBe(true);

package/src/__tests__/mcp-tool-annotations-risk.test.ts

@@ -32,10 +32,12 @@ const { RiskLevel } = await import("../permissions/types.js");
 type ServerSource = "workspace" | "plugin";
 
 function serverConfig(source: ServerSource) {
-  return {
+  const base = {
     transport: { type: "stdio" as const, command: "echo", args: [] },
-    source,
   };
+  return source === "workspace"
+    ? { ...base, source }
+    : { ...base, source, pluginName: "plugin", serverKey: "server" };
 }
 
 interface RiskAnnotations {

package/src/__tests__/oauth-commands-routes.test.ts

@@ -1165,6 +1165,33 @@ describe("POST oauth/managed-connect/start", () => {
     expect(result.connect_url).toBe("https://app.vellum.ai/connect/abc");
   });
 
+  test("forwards tenant_host to the platform only when one is supplied", async () => {
+    // Shopify's endpoints live on the merchant's host, which the platform
+    // substitutes into its templates; other providers must not see the key.
+    const bodies: Array<Record<string, unknown>> = [];
+    mockFetchImpl = async (_path, init) => {
+      bodies.push(JSON.parse(String(init?.body)) as Record<string, unknown>);
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          connect_url: "https://app.vellum.ai/connect/abc",
+        }),
+        text: async () => "",
+      };
+    };
+    await getRoute("POST", "oauth/managed-connect/start").handler(
+      makeArgs({
+        body: { provider: "shopify", tenant_host: " my-store.myshopify.com " },
+      }),
+    );
+    await getRoute("POST", "oauth/managed-connect/start").handler(
+      makeArgs({ body: { provider: "google", tenant_host: "   " } }),
+    );
+    expect(bodies[0]?.tenant_host).toBe("my-store.myshopify.com");
+    expect(bodies[1]).not.toHaveProperty("tenant_host");
+  });
+
   test("raises InternalError when platform returns 401", async () => {
     mockFetchImpl = async () => ({
       ok: false,
@@ -1228,6 +1255,7 @@ describe("GET oauth/managed-connect/poll", () => {
         id: string;
         account_label: string | null;
         scopes_granted: string[];
+        provider_params: Record<string, string>;
       }>;
     };
     expect(result.ok).toBe(true);
@@ -1236,6 +1264,7 @@ describe("GET oauth/managed-connect/poll", () => {
         id: "conn-1",
         account_label: "alice@example.com",
         scopes_granted: ["email"],
+        provider_params: {},
       },
     ]);
   });
@@ -1248,4 +1277,30 @@ describe("GET oauth/managed-connect/poll", () => {
       ),
     ).rejects.toBeInstanceOf(BadRequestError);
   });
+
+  test("passes through the provider params a connection is scoped by", async () => {
+    // QuickBooks pins the company (realm) the user picked to the connection;
+    // a caller addressing /companyinfo/<realmId> needs it back.
+    mockFetchImpl = async () => ({
+      ok: true,
+      status: 200,
+      json: async () => [
+        {
+          id: "conn-qb",
+          account_label: "Acme Widgets",
+          scopes_granted: ["com.intuit.quickbooks.accounting"],
+          provider_params: { realm_id: "9130357849012345" },
+        },
+      ],
+      text: async () => "",
+    });
+    const result = (await getRoute("GET", "oauth/managed-connect/poll").handler(
+      makeArgs({ queryParams: { provider: "quickbooks" } }),
+    )) as {
+      connections: Array<{ provider_params: Record<string, string> }>;
+    };
+    expect(result.connections[0]?.provider_params).toEqual({
+      realm_id: "9130357849012345",
+    });
+  });
 });

package/src/__tests__/oauth-provider-serializer.test.ts

@@ -291,10 +291,32 @@ describe("serializeProviderSummary", () => {
       supports_managed_mode: true,
       managed_service_is_paid: false,
       feature_flag: null,
+      tenant_host: null,
       acts_as: "user",
     });
   });
 
+  test("exposes the tenant host a per-tenant provider needs at connect", () => {
+    // Shopify's OAuth endpoints live on the merchant's own host, so a client
+    // has to collect it before the managed flow can start. The summary is the
+    // only provider metadata the web client reads, so it carries the ask.
+    const shopify = serializeProviderSummary(makeRow({ provider: "shopify" }))!;
+    expect(shopify.tenant_host).toEqual({
+      pattern: "^[a-z0-9][a-z0-9-]*\\.myshopify\\.com$",
+      label: "Shop domain",
+      placeholder: "your-store.myshopify.com",
+    });
+    expect(
+      new RegExp(shopify.tenant_host!.pattern).test("my-store.myshopify.com"),
+    ).toBe(true);
+    expect(new RegExp(shopify.tenant_host!.pattern).test("evil.com")).toBe(
+      false,
+    );
+    expect(
+      serializeProviderSummary(makeRow({ provider: "github" }))!.tenant_host,
+    ).toBeNull();
+  });
+
   test("names which sense of connected a provider represents", () => {
     // The provider key does not say, and the naming actively misleads:
     // `slack` is the user integration while its bot is `slack_channel`, but

package/src/__tests__/oauth-providers-routes.test.ts

@@ -178,6 +178,7 @@ describe("GET /v1/oauth/providers", () => {
       "supports_managed_mode",
       "managed_service_is_paid",
       "feature_flag",
+      "tenant_host",
       "acts_as",
     ];
 

package/src/__tests__/secret-routes-acp-guard.test.ts

@@ -1,6 +1,11 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { ACP_OAUTH_TOKEN_FIELD, ACP_SERVICE } from "../acp/acp-credentials.js";
+import {
+  ACP_OAUTH_EXPIRES_AT_FIELD,
+  ACP_OAUTH_REFRESH_TOKEN_FIELD,
+  ACP_OAUTH_TOKEN_FIELD,
+  ACP_SERVICE,
+} from "../acp/acp-credentials.js";
 import { credentialKey } from "../security/credential-key.js";
 
 let secureKeyStore: Record<string, string | undefined> = {};
@@ -32,6 +37,11 @@ mock.module("../oauth/manual-token-connection.js", () => ({
   syncManualTokenConnection: async () => {},
 }));
 
+mock.module("../runtime/routes/credential-in-use.js", () => ({
+  assertCredentialNotInUse: () => [],
+  invalidateConnectionsAfterCredentialDelete: () => {},
+}));
+
 afterAll(() => {
   mock.restore();
 });
@@ -42,6 +52,9 @@ import { ROUTES } from "../runtime/routes/secret-routes.js";
 const addRoute = ROUTES.find(
   (r) => r.method === "POST" && r.endpoint === "secrets",
 )!;
+const deleteRoute = ROUTES.find(
+  (r) => r.method === "DELETE" && r.endpoint === "secrets",
+)!;
 
 function addAcpOauthToken(value: string) {
   return addRoute.handler({
@@ -74,4 +87,49 @@ describe("secret routes ACP OAuth-token format guard", () => {
       secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_TOKEN_FIELD)],
     ).toBe("sk-ant-oat01-valid-oauth-token");
   });
+
+  test("stores a pasted Claude token without touching leftover refresh material", async () => {
+    secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_REFRESH_TOKEN_FIELD)] =
+      "stale-refresh";
+    secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_EXPIRES_AT_FIELD)] =
+      "111";
+
+    await addAcpOauthToken("sk-ant-oat01-pasted-token");
+
+    expect(
+      secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_TOKEN_FIELD)],
+    ).toBe("sk-ant-oat01-pasted-token");
+    expect(
+      secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_REFRESH_TOKEN_FIELD)],
+    ).toBe("stale-refresh");
+    expect(
+      secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_EXPIRES_AT_FIELD)],
+    ).toBe("111");
+  });
+
+  test("deletes only the requested Claude access-token field", async () => {
+    secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_TOKEN_FIELD)] =
+      "sk-ant-oat01-connected";
+    secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_REFRESH_TOKEN_FIELD)] =
+      "refresh-leftover";
+    secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_EXPIRES_AT_FIELD)] =
+      "111";
+
+    await deleteRoute.handler({
+      body: {
+        type: "credential",
+        name: `${ACP_SERVICE}:${ACP_OAUTH_TOKEN_FIELD}`,
+      },
+    });
+
+    expect(
+      secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_TOKEN_FIELD)],
+    ).toBeUndefined();
+    expect(
+      secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_REFRESH_TOKEN_FIELD)],
+    ).toBe("refresh-leftover");
+    expect(
+      secureKeyStore[credentialKey(ACP_SERVICE, ACP_OAUTH_EXPIRES_AT_FIELD)],
+    ).toBe("111");
+  });
 });

package/src/__tests__/skills.test.ts

@@ -1054,6 +1054,16 @@ describe("ingress-dependent setup skills declare public-ingress intentionally",
     expect(includes ?? []).not.toContain("public-ingress");
   });
 
+  test("telegram-setup documents the private-chat limitation", () => {
+    const content = readFileSync(
+      join(FIRST_PARTY_SKILLS_DIR, "telegram-setup", "SKILL.md"),
+      "utf-8",
+    );
+    expect(content).toMatch(/private-chat only/i);
+    expect(content).toMatch(/group, supergroup, and channel/i);
+    expect(content).toMatch(/button taps/i);
+  });
+
   test("twilio-setup includes public-ingress", () => {
     const includes = readSkillIncludes(FIRST_PARTY_SKILLS_DIR, "twilio-setup");
     expect(includes).toBeDefined();

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

@@ -88,6 +88,7 @@ import {
 } from "../tools/registry.js";
 import { RiskLevel } from "../tools/tool-types.js";
 import type { Tool } from "../tools/types.js";
+import { uiShowTool } from "../tools/ui-surface/definitions.js";
 import { asConversation } from "./helpers/mock-conversation.js";
 
 // ---------------------------------------------------------------------------
@@ -249,6 +250,56 @@ describe("createResolveToolsCallback — toolContextPin", () => {
     });
   }
 
+  test("Slack and desktop turns keep the same full ui_show schema while surfaces persist", () => {
+    projectedSkillToolNames = [];
+    const slackCaps = {
+      channel: "slack" as const,
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+    const desktopCaps = {
+      channel: "macos" as const,
+      dashboardCapable: true,
+      supportsDynamicUi: true,
+      supportsVoiceInput: true,
+    };
+    const liveSlackResolve = createResolveToolsCallback(
+      [uiShowTool],
+      makeProjectionCtx({
+        hasNoClient: false,
+        channelCapabilities: slackCaps,
+      }),
+    )!;
+    const clientlessSlackResolve = createResolveToolsCallback(
+      [uiShowTool],
+      clientlessExecutionCtx({
+        channelCapabilities: slackCaps,
+      }),
+    )!;
+    const liveDesktopResolve = createResolveToolsCallback(
+      [uiShowTool],
+      makeProjectionCtx({
+        hasNoClient: false,
+        channelCapabilities: desktopCaps,
+      }),
+    )!;
+
+    const [liveSlackUiShow] = liveSlackResolve(EMPTY_HISTORY);
+    const [clientlessSlackUiShow] = clientlessSlackResolve(EMPTY_HISTORY);
+    const [liveDesktopUiShow] = liveDesktopResolve(EMPTY_HISTORY);
+    expect(liveSlackUiShow).toEqual(clientlessSlackUiShow);
+    expect(liveSlackUiShow).toEqual(liveDesktopUiShow);
+    expect(
+      (
+        liveSlackUiShow.input_schema as {
+          properties: { surface_type: { enum: string[] } };
+        }
+      ).properties.surface_type.enum,
+    ).toContain("choice");
+    expect(liveSlackUiShow.description).toContain("dynamic_page");
+  });
+
   test("control: without a pin, a clientless fork drops client-gated tools but keeps host and UI tools", () => {
     projectedSkillToolNames = [];
     const resolve = createResolveToolsCallback(

package/src/__tests__/ui-channel-variants.test.ts

@@ -2,10 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import type { ToolDefinition } from "../providers/types.js";
 import { ACTIVATION_MOMENT_PARAMS } from "../telemetry/activation-funnel.js";
-import {
-  injectActivationMomentParam,
-  projectUiToolsForChannel,
-} from "../tools/ui-surface/channel-variants.js";
+import { injectActivationMomentParam } from "../tools/ui-surface/channel-variants.js";
 import {
   uiDismissTool,
   uiShowTool,
@@ -23,58 +20,6 @@ const defs: ToolDefinition[] = [
   },
 ];
 
-function surfaceTypeEnum(def: ToolDefinition): string[] {
-  return (
-    def.input_schema as { properties: { surface_type: { enum: string[] } } }
-  ).properties.surface_type.enum;
-}
-
-describe("projectUiToolsForChannel", () => {
-  test("returns the same array for channels without a variant", () => {
-    for (const channel of [undefined, "macos", "telegram", "phone"]) {
-      expect(projectUiToolsForChannel(defs, channel)).toBe(defs);
-    }
-  });
-
-  test("slack gets a task_progress-only ui_show", () => {
-    const projected = projectUiToolsForChannel(defs, "slack");
-    const uiShow = projected.find((d) => d.name === "ui_show")!;
-
-    expect(surfaceTypeEnum(uiShow)).toEqual(["card"]);
-    expect(uiShow.description).toContain("task_progress");
-    expect(uiShow.description).toContain(
-      "the only surface this channel renders",
-    );
-    expect(uiShow.description).not.toContain("oauth_connect");
-    expect(uiShow.description).not.toContain("dynamic_page");
-    expect(uiShow.description!.length).toBeLessThan(
-      uiShowTool.description.length / 2,
-    );
-  });
-
-  test("slack projection keeps execute and leaves other tools untouched", () => {
-    const projected = projectUiToolsForChannel(defs, "slack");
-    const uiShow = projected.find((d) => d.name === "ui_show") as {
-      execute?: unknown;
-    };
-
-    expect(uiShow.execute).toBe(uiShowTool.execute);
-    expect(projected.find((d) => d.name === "ui_update")).toBe(uiUpdateTool);
-    expect(projected.find((d) => d.name === "ui_dismiss")).toBe(uiDismissTool);
-    expect(projected.find((d) => d.name === "bash")).toBe(defs[3]);
-  });
-
-  test("projection never mutates the shared definitions", () => {
-    const descriptionBefore = uiShowTool.description;
-    const schemaBefore = JSON.stringify(uiShowTool.input_schema);
-
-    projectUiToolsForChannel(defs, "slack");
-
-    expect(uiShowTool.description).toBe(descriptionBefore);
-    expect(JSON.stringify(uiShowTool.input_schema)).toBe(schemaBefore);
-  });
-});
-
 describe("injectActivationMomentParam", () => {
   function properties(def: ToolDefinition): Record<string, unknown> {
     return (def.input_schema as { properties: Record<string, unknown> })