@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.6",
+  "version": "0.11.7-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -43,6 +43,7 @@
     "@qdrant/js-client-rest": "1.17.0",
     "@resvg/resvg-js": "2.6.2",
     "@slack/types": "2.22.0",
+    "@vellumai/avatar-manifest": "file:../packages/avatar-manifest",
     "@vellumai/ces-client": "file:../packages/ces-client",
     "@vellumai/credential-storage": "file:../packages/credential-storage",
     "@vellumai/egress-proxy": "file:../packages/egress-proxy",
@@ -72,6 +73,7 @@
     "remark-parse": "11.0.0",
     "rrule": "2.8.1",
     "semver": "7.8.0",
+    "sharp": "0.34.5",
     "stemmer": "2.0.1",
     "tar-stream": "3.1.7",
     "tldts": "7.0.25",
@@ -85,6 +87,7 @@
     "node": ">=20.12.0"
   },
   "bundledDependencies": [
+    "@vellumai/avatar-manifest",
     "@vellumai/ces-client",
     "@vellumai/credential-storage",
     "@vellumai/service-contracts",

package/scripts/sync-llm-catalog.ts

@@ -86,6 +86,9 @@ function projectModel(model: CatalogModel): Record<string, unknown> {
   if (model.pricing !== undefined) {
     projected.pricing = model.pricing;
   }
+  if (model.featureFlag !== undefined) {
+    projected.featureFlag = model.featureFlag;
+  }
   return projected;
 }
 
@@ -115,6 +118,9 @@ function projectProvider(entry: ProviderCatalogEntry): Record<string, unknown> {
   if (entry.supportsPlatformAuth !== undefined) {
     projected.supportsPlatformAuth = entry.supportsPlatformAuth;
   }
+  if (entry.featureFlag !== undefined) {
+    projected.featureFlag = entry.featureFlag;
+  }
   projected.defaultModel = entry.defaultModel;
   projected.models = entry.models.map(projectModel);
   // NOTE: `apiKeyUrl` intentionally omitted — clients use

package/src/__tests__/approval-card-edit-inbound-handoff.test.ts

@@ -0,0 +1,199 @@
+/**
+ * The inbound handoff of the approval-card message id, driven through the
+ * real handler.
+ *
+ * The companion suite (approval-card-edit.test.ts) pins the interception
+ * seam but injects `approvalMessageId` directly, so it stays green if the
+ * inbound handler stops reading `sourceMetadata.messageId` off the wire.
+ * This suite closes that gap: a Telegram button decision enters through
+ * `handleChannelInbound` exactly as the gateway forwards it, and the edit
+ * must address the message id the wire carried.
+ */
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+
+mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
+
+const _conversationMocks = new Map<string, unknown>();
+mock.module("../daemon/conversation-registry.js", () => ({
+  findConversation: (id: string) => _conversationMocks.get(id),
+}));
+
+mock.module("../runtime/local-actor-identity.js", () => ({
+  findLocalGuardianPrincipalId: async () => "vellum-principal-1",
+}));
+
+import type { TrustVerdict } from "@vellumai/gateway-client";
+
+import type { Conversation } from "../daemon/conversation.js";
+import * as providers from "../messaging/providers/index.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
+import {
+  handleChannelInbound,
+  setAdapterProcessMessage,
+} from "./helpers/channel-test-adapter.js";
+
+await initializeDb();
+
+const CHAT_ID = "chat-123";
+const GUARDIAN = "user-1";
+const BUTTON_MESSAGE_ID = "4242";
+const CALLBACK_URL = "https://gateway.test/deliver/telegram";
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM channel_inbound_events");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM contact_channels");
+  db.run("DELETE FROM contacts");
+}
+
+function guardianVerdict(): TrustVerdict {
+  return {
+    trustClass: "guardian",
+    canonicalSenderId: GUARDIAN,
+    contactId: "contact-1",
+    channelId: "channel-1",
+    type: "telegram",
+    address: GUARDIAN,
+    externalChatId: CHAT_ID,
+    status: "active",
+    policy: "allow",
+    guardianExternalUserId: GUARDIAN,
+    guardianDeliveryChatId: CHAT_ID,
+    guardianPrincipalId: "vellum-principal-1",
+  } satisfies TrustVerdict;
+}
+
+function makeInboundRequest(overrides: Record<string, unknown> = {}): Request {
+  return new Request("http://localhost/channels/inbound", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Gateway-Origin": "test-token",
+    },
+    body: JSON.stringify({
+      sourceChannel: "telegram",
+      interface: "telegram",
+      conversationExternalId: CHAT_ID,
+      externalMessageId: `msg-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2, 8)}`,
+      content: "hello",
+      actorExternalId: GUARDIAN,
+      replyCallbackUrl: CALLBACK_URL,
+      sourceMetadata: { trustVerdict: guardianVerdict() },
+      ...overrides,
+    }),
+  });
+}
+
+function conversationIdFromInboundEvents(): string {
+  const rows = getDb()
+    .$client.prepare("SELECT conversation_id FROM channel_inbound_events")
+    .all() as Array<{ conversation_id: string }>;
+  expect(rows.length).toBeGreaterThan(0);
+  return rows[0].conversation_id;
+}
+
+function registerPendingInteraction(
+  requestId: string,
+  conversationId: string,
+): void {
+  const _mockSession = {
+    handleConfirmationResponse: mock(() => {}),
+    ensureActorScopedHistory: async () => {},
+  } as unknown as Conversation;
+  _conversationMocks.set(conversationId, _mockSession);
+
+  pendingInteractions.register(requestId, {
+    conversationId,
+    kind: "confirmation",
+    confirmationDetails: {
+      toolName: "execute_shell",
+      input: { command: "ls" },
+      riskLevel: "high",
+      allowlistOptions: [
+        { label: "test", description: "test", pattern: "test" },
+      ],
+      scopeOptions: [{ label: "everywhere", scope: "everywhere" }],
+    },
+  });
+}
+
+describe("approval-card edit: inbound message-id handoff", () => {
+  let editSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    resetTables();
+    pendingInteractions.clear();
+    _conversationMocks.clear();
+    setAdapterProcessMessage(undefined);
+    editSpy = spyOn(providers, "editChannelMessage").mockResolvedValue({
+      ok: true,
+    });
+  });
+
+  test("a Telegram button press edits the message id the wire carried", async () => {
+    // First inbound materializes the conversation the pending approval
+    // will hang off, the way a real approval prompt's conversation exists
+    // before its buttons are pressed.
+    const first = await handleChannelInbound(makeInboundRequest());
+    expect(((await first.json()) as { accepted?: boolean }).accepted).toBe(
+      true,
+    );
+    const conversationId = conversationIdFromInboundEvents();
+    registerPendingInteraction("req-handoff-1", conversationId);
+
+    // The gateway forwards a button press with the keyboard message's id on
+    // sourceMetadata.messageId; nothing in this request names the id any
+    // other way, so the edit below proves the handler read it off the wire.
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        content: "",
+        callbackData: "apr:req-handoff-1:approve_once",
+        sourceMetadata: {
+          trustVerdict: guardianVerdict(),
+          messageId: BUTTON_MESSAGE_ID,
+        },
+      }),
+    );
+    expect(res.status).toBe(200);
+
+    expect(editSpy).toHaveBeenCalledTimes(1);
+    const [callbackUrl, payload] = editSpy.mock.calls[0];
+    expect(callbackUrl).toBe(CALLBACK_URL);
+    expect(payload.chatId).toBe(CHAT_ID);
+    expect(payload.messageId).toBe(BUTTON_MESSAGE_ID);
+    expect(payload.text).toContain("Approved");
+
+    editSpy.mockRestore();
+  });
+
+  test("a button press whose wire carries no message id edits nothing", async () => {
+    // The inverse pin: the edit is driven by the wire's id and only by it.
+    const first = await handleChannelInbound(makeInboundRequest());
+    expect(((await first.json()) as { accepted?: boolean }).accepted).toBe(
+      true,
+    );
+    const conversationId = conversationIdFromInboundEvents();
+    registerPendingInteraction("req-handoff-2", conversationId);
+
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        content: "",
+        callbackData: "apr:req-handoff-2:approve_once",
+        sourceMetadata: { trustVerdict: guardianVerdict() },
+      }),
+    );
+    expect(res.status).toBe(200);
+
+    expect(editSpy).not.toHaveBeenCalled();
+
+    editSpy.mockRestore();
+  });
+});

package/src/__tests__/approval-card-edit.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Approval-card editing after a button decision, across channels.
+ *
+ * The card edit is routed by the reply callback URL through the channel edit
+ * capability, so the same interception path serves every channel whose
+ * transport implements `edit`. These tests drive the Telegram shape end to
+ * end at this seam: the gateway forwards the id of the message holding the
+ * inline keyboard, and a decision or a stale press must edit exactly that
+ * message.
+ */
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+
+const _conversationMocks = new Map<string, unknown>();
+mock.module("../daemon/conversation-registry.js", () => ({
+  findConversation: (id: string) => _conversationMocks.get(id),
+}));
+
+let _anchorPrincipalId: string | undefined;
+mock.module("../runtime/local-actor-identity.js", () => ({
+  findLocalGuardianPrincipalId: async () => _anchorPrincipalId,
+}));
+
+import type { Conversation } from "../daemon/conversation.js";
+import * as providers from "../messaging/providers/index.js";
+import { initializeDb } from "../persistence/db-init.js";
+import * as gatewayClient from "../runtime/gateway-client.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
+import { handleApprovalInterception } from "../runtime/routes/guardian-approval-interception.js";
+
+await initializeDb();
+
+const ASSISTANT_ID = "self";
+const CONVERSATION_ID = "conv-card-edit-1";
+const REQUESTER_CHAT = "5550100";
+const TELEGRAM_CALLBACK_URL = "https://gateway.test/deliver/telegram?chat=1";
+const BUTTON_MESSAGE_ID = "4242";
+
+function registerPendingInteraction(requestId: string): void {
+  const _mockSession = {
+    handleConfirmationResponse: mock(() => {}),
+    ensureActorScopedHistory: async () => {},
+  } as unknown as Conversation;
+  _conversationMocks.set(CONVERSATION_ID, _mockSession);
+
+  pendingInteractions.register(requestId, {
+    conversationId: CONVERSATION_ID,
+    kind: "confirmation",
+    confirmationDetails: {
+      toolName: "execute_shell",
+      input: { command: "ls" },
+      riskLevel: "high",
+      allowlistOptions: [
+        { label: "test", description: "test", pattern: "test" },
+      ],
+      scopeOptions: [{ label: "everywhere", scope: "everywhere" }],
+    },
+  });
+}
+
+function guardianParams(callbackData: string) {
+  return {
+    conversationId: CONVERSATION_ID,
+    callbackData,
+    content: "",
+    conversationExternalId: REQUESTER_CHAT,
+    sourceChannel: "telegram" as const,
+    actorExternalId: "guardian-user-1",
+    replyCallbackUrl: TELEGRAM_CALLBACK_URL,
+    trustCtx: {
+      sourceChannel: "telegram" as const,
+      trustClass: "guardian" as const,
+      requesterExternalUserId: "guardian-user-1",
+      guardianExternalUserId: "guardian-user-1",
+      guardianPrincipalId: "guardian-principal-1",
+    },
+    assistantId: ASSISTANT_ID,
+    approvalMessageId: BUTTON_MESSAGE_ID,
+  };
+}
+
+describe("approval card edit after a button decision", () => {
+  let editSpy: ReturnType<typeof spyOn>;
+  let deliverSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    pendingInteractions.clear();
+    _anchorPrincipalId = "guardian-principal-1";
+    editSpy = spyOn(providers, "editChannelMessage").mockResolvedValue({
+      ok: true,
+    });
+    deliverSpy = spyOn(gatewayClient, "deliverChannelReply").mockResolvedValue({
+      ok: true,
+    });
+  });
+
+  test("a Telegram approve button edits exactly the card message", async () => {
+    registerPendingInteraction("req-card-edit-approve");
+
+    const result = await handleApprovalInterception(
+      guardianParams("apr:req-card-edit-approve:approve_once"),
+    );
+
+    expect(result).toEqual({ handled: true, type: "decision_applied" });
+    expect(editSpy).toHaveBeenCalledTimes(1);
+    const [callbackUrl, payload] = editSpy.mock.calls[0];
+    expect(callbackUrl).toBe(TELEGRAM_CALLBACK_URL);
+    expect(payload.chatId).toBe(REQUESTER_CHAT);
+    expect(payload.messageId).toBe(BUTTON_MESSAGE_ID);
+    expect(payload.text).toContain("Approved");
+
+    editSpy.mockRestore();
+    deliverSpy.mockRestore();
+  });
+
+  test("a Telegram reject button edits the card to Denied", async () => {
+    registerPendingInteraction("req-card-edit-reject");
+
+    const result = await handleApprovalInterception(
+      guardianParams("apr:req-card-edit-reject:reject"),
+    );
+
+    expect(result).toEqual({ handled: true, type: "decision_applied" });
+    expect(editSpy).toHaveBeenCalledTimes(1);
+    const [, payload] = editSpy.mock.calls[0];
+    expect(payload.messageId).toBe(BUTTON_MESSAGE_ID);
+    expect(payload.text).toContain("Denied");
+
+    editSpy.mockRestore();
+    deliverSpy.mockRestore();
+  });
+
+  test("a stale Telegram button press marks the card resolved", async () => {
+    // Pending interaction exists, but the button belongs to a different,
+    // already-settled request: the card must lose its buttons rather than
+    // apply to the wrong interaction.
+    registerPendingInteraction("req-card-edit-live");
+
+    const result = await handleApprovalInterception(
+      guardianParams("apr:req-card-edit-settled:approve_once"),
+    );
+
+    expect(result).toEqual({ handled: true, type: "stale_ignored" });
+    expect(editSpy).toHaveBeenCalledTimes(1);
+    const [callbackUrl, payload] = editSpy.mock.calls[0];
+    expect(callbackUrl).toBe(TELEGRAM_CALLBACK_URL);
+    expect(payload.messageId).toBe(BUTTON_MESSAGE_ID);
+    expect(payload.text).toBe("This approval request has been resolved.");
+    expect(payload.emphasis).toBe("muted");
+
+    editSpy.mockRestore();
+    deliverSpy.mockRestore();
+  });
+});

package/src/__tests__/attachments-store-heic-normalize.test.ts

@@ -4,7 +4,7 @@
  * register and assistant-outbound paths keep content verbatim.
  *
  * The converter module is mocked (keyed on the declared mime type) so these
- * tests run identically with and without macOS sips; real conversion is
+ * tests run independently of the installed image encoder; real conversion is
  * covered in image-conversion.test.ts. mock.module is process-global — keep
  * these cases in this file.
  */

package/src/__tests__/available-skills.test.ts

@@ -8,6 +8,10 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { SkillSummary } from "../config/skills.js";
 import type { SkillInstallMeta } from "../skills/install-meta.js";
+import {
+  SKILL_PLATFORM_VALUES,
+  skillPlatformForNodePlatform,
+} from "../skills/platform-compatibility.js";
 import { setConfig } from "./helpers/set-config.js";
 
 function makeSummary(overrides: Partial<SkillSummary> = {}): SkillSummary {
@@ -120,6 +124,26 @@ describe("listInstalledSkills", () => {
     ]);
   });
 
+  test("reports host-incompatible skills as unavailable", async () => {
+    const currentPlatform = skillPlatformForNodePlatform(process.platform)!;
+    const incompatiblePlatform = SKILL_PLATFORM_VALUES.find(
+      (platform) => platform !== currentPlatform,
+    )!;
+    catalogFixture = [
+      makeSummary({ id: "compatible", platforms: [currentPlatform] }),
+      makeSummary({ id: "incompatible", platforms: [incompatiblePlatform] }),
+    ];
+
+    const { listInstalledSkills } =
+      await import("../skills/available-skills.js");
+    const entries = await listInstalledSkills();
+
+    expect(entries.map((entry) => [entry.id, entry.state])).toEqual([
+      ["compatible", "enabled"],
+      ["incompatible", "unavailable"],
+    ]);
+  });
+
   test("reports bundled skills excluded by allowBundled as unavailable", async () => {
     catalogFixture = [
       makeSummary({ id: "allowed-bundled" }),
@@ -250,6 +274,36 @@ describe("listCatalogSkills", () => {
     expect(await listCatalogSkills()).toEqual([]);
   });
 
+  test("reports host-incompatible catalog skills as unavailable", async () => {
+    const currentPlatform = skillPlatformForNodePlatform(process.platform)!;
+    const incompatiblePlatform = SKILL_PLATFORM_VALUES.find(
+      (platform) => platform !== currentPlatform,
+    )!;
+    remoteFixture = [
+      {
+        id: "incompatible",
+        name: "incompatible",
+        description: "Only works elsewhere",
+        platforms: [incompatiblePlatform],
+        metadata: { vellum: { platforms: [incompatiblePlatform] } },
+      },
+    ];
+
+    const { listCatalogSkills } = await import("../skills/available-skills.js");
+    expect(await listCatalogSkills()).toEqual([
+      {
+        id: "incompatible",
+        displayName: "incompatible",
+        description: "Only works elsewhere",
+        activationHints: undefined,
+        avoidWhen: undefined,
+        platforms: [incompatiblePlatform],
+        installed: false,
+        state: "unavailable",
+      },
+    ]);
+  });
+
   test("adds no error handling of its own — unexpected catalog-read errors propagate", async () => {
     remoteError = new Error("catalog read exploded");
     const { listCatalogSkills } = await import("../skills/available-skills.js");

package/src/__tests__/avatar-identity-sync.test.ts

@@ -1,4 +1,8 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+mock.module("../platform/sync-avatar.js", () => ({
+  syncAvatarToPlatform: () => {},
+}));
 
 import type { AssistantEventEnvelope } from "../api/index.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";

package/src/__tests__/catalog-install-normalize.test.ts

@@ -52,6 +52,7 @@ describe("fetchCatalog normalization", () => {
           description: "Shop on Amazon",
           icon: "🛒",
           category: "commerce",
+          platforms: ["windows"],
           updated_at: "2026-04-19T19:26:17Z",
         },
       ],
@@ -67,6 +68,8 @@ describe("fetchCatalog normalization", () => {
     expect(skill.icon).toBe("🛒");
     expect(skill.metadata?.icon).toBe("🛒");
     expect(skill.updatedAt).toBe("2026-04-19T19:26:17Z");
+    expect(skill.platforms).toEqual(["windows"]);
+    expect(skill.metadata?.vellum?.platforms).toEqual(["windows"]);
   });
 
   test("leaves category undefined when the API omits it", async () => {
@@ -115,7 +118,11 @@ describe("readLocalCatalog normalization", () => {
               description: "Task management",
               metadata: {
                 icon: "✅",
-                vellum: { "display-name": "Tasks", category: "productivity" },
+                vellum: {
+                  "display-name": "Tasks",
+                  category: "productivity",
+                  platforms: ["macos", "linux"],
+                },
               },
             },
           ],
@@ -127,6 +134,7 @@ describe("readLocalCatalog normalization", () => {
       expect(catalog).toHaveLength(1);
       expect(catalog[0].metadata?.vellum?.category).toBe("productivity");
       expect(catalog[0].metadata?.vellum?.["display-name"]).toBe("Tasks");
+      expect(catalog[0].platforms).toEqual(["macos", "linux"]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }

package/src/__tests__/channel-policy.test.ts

@@ -38,9 +38,7 @@ describe("channel policy registry", () => {
 
   test("getDeliverableChannels returns exactly the channels with deliveryEnabled: true", () => {
     const deliverable = getDeliverableChannels();
-    const expected = CHANNEL_IDS.filter(
-      (id) => getChannelPolicy(id).notification.deliveryEnabled,
-    );
+    const expected = CHANNEL_IDS.filter(isNotificationDeliverable);
 
     expect(deliverable).toHaveLength(expected.length);
     for (const id of expected) {

package/src/__tests__/channel-readiness-discord.test.ts

@@ -44,18 +44,6 @@ type SocketHealth = {
 let askedChannels: string[];
 let socketHealth: SocketHealth | Error;
 
-/** How many channels the gateway reports on Discord's allow-list. */
-let admittedChannelCount: number | Error;
-
-mock.module("../channels/gateway-discord-admission.js", () => ({
-  readDiscordAdmission: async () => {
-    if (admittedChannelCount instanceof Error) {
-      throw admittedChannelCount;
-    }
-    return { admittedChannelCount };
-  },
-}));
-
 mock.module("../channels/gateway-channel-socket-health.js", () => ({
   readChannelSocketHealth: async (channel: string) => {
     askedChannels.push(channel);
@@ -72,7 +60,6 @@ beforeEach(() => {
   socketHealth = { channel: "discord", status: "connected" };
   // The default install state: fail-closed and empty, admitting nothing until
   // someone lists channel ids. Tests that need admission say so.
-  admittedChannelCount = 0;
 });
 
 async function runDiscordProbe() {
@@ -95,28 +82,30 @@ describe("discord readiness", () => {
     expect(askedChannels).toEqual(["discord"]);
   });
 
-  test("a fresh install has neither a token nor an allow-list", async () => {
+  test("a fresh install has no token", async () => {
     const [snapshot] = await runDiscordProbe();
 
     expect(findCheck(snapshot, "bot_token").passed).toBe(false);
-    expect(findCheck(snapshot, "guild_admission").passed).toBe(false);
     // Nothing configured at all, which is a different report from a channel
     // half set up: no step has been taken rather than one left undone.
     expect(snapshot.setupStatus).toBe("not_configured");
   });
 
-  test("an allow-list without a token is half set up", async () => {
-    admittedChannelCount = 3;
+  test("Discord has one setup step, so it is never half configured", async () => {
+    // A live socket without a token still reads as not configured rather than
+    // incomplete. `incomplete` needs one configuration check passing while
+    // another fails, and the token is now the only one: with the room
+    // allow-list gone there is no second step to be part-way through.
+    socketHealth = { channel: "discord", status: "connected" };
 
     const [snapshot] = await runDiscordProbe();
 
     expect(findCheck(snapshot, "bot_token").passed).toBe(false);
-    expect(snapshot.setupStatus).toBe("incomplete");
+    expect(snapshot.setupStatus).toBe("not_configured");
   });
 
-  test("a token, a live connection and an allow-list read as ready", async () => {
+  test("a token and a live connection read as ready", async () => {
     mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
-    admittedChannelCount = 2;
     socketHealth = {
       channel: "discord",
       status: "connected",
@@ -130,61 +119,11 @@ describe("discord readiness", () => {
     expect(delivery.passed).toBe(true);
     expect(delivery.message).toContain("Discord");
     expect(delivery.message).toContain("2026-08-21T17:00:00.000Z");
-    expect(findCheck(snapshot, "guild_admission").message).toContain(
-      "2 channels",
-    );
     expect(snapshot.ready).toBe(true);
   });
 
-  test("an empty allow-list is unfinished setup, not a live channel", async () => {
-    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
-    admittedChannelCount = 0;
-
-    const [snapshot] = await runDiscordProbe();
-
-    // A connected socket that admits nothing still drops every guild message,
-    // so claiming ready here would promise delivery the gate is refusing.
-    const admission = findCheck(snapshot, "guild_admission");
-    expect(admission.passed).toBe(false);
-    expect(snapshot.setupStatus).toBe("incomplete");
-    expect(snapshot.ready).toBe(false);
-
-    // And it is a setup step rather than an outage: direct messages carry no
-    // guild and never meet this gate, so the connection itself is fine.
-    expect(snapshot.health).not.toBe("failing");
-    expect(findCheck(snapshot, "inbound_delivery").passed).toBe(true);
-  });
-
-  test("one admitted channel reads in the singular", async () => {
-    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
-    admittedChannelCount = 1;
-
-    const [snapshot] = await runDiscordProbe();
-
-    expect(findCheck(snapshot, "guild_admission").message).toContain(
-      "1 channel",
-    );
-    expect(findCheck(snapshot, "guild_admission").message).not.toContain(
-      "1 channels",
-    );
-  });
-
-  test("an unreachable gateway does not claim the allow-list is empty", async () => {
-    mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
-    admittedChannelCount = new Error("gateway down");
-
-    const [snapshot] = await runDiscordProbe();
-
-    const admission = findCheck(snapshot, "guild_admission");
-    expect(admission.passed).toBe(true);
-    expect(admission.indeterminate).toBe(true);
-  });
-
   test("a dead socket reads as configured and failing, not unconfigured", async () => {
     mockSecureKeys[credentialKey("discord_channel", "bot_token")] = "bot-fake";
-    // Setup has to be finished for this to isolate the socket: an empty
-    // allow-list would leave it incomplete for a reason that is not the socket.
-    admittedChannelCount = 1;
     socketHealth = { channel: "discord", status: "disconnected" };
 
     const [snapshot] = await runDiscordProbe();