@vellumai/assistant 0.11.6 → 0.11.7-staging.1

package/src/__tests__/credential-security-invariants.test.ts

@@ -179,6 +179,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "providers/inference/credential-slot-repair.ts", // boot repair: copies the shared openai-compatible slot value into per-connection slots (get/set of provider API keys only; values never logged or returned)
       "runtime/routes/inference-provider-connection-routes.ts", // connection delete removes its dedicated per-connection key slot (deleteSecureKeyAsync only; no reads)
       "daemon/handlers/config-slack-channel.ts", // Slack channel config credential management
+      "daemon/handlers/config-discord-channel.ts", // Discord channel bot token management
       "providers/platform-proxy/context.ts", // managed proxy API key lookup for provider initialization
       "platform/client.ts", // platform client credential store fallback for standalone CLI auth
       "mcp/mcp-header-store.ts", // MCP static auth header persistence (credential store CRUD + legacy migration)
@@ -203,8 +204,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "providers/registry.ts", // provider registry API key lookup for initialization
       "providers/inference/resolve-auth.ts", // provider_connection auth resolver (api_key path reads vault, mirrors registry.ts)
       "providers/inference/codex-token-refresh.ts", // Codex OAuth token refresh (reads/writes access_token, refresh_token, expires_at)
-      "cli/commands/inference-providers.ts", // ChatGPT subscription OAuth token storage
-      "runtime/routes/chatgpt-subscription-auth-routes.ts", // ChatGPT subscription daemon OAuth flow (stores tokens in CES)
+      "providers/inference/chatgpt-subscription-credentials.ts", // ChatGPT subscription sign-in token storage, shared by the daemon routes and the CLI (setSecureKeyAsync only; no reads)
       "providers/provider-availability.ts", // provider availability API key check
       "media/image-credentials.ts", // shared image-gen credential resolver (provider API key lookup)
       "persistence/embeddings/embedding-backend.ts", // embedding backend API key lookup
@@ -231,7 +231,6 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/routes/avatar-routes.ts", // avatar generate route reads platform_base_url from credential store
       "cli/commands/keys.ts", // CLI provider key management
       "cli/commands/oauth/connect.ts", // CLI OAuth connect stored-secret verification
-      "runtime/routes/chatgpt-subscription-auth-routes.ts", // ChatGPT subscription OAuth token storage
       "runtime/routes/identity-routes.ts", // health/readyz endpoint checks CES connectivity via getCesClient
       "tools/executor.ts", // CES approval bridge resolves the CES RPC client via getCesClient
       "tools/network/web-fetch.ts", // Firecrawl /scrape BYOK fetch provider API key lookup (firecrawl provider key)
@@ -470,24 +469,24 @@ describe("Invariant 4: credentials only used for allowed purpose", () => {
   });
 
   // PR 18 — vault policy fields with strict defaults
-  test("credential without explicit policy gets strict defaults (deny all)", () => {
+  test("credential without explicit policy gets strict defaults (deny all)", async () => {
     // A credential stored without allowed_tools defaults to empty array,
     // which the broker's isToolAllowed check fails closed on.
     upsertCredentialMetadata("test-svc", "pass", {});
 
-    const result = broker.authorize({
+    const result = await broker.browserFill({
       service: "test-svc",
       field: "pass",
       toolName: "browser_fill_credential",
+      fill: async () => {},
     });
 
-    expect(result.authorized).toBe(false);
-    expect(!result.authorized && result.reason).toContain(
-      "No tools are currently allowed",
-    );
+    expect(result.success).toBe(false);
+    expect(result.reason).toContain("No tools are currently allowed");
   });
 });
 
+
 // ---------------------------------------------------------------------------
 // Invariant 6 — oauth2ClientSecret never in plaintext metadata
 // ---------------------------------------------------------------------------

package/src/__tests__/default-profile-catalog-fallback.test.ts

@@ -0,0 +1,289 @@
+/**
+ * Managed backup profiles and the `fallbackProfile` pointers of the vellum
+ * column (`default-profile-catalog.ts`).
+ *
+ * The invariants under test:
+ * - Every default profile's managed (vellum) implementation points at a
+ *   backup profile that exists in the code catalog.
+ * - Cross-provider rule: a backup pins its model at a DIFFERENT managed
+ *   upstream than its primary, so an outage at the primary's provider can
+ *   be served by the backup. Holds for the experiment arms too.
+ * - Probe coverage: every backup model is a catalog member of its upstream
+ *   provider, which is what feeds the platform's model liveness probe.
+ * - Scoping: backups exist for the managed column only. A BYOK or chatgpt
+ *   default provider materializes no backup profiles, and its primaries
+ *   carry no `fallbackProfile` pointers.
+ * - The effective catalog parses under `LLMSchema` (exercising the
+ *   `fallbackProfile` superRefine against the real entries), and backups
+ *   are delete-protected like the other managed defaults.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { BALANCED_MODEL_EXPERIMENT_FLAG_KEY } from "../config/balanced-model-experiment.js";
+import {
+  CODE_DEFAULT_PROFILE_ENTRIES,
+  getEffectiveProfile,
+  getEffectiveProfiles,
+  getEffectiveProfilesForProvider,
+  INVARIANT_PROFILE_NAMES,
+  MANAGED_PROFILE_NAMES,
+  MANAGED_PROFILE_TEMPLATES,
+  PROFILE_IMPLS,
+  resolveDefaultProfileForProvider,
+} from "../config/default-profile-catalog.js";
+import {
+  BACKUP_PROFILE_KEYS,
+  DEFAULT_PROFILE_KEYS,
+  DEFAULT_PROFILE_PROVIDERS,
+  FALLBACK_PROFILE_BY_KEY,
+} from "../config/default-profile-names.js";
+import { clearCachedOverrides } from "../config/feature-flag-cache.js";
+import {
+  type DefaultProviderConfig,
+  LLMSchema,
+  type ProfileEntry,
+} from "../config/schemas/llm.js";
+import { isModelInCatalog } from "../providers/model-catalog.js";
+import { getManagedUpstream } from "../providers/vellum-model-routing.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
+
+const vellum: DefaultProviderConfig = { provider: "vellum" };
+
+afterEach(() => {
+  clearCachedOverrides();
+});
+
+describe("fallbackProfile pointers on the vellum column", () => {
+  test("every default profile's vellum impl points at an existing backup", () => {
+    for (const key of DEFAULT_PROFILE_KEYS) {
+      const impl = PROFILE_IMPLS[key].vellum;
+      expect(impl.fallbackProfile).toBe(FALLBACK_PROFILE_BY_KEY[key]);
+      const backup = CODE_DEFAULT_PROFILE_ENTRIES[FALLBACK_PROFILE_BY_KEY[key]];
+      expect(backup).toBeDefined();
+      expect(backup.provider).toBe("vellum");
+      expect(backup.source).toBe("managed");
+      // Single hop: a backup never declares a fallback of its own.
+      expect(backup.fallbackProfile).toBeUndefined();
+    }
+  });
+
+  test("no BYOK or chatgpt column impl carries fallbackProfile", () => {
+    for (const key of DEFAULT_PROFILE_KEYS) {
+      for (const provider of DEFAULT_PROFILE_PROVIDERS) {
+        if (provider === "vellum") {
+          continue;
+        }
+        expect(PROFILE_IMPLS[key][provider].fallbackProfile).toBeUndefined();
+      }
+      // A default-capable provider without a named matrix column
+      // materializes from the shared BYOK templates: no pointer either.
+      const entry = resolveDefaultProfileForProvider(undefined, key, {
+        provider: "together",
+      });
+      expect(entry?.fallbackProfile).toBeUndefined();
+    }
+  });
+});
+
+describe("cross-provider rule", () => {
+  test("every backup dispatches through a different managed upstream than its primary", () => {
+    for (const key of DEFAULT_PROFILE_KEYS) {
+      const primary = CODE_DEFAULT_PROFILE_ENTRIES[key];
+      const backup = CODE_DEFAULT_PROFILE_ENTRIES[FALLBACK_PROFILE_BY_KEY[key]];
+      const primaryUpstream = getManagedUpstream(primary.model as string);
+      const backupUpstream = getManagedUpstream(backup.model as string);
+      expect(primaryUpstream).not.toBeNull();
+      expect(backupUpstream).not.toBeNull();
+      expect(backupUpstream).not.toBe(primaryUpstream);
+    }
+  });
+
+  test("the balanced experiment arms keep the cross-provider split", () => {
+    const backup =
+      CODE_DEFAULT_PROFILE_ENTRIES[FALLBACK_PROFILE_BY_KEY.balanced];
+    const backupUpstream = getManagedUpstream(backup.model as string);
+    for (const arm of ["terra", "glm-5p2"]) {
+      setOverridesForTesting({ [BALANCED_MODEL_EXPERIMENT_FLAG_KEY]: arm });
+      const armed = resolveDefaultProfileForProvider(
+        undefined,
+        "balanced",
+        vellum,
+      );
+      expect(armed?.fallbackProfile).toBe(FALLBACK_PROFILE_BY_KEY.balanced);
+      const armedUpstream = getManagedUpstream(armed?.model as string);
+      expect(armedUpstream).not.toBeNull();
+      expect(armedUpstream).not.toBe(backupUpstream);
+    }
+  });
+
+  test("every backup model is a catalog member of its upstream (liveness-probe coverage)", () => {
+    for (const key of BACKUP_PROFILE_KEYS) {
+      const model = CODE_DEFAULT_PROFILE_ENTRIES[key].model as string;
+      const upstream = getManagedUpstream(model);
+      expect(upstream).not.toBeNull();
+      expect(isModelInCatalog(upstream as string, model)).toBe(true);
+    }
+  });
+});
+
+describe("managed-column-only scoping", () => {
+  test("the managed column materializes the backups after the primaries", () => {
+    const effective = getEffectiveProfilesForProvider(undefined, vellum);
+    for (const key of BACKUP_PROFILE_KEYS) {
+      expect(effective[key]).toBeDefined();
+      expect(effective[key]?.provider).toBe("vellum");
+      expect(effective[key]?.source).toBe("managed");
+    }
+    // The seeder inserts missing managed keys in MANAGED_PROFILE_TEMPLATES
+    // order, which is what places backups after the primaries in
+    // `profileOrder` presentation.
+    expect(Object.keys(MANAGED_PROFILE_TEMPLATES)).toEqual([
+      ...DEFAULT_PROFILE_KEYS,
+      ...BACKUP_PROFILE_KEYS,
+    ]);
+  });
+
+  test("a null defaultProvider (pre-defaultProvider install) keeps its backups", () => {
+    const effective = getEffectiveProfiles(undefined);
+    for (const key of BACKUP_PROFILE_KEYS) {
+      expect(effective[key]).toBeDefined();
+      expect(
+        resolveDefaultProfileForProvider(undefined, key, null),
+      ).toBeDefined();
+    }
+  });
+
+  test("a BYOK default provider materializes no backups and no pointers", () => {
+    for (const provider of ["anthropic", "openai", "gemini"] as const) {
+      const effective = getEffectiveProfilesForProvider(undefined, {
+        provider,
+      });
+      for (const key of BACKUP_PROFILE_KEYS) {
+        expect(effective[key]).toBeUndefined();
+      }
+      for (const key of DEFAULT_PROFILE_KEYS) {
+        expect(effective[key]?.fallbackProfile).toBeUndefined();
+      }
+    }
+  });
+
+  test("the chatgpt column materializes no backups and no pointers", () => {
+    const effective = getEffectiveProfilesForProvider(undefined, {
+      provider: "chatgpt",
+    });
+    for (const key of BACKUP_PROFILE_KEYS) {
+      expect(effective[key]).toBeUndefined();
+    }
+    for (const key of DEFAULT_PROFILE_KEYS) {
+      expect(effective[key]?.fallbackProfile).toBeUndefined();
+    }
+  });
+
+  test("a persisted managed stub does not resurrect a backup off the managed column", () => {
+    // A `config get` -> `config set` round-trip on a managed install can
+    // leave a thin managed stub for a backup in `llm.profiles`
+    // (`normalizeManagedProfileWrites`). The stub is the workspace's slot for
+    // a code-owned body, not a profile, so once the column has no body behind
+    // it the name must stop being listed rather than resolve to a
+    // providerless entry the pickers would offer and `LLMSchema` would
+    // reject.
+    const workspace: Record<string, ProfileEntry> = {
+      "balanced-backup": { source: "managed" },
+    };
+    for (const provider of ["anthropic", "chatgpt"] as const) {
+      const effective = getEffectiveProfilesForProvider(workspace, {
+        provider,
+      });
+      expect(effective["balanced-backup"]).toBeUndefined();
+      expect(
+        resolveDefaultProfileForProvider(workspace, "balanced-backup", {
+          provider,
+        }),
+      ).toBeUndefined();
+    }
+    // The managed column still has a body for the stub to stand for.
+    expect(
+      getEffectiveProfilesForProvider(workspace, vellum)["balanced-backup"]
+        ?.model,
+    ).toBe(CODE_DEFAULT_PROFILE_ENTRIES["balanced-backup"]?.model);
+  });
+
+  test("a user-owned entry under a backup name stays listed off the managed column", () => {
+    // Nothing code-owned resolves there, so the entry is simply a profile of
+    // that name and keeps its own body.
+    const workspace: Record<string, ProfileEntry> = {
+      "balanced-backup": {
+        source: "user",
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+      },
+    };
+    const effective = getEffectiveProfilesForProvider(workspace, {
+      provider: "anthropic",
+    });
+    expect(effective["balanced-backup"]?.model).toBe("claude-opus-4-7");
+  });
+});
+
+describe("effective-profile machinery", () => {
+  test("the full effective catalog parses under LLMSchema", () => {
+    // Exercises the fallbackProfile superRefine (target exists, no self
+    // reference, no mix target, single hop) against the real entries.
+    for (const profiles of [
+      getEffectiveProfiles(undefined),
+      getEffectiveProfilesForProvider(undefined, vellum),
+    ]) {
+      const parsed = LLMSchema.parse({
+        profiles,
+        activeProfile: "balanced",
+      });
+      for (const key of DEFAULT_PROFILE_KEYS) {
+        expect(parsed.profiles[key]?.fallbackProfile).toBe(
+          FALLBACK_PROFILE_BY_KEY[key],
+        );
+      }
+    }
+  });
+
+  test("a workspace entry never overlays a backup, whatever its source", () => {
+    // Backups are code-owned (`CODE_OWNED_PROFILE_NAMES`), so unlike the
+    // primaries they take no workspace overlay at all: not the usual
+    // label/status/topP whitelist from a managed stub, and not a user-owned
+    // shadow. Disabling a backup through a hand-edited config would strand
+    // the primary's fallback exactly when it is needed.
+    for (const source of ["managed", "user"] as const) {
+      const workspace: Record<string, ProfileEntry> = {
+        "balanced-backup": {
+          source,
+          label: "My Backup",
+          status: "disabled",
+          topP: 0.7,
+          // Stale content drift on disk must lose to the code default body.
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
+          maxTokens: 1,
+        },
+      };
+      const entry = getEffectiveProfile(workspace, "balanced-backup");
+      const body = CODE_DEFAULT_PROFILE_ENTRIES["balanced-backup"];
+      expect(entry?.label).toBe(body.label);
+      expect(entry?.status).toBeUndefined();
+      expect(entry?.topP).toBe(body.topP);
+      expect(entry?.model).toBe(body.model);
+      expect(entry?.maxTokens).toBe(body.maxTokens);
+      expect(String(entry?.provider)).toBe("vellum");
+    }
+  });
+
+  test("backup profiles are delete-protected like the other managed defaults", () => {
+    // Membership in these sets is what wires the route-level deletion
+    // rejection (`rejectManagedProfileDeletion`, `handleCreateProfile`) and
+    // the commitConfigWrite invariant guard
+    // (`assertInvariantProfilesPreserved`).
+    for (const key of BACKUP_PROFILE_KEYS) {
+      expect(MANAGED_PROFILE_NAMES.has(key)).toBe(true);
+      expect(INVARIANT_PROFILE_NAMES.has(key)).toBe(true);
+    }
+  });
+});

package/src/__tests__/discord-callback-round-trip.test.ts

@@ -0,0 +1,93 @@
+/**
+ * The Discord callback seam, end to end through the join rather than either
+ * half of it.
+ *
+ * Discord's send, render and DM delivery each have their own unit coverage,
+ * and the gateway's inbound has schema, admission and normalizer coverage.
+ * Nothing exercised the point where they meet: a reply addressed to a Discord
+ * callback resolving to the Discord transport and being delivered with the
+ * chat id it was given. That join is where a channel goes silently deaf while
+ * every component around it still passes, which is the shape the Slack
+ * plan-mode bug had.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+const sent: Array<{ channelId: string; text: string }> = [];
+
+// Spread the real module rather than listing the exports this test happens to
+// need. `mock.module` replaces the module wholesale, so a partial stub breaks
+// the transport's import of any export it omits, and would break again the
+// next time `send.ts` grows one.
+const actualSend = await import("../messaging/providers/discord/send.js");
+
+mock.module("../messaging/providers/discord/send.js", () => ({
+  ...actualSend,
+  sendDiscordReply: async (target: { channelId: string }, text: string) => {
+    sent.push({ channelId: target.channelId, text });
+    return { messageId: "1401234567890123456" };
+  },
+}));
+
+const { channelForCallback } =
+  await import("../messaging/providers/callback-routing.js");
+const { deliverDirect, getTransportForCallback, isDirectDelivery } =
+  await import("../messaging/providers/index.js");
+
+type ChannelReplyPayload = Parameters<typeof deliverDirect>[1];
+
+const DISCORD_CALLBACK = "https://gateway.example/deliver/discord";
+
+describe("a Discord reply reaches the Discord transport", () => {
+  test("the callback resolves to discord, absolute and relative", () => {
+    expect(channelForCallback(DISCORD_CALLBACK)).toBe("discord");
+    // Off-channel guardian flows emit a base-less callback.
+    expect(channelForCallback("/deliver/discord")).toBe("discord");
+    expect(channelForCallback("/deliver/discord?x=1")).toBe("discord");
+  });
+
+  test("the resolved transport is the one that can send", () => {
+    expect(isDirectDelivery(DISCORD_CALLBACK)).toBe(true);
+    const transport = getTransportForCallback(DISCORD_CALLBACK);
+    expect(transport).toBeDefined();
+    expect(typeof transport?.deliver).toBe("function");
+  });
+
+  test("a reply is delivered to the chat id it was addressed to", async () => {
+    sent.length = 0;
+    const payload: ChannelReplyPayload = {
+      chatId: "1409876543210987654",
+      text: "hello from the assistant",
+    };
+    await deliverDirect(DISCORD_CALLBACK, payload);
+
+    expect(sent).toHaveLength(1);
+    // `POST /channels/{id}/messages` addresses a channel and nothing more, so
+    // the chat id is the channel the reply lands in.
+    expect(sent[0]?.channelId).toBe("1409876543210987654");
+    expect(sent[0]?.text).toContain("hello from the assistant");
+  });
+
+  test("a threaded reply lands in the thread, which is its own channel", async () => {
+    sent.length = 0;
+    const payload: ChannelReplyPayload = {
+      chatId: "1409876543210987654",
+      text: "in the thread",
+    };
+    await deliverDirect(
+      `${DISCORD_CALLBACK}?threadId=1405555555555555555`,
+      payload,
+    );
+
+    expect(sent[0]?.channelId).toBe("1405555555555555555");
+  });
+
+  test("Discord declines streaming rather than faking it", () => {
+    // No primitive exists, so the transport omits the method and the caller
+    // sends the finished reply. An implementation here would be a repeated
+    // edit, which is the approach the platforms discourage.
+    expect(getTransportForCallback(DISCORD_CALLBACK)?.streamReply).toBe(
+      undefined,
+    );
+  });
+});

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

@@ -0,0 +1,237 @@
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+
+const originalVellumDev = process.env.VELLUM_DEV;
+process.env.VELLUM_DEV = "1";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+    child: () => ({
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      debug: () => {},
+    }),
+  }),
+}));
+
+let oauthConnectionStore: Record<string, { id: string; status: string }> = {};
+
+mock.module("../oauth/manual-token-connection.js", () => ({
+  ensureManualTokenConnection: async (provider: string) => {
+    oauthConnectionStore[provider] = {
+      id: `conn-${provider}`,
+      status: "active",
+    };
+  },
+  removeManualTokenConnection: (provider: string) => {
+    delete oauthConnectionStore[provider];
+  },
+  syncManualTokenConnection: async () => {},
+}));
+
+const originalFetch = globalThis.fetch;
+
+import {
+  clearDiscordChannelConfig,
+  getDiscordChannelConfig,
+  setDiscordChannelConfig,
+} from "../daemon/handlers/config-discord-channel.js";
+import { credentialKey } from "../security/credential-key.js";
+import * as secureKeys from "../security/secure-keys.js";
+import { _resetBackend, getSecureKeyAsync } from "../security/secure-keys.js";
+import { _setMetadataPath } from "../tools/credentials/metadata-store.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
+import { setConfig } from "./helpers/set-config.js";
+
+const BOT_TOKEN_KEY = credentialKey("discord_channel", "bot_token");
+
+/**
+ * The permission integer the parameterized invite link requests. The setup
+ * skill's invite script derives the same value from named bits; skills are
+ * import-isolated from this package, so equality is pinned here instead.
+ */
+const INVITE_PERMISSIONS = "277025770560";
+
+interface FakeDiscord {
+  meStatus?: number;
+  application?: unknown;
+}
+
+function installDiscordApi(fake: FakeDiscord) {
+  globalThis.fetch = (async (input: URL | RequestInfo) => {
+    const url = String(input);
+    if (url.endsWith("/users/@me")) {
+      return new Response(
+        JSON.stringify({ id: "900000000000000001", username: "test-bot" }),
+        { status: fake.meStatus ?? 200 },
+      );
+    }
+    if (url.endsWith("/oauth2/applications/@me")) {
+      return new Response(JSON.stringify(fake.application ?? {}), {
+        status: 200,
+      });
+    }
+    throw new Error(`Unexpected fetch: ${url}`);
+  }) as typeof fetch;
+}
+
+afterAll(() => {
+  globalThis.fetch = originalFetch;
+  _setMetadataPath(null);
+  setStorePathForTesting(null);
+  _resetBackend();
+  if (originalVellumDev === undefined) {
+    delete process.env.VELLUM_DEV;
+  } else {
+    process.env.VELLUM_DEV = originalVellumDev;
+  }
+});
+
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
+const secureStorePath = join(testDir, "discord-config-keys.enc");
+const metadataPath = join(testDir, "discord-config-metadata.json");
+
+beforeEach(() => {
+  oauthConnectionStore = {};
+  setConfig("discord", {});
+  rmSync(secureStorePath, { force: true });
+  rmSync(metadataPath, { force: true });
+  setStorePathForTesting(secureStorePath);
+  _resetBackend();
+  _setMetadataPath(metadataPath);
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("connecting a Discord bot", () => {
+  test("a valid token is stored and the identity read back", async () => {
+    installDiscordApi({
+      application: { id: "700000000000000001" },
+    });
+
+    const result = await setDiscordChannelConfig("bot-valid-token");
+
+    expect(result.success).toBe(true);
+    expect(result.connected).toBe(true);
+    expect(result.botUserId).toBe("900000000000000001");
+    expect(result.botUsername).toBe("test-bot");
+    expect(result.applicationId).toBe("700000000000000001");
+    expect(await getSecureKeyAsync(BOT_TOKEN_KEY)).toBe("bot-valid-token");
+
+    const read = await getDiscordChannelConfig();
+    expect(read.hasBotToken).toBe(true);
+    expect(read.botUsername).toBe("test-bot");
+  });
+
+  test("an app without install settings gets a parameterized invite link", async () => {
+    // The wizard's create step makes exactly this app: a client-id-only link
+    // would install nothing, so the link has to say what to grant.
+    installDiscordApi({ application: { id: "700000000000000001" } });
+
+    const result = await setDiscordChannelConfig("bot-valid-token");
+
+    const url = new URL(result.inviteUrl!);
+    expect(url.searchParams.get("client_id")).toBe("700000000000000001");
+    expect(url.searchParams.get("scope")).toBe("bot");
+    expect(url.searchParams.get("permissions")).toBe(INVITE_PERMISSIONS);
+  });
+
+  test("an app whose install settings grant bot gets a client-id-only link", async () => {
+    // The owner's Default Install Settings own the grant; parameters in the
+    // URL would silently override what they configured.
+    installDiscordApi({
+      application: {
+        id: "700000000000000001",
+        integration_types_config: {
+          "0": { oauth2_install_params: { scopes: ["bot"] } },
+        },
+      },
+    });
+
+    const result = await setDiscordChannelConfig("bot-valid-token");
+
+    const url = new URL(result.inviteUrl!);
+    expect(url.searchParams.get("client_id")).toBe("700000000000000001");
+    expect(url.searchParams.get("scope")).toBeNull();
+    expect(url.searchParams.get("permissions")).toBeNull();
+
+    // And the link survives a reload through the stored config.
+    const read = await getDiscordChannelConfig();
+    expect(read.inviteUrl).toBe(result.inviteUrl);
+  });
+
+  test("a rejected token stores nothing", async () => {
+    installDiscordApi({ meStatus: 401 });
+
+    const result = await setDiscordChannelConfig("bot-bad-token");
+
+    expect(result.success).toBe(false);
+    expect(result.hasBotToken).toBe(false);
+    expect(result.error).toContain("rejected");
+    expect(await getSecureKeyAsync(BOT_TOKEN_KEY)).toBeFalsy();
+  });
+});
+
+describe("disconnecting a Discord bot", () => {
+  test("clearing removes the token and the stored identity", async () => {
+    installDiscordApi({ application: { id: "700000000000000001" } });
+    await setDiscordChannelConfig("bot-valid-token");
+
+    const result = await clearDiscordChannelConfig();
+
+    expect(result.success).toBe(true);
+    expect(result.hasBotToken).toBe(false);
+    expect(result.connected).toBe(false);
+    expect(await getSecureKeyAsync(BOT_TOKEN_KEY)).toBeFalsy();
+    const read = await getDiscordChannelConfig();
+    expect(read.botUsername).toBeUndefined();
+    expect(read.inviteUrl).toBeUndefined();
+  });
+
+  test("a failed credential delete does not report a disconnect", async () => {
+    installDiscordApi({ application: { id: "700000000000000001" } });
+    await setDiscordChannelConfig("bot-valid-token");
+
+    const deleteSpy = spyOn(
+      secureKeys,
+      "deleteSecureKeyAsync",
+    ).mockResolvedValue("error");
+    try {
+      const result = await clearDiscordChannelConfig();
+      // The token is still stored, so the gateway's client stays connected: a
+      // success here would be a disconnect that did not happen.
+      expect(result.success).toBe(false);
+      expect(result.hasBotToken).toBe(true);
+      expect(result.connected).toBe(true);
+    } finally {
+      deleteSpy.mockRestore();
+    }
+    expect(await getSecureKeyAsync(BOT_TOKEN_KEY)).toBe("bot-valid-token");
+  });
+
+  test("clearing when nothing is stored is already disconnected", async () => {
+    const result = await clearDiscordChannelConfig();
+
+    expect(result.success).toBe(true);
+    expect(result.hasBotToken).toBe(false);
+  });
+});