@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/__tests__/credential-record-write-through.test.ts

@@ -0,0 +1,78 @@
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { credentialKey } from "@vellumai/credential-storage";
+import type { CredentialRecord } from "@vellumai/service-contracts/credential-rpc";
+
+import type { CredentialRecordBackend } from "../security/ces-rpc-record-backend.js";
+import {
+  _setMetadataPath,
+  persistCredentialMetadata,
+  setCredentialRecordBackend,
+  upsertCredentialMetadata,
+} from "../tools/credentials/metadata-store.js";
+
+function makeBackend(): CredentialRecordBackend & {
+  store: Map<string, CredentialRecord>;
+} {
+  const store = new Map<string, CredentialRecord>();
+  return {
+    store,
+    isAvailable: () => true,
+    get: async (account) => store.get(account),
+    set: async (account, record) => {
+      store.set(account, record);
+      return true;
+    },
+    delete: async (account) => {
+      if (!store.has(account)) {
+        return "not-found";
+      }
+      store.delete(account);
+      return "deleted";
+    },
+    list: async () =>
+      [...store.entries()].map(([account, record]) => ({ account, record })),
+    bulkSet: async (records) => {
+      for (const { account, record } of records) {
+        store.set(account, record);
+      }
+      return records.map((entry) => ({ account: entry.account, ok: true }));
+    },
+  };
+}
+
+describe("CES credential record write-through", () => {
+  afterEach(() => {
+    setCredentialRecordBackend(undefined);
+    _setMetadataPath(null);
+  });
+
+  test("upsert write-through updates the CES backend", async () => {
+    const backend = makeBackend();
+    setCredentialRecordBackend(backend);
+
+    const created = upsertCredentialMetadata("slack_channel", "bot_token", {
+      allowedTools: ["bash"],
+    });
+    await persistCredentialMetadata(created);
+
+    const stored = backend.store.get(
+      credentialKey("slack_channel", "bot_token"),
+    );
+    expect(stored?.allowedTools).toEqual(["bash"]);
+    expect(stored?.credentialId).toBe(created.credentialId);
+  });
+
+  test("test metadata path override skips CES write-through", async () => {
+    const backend = makeBackend();
+    setCredentialRecordBackend(backend);
+    _setMetadataPath("/tmp/does-not-write-through-metadata.json");
+
+    const created = upsertCredentialMetadata("github", "token", {
+      allowedTools: ["bash"],
+    });
+    await persistCredentialMetadata(created);
+
+    expect(backend.store.size).toBe(0);
+  });
+});

package/src/__tests__/credential-routes.test.ts

@@ -749,12 +749,28 @@ describe("credentials routes", () => {
       expect(entry.service).toBe("vercel");
       expect(entry.field).toBe("api_token");
       expect(entry.hasSecret).toBe(true);
-      expect(entry.scrubbedValue).toBe("****alue");
+      expect(entry.scrubbedValue).toBe("supe****");
 
       // AND the raw secret never appears anywhere in the response
       expect(JSON.stringify(result)).not.toContain(SECRET_VALUE);
     });
 
+    test("masked preview keeps a vendor token prefix", async () => {
+      const token = "cfat_000000000000000000000000000000000000abcd";
+      await setRoute!.handler({
+        body: {
+          service: "cloudflare",
+          field: "api_token",
+          value: token,
+        },
+      });
+
+      const result = (await listRoute!.handler({ body: {} })) as ListResponse;
+      expect(result.credentials).toHaveLength(1);
+      expect(result.credentials[0].scrubbedValue).toBe("cfat****");
+      expect(JSON.stringify(result)).not.toContain(token);
+    });
+
     test("filters credentials by search substring", async () => {
       /**
        * The optional `search` filter restricts the listing to credentials

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__/delete-propagation.test.ts

@@ -9,6 +9,8 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { readProviderMetadata } from "../messaging/read-provider-metadata.js";
+
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
@@ -249,7 +251,10 @@ describe("Slack delete propagation", () => {
     expect(slackMeta!.deletedAt).toBeUndefined();
   });
 
-  test("delete for row without slackMeta is a no-op (legacy row)", async () => {
+  test("delete for row without slackMeta stamps the neutral metadata", async () => {
+    // A legacy pre-enrichment row still gets its delete marked: the neutral
+    // envelope is synthesized so readProviderMetadata serves the stamp to
+    // every channel-agnostic reader, and content stays for audit.
     const seeded = seedSlackMessage({
       externalChatId: "C0123CHANNEL",
       originalTs: "2222.2222",
@@ -257,6 +262,7 @@ describe("Slack delete propagation", () => {
       withSlackMeta: false,
     });
 
+    const before = Date.now();
     const req = buildSlackDeleteRequest({
       externalChatId: seeded.externalChatId,
       deletedTs: seeded.originalTs,
@@ -265,7 +271,7 @@ describe("Slack delete propagation", () => {
     const json = (await resp.json()) as Record<string, unknown>;
 
     expect(json.accepted).toBe(true);
-    expect(json.deleted).toBe(false);
+    expect(json.deleted).toBe(true);
 
     const db = getDb();
     const row = db
@@ -277,6 +283,90 @@ describe("Slack delete propagation", () => {
     expect(row!.content).toBe("Legacy pre-upgrade text");
     const parsed = JSON.parse(row!.metadata!) as Record<string, unknown>;
     expect(parsed.slackMeta).toBeUndefined();
+    const neutral = readProviderMetadata(row!.metadata);
+    expect(neutral).not.toBeNull();
+    expect(neutral!.source).toBe("slack");
+    expect(neutral!.messageId).toBe(seeded.originalTs);
+    expect(neutral!.deletedAt).toBeDefined();
+    expect(neutral!.deletedAt!).toBeGreaterThanOrEqual(before);
+  });
+
+  test("a flat-legacy row's fields survive the delete stamp", async () => {
+    // Rows written before slackMeta nesting carry the Slack envelope flat in
+    // messages.metadata. The stamp bases on the mapped envelope, so thread
+    // and display identity remain readable beside deletedAt instead of
+    // being shadowed by a minimal synthesis.
+    const seeded = seedSlackMessage({
+      externalChatId: "C0123CHANNEL",
+      originalTs: "3333.3333",
+      content: "Flat legacy text",
+      withSlackMeta: false,
+    });
+    const db = getDb();
+    db.update(messages)
+      .set({
+        metadata: JSON.stringify({
+          source: "slack",
+          channelId: seeded.externalChatId,
+          channelTs: seeded.originalTs,
+          threadTs: "3000.0001",
+          eventKind: "message",
+          displayName: "Flat User",
+        }),
+      })
+      .where(eq(messages.id, seeded.messageId))
+      .run();
+
+    const req = buildSlackDeleteRequest({
+      externalChatId: seeded.externalChatId,
+      deletedTs: seeded.originalTs,
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+    expect(json.deleted).toBe(true);
+
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, seeded.messageId))
+      .get();
+    const neutral = readProviderMetadata(row!.metadata);
+    expect(neutral).not.toBeNull();
+    expect(neutral!.deletedAt).toBeDefined();
+    expect(neutral!.threadId).toBe("3000.0001");
+    expect(neutral!.displayName).toBe("Flat User");
+  });
+
+  test("a row with malformed metadata still records its delete", async () => {
+    const seeded = seedSlackMessage({
+      externalChatId: "C0123CHANNEL",
+      originalTs: "4444.4444",
+      content: "Row with broken envelope",
+      withSlackMeta: false,
+    });
+    const db = getDb();
+    db.update(messages)
+      .set({ metadata: "{not json" })
+      .where(eq(messages.id, seeded.messageId))
+      .run();
+
+    const req = buildSlackDeleteRequest({
+      externalChatId: seeded.externalChatId,
+      deletedTs: seeded.originalTs,
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(true);
+
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, seeded.messageId))
+      .get();
+    const neutral = readProviderMetadata(row!.metadata);
+    expect(neutral).not.toBeNull();
+    expect(neutral!.deletedAt).toBeDefined();
   });
 
   test("delete missing sourceMetadata.messageId is a no-op", async () => {

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,
+    );
+  });
+});