@vellumai/vellum-gateway 0.12.6 → 0.12.7-staging.1

package/AGENTS.md

@@ -169,7 +169,7 @@ A default row per enforced channel is **seeded at startup** (`seedAdmissionPolic
 | Policy             | Floor | Notes                                                                                                                         |
 | ------------------ | ----- | ----------------------------------------------------------------------------------------------------------------------------- |
 | `no_one`           | 5     | Hard-deny at gateway _before_ forwarding (kill switch in `handle-inbound.ts`). Includes the guardian — this channel is _OFF_. |
-| `guardian_only`    | 4     | Seeded default for `vellum`.                                                                                                  |
+| `guardian_only`    | 4     | Seeded default for `vellum` and `vellum-shared`.                                                                              |
 | `trusted_contacts` | 3     | Seeded default for all other channels; also the read-path safety fallback.                                                    |
 | `any_contact`      | 2     | May surface Slack DM / email upgrade challenge on deny.                                                                       |
 | `strangers`        | 1     | May surface upgrade challenge.                                                                                                |
@@ -183,7 +183,7 @@ A default row per enforced channel is **seeded at startup** (`seedAdmissionPolic
 
 For exempt ids, `PUT /v1/assistants/:id/channel-admission-policy/:channelType` returns **403**, the GET list omits them, and the runtime short-circuits `admitted: true` in `admission-policy.ts` (defense in depth). Codex finding from #35006 review: exemption checks must live in _both_ the gateway route handler AND the runtime stage — single-side enforcement creates a misuse wedge.
 
-**Hidden channels** (`ADMISSION_POLICY_HIDDEN_CHANNELS` = `vellum`, `whatsapp`) — managed automatically, **not** user-configurable, but (unlike exempt channels) **still enforced at runtime**:
+**Hidden channels** (`ADMISSION_POLICY_HIDDEN_CHANNELS` = `vellum`, `vellum-shared`, `whatsapp`): managed automatically, **not** user-configurable, but (unlike exempt channels) **still enforced at runtime**:
 
 - The GET list omits them, and `PUT`/`DELETE` return **403** (`isAdmissionPolicyHiddenChannel`).
 - They are **not** exempt — the runtime still evaluates rank-vs-floor, so a real inbound channel like `whatsapp` keeps its admission floor.

package/ARCHITECTURE.md

@@ -207,10 +207,11 @@ All contact paths are registered flat only (`/v1/contacts...`, `/v1/contact-chan
 | DELETE   | `/v1/contacts/invites/:inviteId`      |
 | POST     | `/v1/contacts/invites/:inviteId/call` |
 | POST     | `/v1/contacts/invites/redeem`         |
+| POST     | `/v1/shared/invites/redeem`           |
 
 **Authentication boundary:**
 
-- Gateway validates the caller's JWT bearer token.
+- Gateway validates the caller's JWT bearer token, except on `/v1/shared/invites/redeem`, where the `vellum-shared` invite link token in the body is the credential (see Invite-based onboarding).
 - Native contact/invite endpoints are served from the gateway DB after that bearer-auth check; runtime-relayed requests (Telegram control plane, contact search reads) reach the runtime with a minted JWT (`gateway_ingress_v1` or `gateway_service_v1` scope profile).
 - Upstream 4xx/5xx responses are passed through, while connection errors return `502` and timeouts return `504`.
 
@@ -609,6 +610,8 @@ The channel inbound handler (`inbound-message-handler.ts`) enforces an access co
 
 **Invite-based onboarding:** Invite tokens are minted by the gateway via the invite HTTP API and stored SHA-256 hashed on the gateway DB's `ingress_invites` row -- the raw token is returned exactly once at creation time. External users redeem invites by sending the token as a channel message, which atomically creates a member record with `active` status and `allow` policy.
 
+A `vellum-shared` invite is redeemed instead through `POST /v1/shared/invites/redeem`, which the platform calls on the invitee's behalf with the link token and a device id. In one gateway DB transaction it claims the invite's single use, mints a principal, binds it to the invite's contact-role contact, records it as that contact's active `vellum-shared` channel, and mints a device-bound `contact`-role token pair; a failure at any step rolls all of it back and leaves the invite redeemable. `writeSharedPrincipalChannel` is the only writer of `vellum-shared` rows. The route accepts only the link token, never the 6-digit code, answers 404 while `vellum-trusted-contacts` is off, limits failed attempts per client IP, and is denied at the remote web ingress. The principal then resolves as `trusted_contact` through its `vellum-shared` channel for as long as that channel stays active.
+
 **Relationship to guardian verification:** Guardian verification and ingress contact management are independent systems. Guardian verification establishes who controls the assistant on a channel (the trust anchor for approvals). Ingress contacts control who can interact with the assistant.
 
 #### SQLite Tables
@@ -639,6 +642,8 @@ The gateway declares `contacts` and `contact_channels` tables and exposes them v
 | `gateway/src/http/routes/contacts-control-plane-proxy.ts` | Gateway-native invite lifecycle (mint, list, revoke, redeem) shared by HTTP and IPC              |
 | `gateway/src/ipc/invite-handlers.ts`                      | IPC routes relaying the daemon's invite surfaces to the native functions                         |
 | `gateway/src/verification/invite-redemption.ts`           | Redemption engine — validation, atomic claim, ACL activation                                     |
+| `gateway/src/verification/shared-invite-redemption.ts`    | `vellum-shared` invite redemption: claim, principal, channel and token pair in one transaction   |
+| `gateway/src/http/routes/shared-invite-redeem.ts`         | `POST /v1/shared/invites/redeem`: flag gate, request schema, per-IP failure limit                |
 | `assistant/src/contacts/contact-store.ts`                 | Contact and channel lookups (findContactChannel, guardian bindings)                              |
 | `assistant/src/contacts/contacts-write.ts`                | Contact and channel identity/info writes (upsert, redemption info mirror — ACL is gateway-owned) |
 | `assistant/src/ipc/routes/invite-ipc-routes.ts`           | `invite_redeemed` info mirror — local contact/channel identity upsert                            |

package/README.md

@@ -156,6 +156,7 @@ Control-plane routes are listed with their flat paths. Clients emit assistant-sc
 | `/v1/contacts/invites/:id`                            | DELETE          | Gateway-native invite revoke                                                                                                                  |
 | `/v1/contacts/invites/:id/call`                       | POST            | Gateway-native invite-call relay — validates the invite row, then delegates the provider call to the assistant                                |
 | `/v1/contacts/invites/redeem`                         | POST            | Gateway-native invite redemption (voice code and link token)                                                                                  |
+| `/v1/shared/invites/redeem`                           | POST            | Unauthenticated `vellum-shared` invite redemption for a contact principal and token pair; 404 while `vellum-trusted-contacts` is off          |
 | `/v1/health`                                          | GET             | Authenticated runtime health proxy (`/v1/health` on runtime)                                                                                  |
 | `/healthz`                                            | GET             | Liveness probe                                                                                                                                |
 | `/readyz`                                             | GET             | Readiness probe                                                                                                                               |

package/node_modules/@vellumai/ces-client/node_modules/@vellumai/service-contracts/src/__tests__/channels.test.ts

@@ -24,6 +24,7 @@ describe("isChannelId", () => {
     // so these must remain canonical for that assertion to mean anything.
     expect(isChannelId("platform")).toBe(true);
     expect(isChannelId("vellum")).toBe(true);
+    expect(isChannelId("vellum-shared")).toBe(true);
   });
 
   test("includes discord", () => {
@@ -58,6 +59,7 @@ describe("botProviderForChannel and channelForBotProvider", () => {
   test("answer nothing for a channel without a bot, a person's grant, or an unknown key", () => {
     expect(botProviderForChannel("phone")).toBeUndefined();
     expect(botProviderForChannel("vellum")).toBeUndefined();
+    expect(botProviderForChannel("vellum-shared")).toBeUndefined();
     expect(botProviderForChannel("not-a-channel")).toBeUndefined();
     // `slack` is the person's integration standing beside the bot's key.
     expect(channelForBotProvider("slack")).toBeUndefined();

package/node_modules/@vellumai/ces-client/node_modules/@vellumai/service-contracts/src/channels.ts

@@ -4,8 +4,9 @@
  *
  * A "channel" is an external messaging surface an actor can reach the
  * assistant through (Slack, Telegram, WhatsApp, phone, …) plus a couple of
- * internal ids (`vellum` for native app conversations, `platform` for the
- * internal control plane). This is the single source of truth for that set:
+ * internal ids (`vellum` for native app conversations, `vellum-shared` for
+ * conversations a guardian shares with a contact, `platform` for the internal
+ * control plane). This is the single source of truth for that set:
  *
  * One id, `plugin`, does not name a surface: it names *every* surface a plugin
  * brings. A plugin channel's real identity is the plugin, which is workspace
@@ -41,6 +42,9 @@ export const CHANNEL_IDS = [
   "a2a",
   "discord",
   "plugin",
+  // Internal id for conversations a guardian shares with a contact. It has no
+  // transport: the contact's own client holds the connection.
+  "vellum-shared",
 ] as const;
 
 export type ChannelId = (typeof CHANNEL_IDS)[number];
@@ -78,8 +82,8 @@ export function isChannelId(value: unknown): value is ChannelId {
  * here would be a second copy of a different fact.
  *
  * Channels absent from this map reach the assistant without a bot credential
- * of their own: `phone` through the voice provider, `vellum` and `platform`
- * internally.
+ * of their own: `phone` through the voice provider, `vellum`, `vellum-shared`
+ * and `platform` internally.
  */
 export const CHANNEL_BOT_PROVIDER = {
   slack: "slack_channel",

package/node_modules/@vellumai/gateway-client/node_modules/@vellumai/service-contracts/src/__tests__/channels.test.ts

@@ -24,6 +24,7 @@ describe("isChannelId", () => {
     // so these must remain canonical for that assertion to mean anything.
     expect(isChannelId("platform")).toBe(true);
     expect(isChannelId("vellum")).toBe(true);
+    expect(isChannelId("vellum-shared")).toBe(true);
   });
 
   test("includes discord", () => {
@@ -58,6 +59,7 @@ describe("botProviderForChannel and channelForBotProvider", () => {
   test("answer nothing for a channel without a bot, a person's grant, or an unknown key", () => {
     expect(botProviderForChannel("phone")).toBeUndefined();
     expect(botProviderForChannel("vellum")).toBeUndefined();
+    expect(botProviderForChannel("vellum-shared")).toBeUndefined();
     expect(botProviderForChannel("not-a-channel")).toBeUndefined();
     // `slack` is the person's integration standing beside the bot's key.
     expect(channelForBotProvider("slack")).toBeUndefined();

package/node_modules/@vellumai/gateway-client/node_modules/@vellumai/service-contracts/src/channels.ts

@@ -4,8 +4,9 @@
  *
  * A "channel" is an external messaging surface an actor can reach the
  * assistant through (Slack, Telegram, WhatsApp, phone, …) plus a couple of
- * internal ids (`vellum` for native app conversations, `platform` for the
- * internal control plane). This is the single source of truth for that set:
+ * internal ids (`vellum` for native app conversations, `vellum-shared` for
+ * conversations a guardian shares with a contact, `platform` for the internal
+ * control plane). This is the single source of truth for that set:
  *
  * One id, `plugin`, does not name a surface: it names *every* surface a plugin
  * brings. A plugin channel's real identity is the plugin, which is workspace
@@ -41,6 +42,9 @@ export const CHANNEL_IDS = [
   "a2a",
   "discord",
   "plugin",
+  // Internal id for conversations a guardian shares with a contact. It has no
+  // transport: the contact's own client holds the connection.
+  "vellum-shared",
 ] as const;
 
 export type ChannelId = (typeof CHANNEL_IDS)[number];
@@ -78,8 +82,8 @@ export function isChannelId(value: unknown): value is ChannelId {
  * here would be a second copy of a different fact.
  *
  * Channels absent from this map reach the assistant without a bot credential
- * of their own: `phone` through the voice provider, `vellum` and `platform`
- * internally.
+ * of their own: `phone` through the voice provider, `vellum`, `vellum-shared`
+ * and `platform` internally.
  */
 export const CHANNEL_BOT_PROVIDER = {
   slack: "slack_channel",

package/node_modules/@vellumai/gateway-client/src/__tests__/route-trust-class.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import {
+  isTrustCheckedScopeProfile,
+  routeAdmitsTrustClass,
+  tokenMayReachRoute,
+  TRUST_EXEMPT_SCOPE_PROFILES,
+} from "../route-trust-class.js";
+
+const CONTACT_ROUTE = ["guardian", "trusted_contact", "unverified_contact"];
+
+const contactMayReach = (
+  allowed: readonly string[] | undefined,
+  resolve: () => Promise<string | undefined>,
+) => tokenMayReachRoute("contact_client_v1", allowed, resolve);
+
+describe("routeAdmitsTrustClass", () => {
+  test("an absent list admits the guardian only", () => {
+    expect(routeAdmitsTrustClass(undefined, "guardian")).toBe(true);
+    expect(routeAdmitsTrustClass(undefined, "trusted_contact")).toBe(false);
+    expect(routeAdmitsTrustClass(undefined, "unknown")).toBe(false);
+  });
+
+  test("a listed class is admitted and an unlisted one refused", () => {
+    expect(routeAdmitsTrustClass(CONTACT_ROUTE, "trusted_contact")).toBe(true);
+    expect(routeAdmitsTrustClass(CONTACT_ROUTE, "unknown")).toBe(false);
+  });
+
+  test("a value outside the vocabulary is refused even when listed", () => {
+    expect(routeAdmitsTrustClass(["owner"], "owner")).toBe(false);
+    expect(routeAdmitsTrustClass(CONTACT_ROUTE, undefined)).toBe(false);
+  });
+});
+
+describe("tokenMayReachRoute for a contact token", () => {
+  test("a route admitting only the guardian refuses without resolving", async () => {
+    const resolve = mock(async () => "trusted_contact");
+    expect(await contactMayReach(undefined, resolve)).toBe(false);
+    expect(await contactMayReach(["guardian"], resolve)).toBe(false);
+    expect(resolve).not.toHaveBeenCalled();
+  });
+
+  test.each([
+    ["trusted_contact", true],
+    ["unverified_contact", true],
+    ["unknown", false],
+    ["guardian", false],
+    [undefined, false],
+  ] as const)(
+    "a contact route resolving %p admits: %p",
+    async (trustClass, admitted) => {
+      expect(await contactMayReach(CONTACT_ROUTE, async () => trustClass)).toBe(
+        admitted,
+      );
+    },
+  );
+
+  test("a class the route does not list is refused", async () => {
+    expect(
+      await contactMayReach(
+        ["guardian", "trusted_contact"],
+        async () => "unverified_contact",
+      ),
+    ).toBe(false);
+  });
+
+  test("a resolver that throws refuses", async () => {
+    expect(
+      await contactMayReach(CONTACT_ROUTE, async () => {
+        throw new Error("gateway unreachable");
+      }),
+    ).toBe(false);
+  });
+});
+
+describe("isTrustCheckedScopeProfile", () => {
+  test("an exempt profile is not trust-checked", () => {
+    for (const profile of TRUST_EXEMPT_SCOPE_PROFILES) {
+      expect(isTrustCheckedScopeProfile(profile)).toBe(false);
+    }
+  });
+
+  test("the contact profile, unknown profiles and prototype keys are", () => {
+    for (const profile of [
+      "contact_client_v1",
+      "bogus_v1",
+      "toString",
+      "constructor",
+      "__proto__",
+    ]) {
+      expect(isTrustCheckedScopeProfile(profile)).toBe(true);
+    }
+  });
+});
+
+describe("tokenMayReachRoute for a trust-exempt token", () => {
+  test.each([...TRUST_EXEMPT_SCOPE_PROFILES])(
+    "%s counts as the guardian without a lookup",
+    async (profile) => {
+      const resolve = mock(async () => "trusted_contact");
+      expect(await tokenMayReachRoute(profile, undefined, resolve)).toBe(true);
+      expect(await tokenMayReachRoute(profile, CONTACT_ROUTE, resolve)).toBe(
+        true,
+      );
+      expect(
+        await tokenMayReachRoute(profile, ["trusted_contact"], resolve),
+      ).toBe(false);
+      expect(resolve).not.toHaveBeenCalled();
+    },
+  );
+});

package/node_modules/@vellumai/gateway-client/src/admission-policy-contract.ts

@@ -56,8 +56,8 @@ export const ADMISSION_FLOOR: Record<AdmissionPolicy, number> = {
  *
  * `phone` is NOT exempt — voice ingress enforces the admission floor.
  *
- * `vellum` / `whatsapp` are NOT exempt — their floors are still enforced at
- * runtime — but they are hidden from the configurable UI; see
+ * `vellum` / `vellum-shared` / `whatsapp` are NOT exempt: their floors are
+ * still enforced at runtime, but they are hidden from the configurable UI; see
  * {@link ADMISSION_POLICY_HIDDEN_CHANNELS}.
  */
 export const ADMISSION_POLICY_EXEMPT_CHANNELS: ReadonlySet<string> = new Set([
@@ -81,9 +81,12 @@ export function isAdmissionPolicyExemptChannel(channelType: string): boolean {
  * `vellum` is the local desktop/web client surface; the guardian is always
  * max-rank there, so the seed default admits them regardless of the floor.
  *
+ * `vellum-shared` carries conversations a guardian shares with a contact. Its
+ * seed default is `guardian_only`, which admits no contact.
  */
 export const ADMISSION_POLICY_HIDDEN_CHANNELS: ReadonlySet<string> = new Set([
   "vellum",
+  "vellum-shared",
   "whatsapp",
 ]);
 

package/node_modules/@vellumai/gateway-client/src/index.ts

@@ -132,6 +132,15 @@ export type {
   TrustVerdict,
 } from "./trust-verdict-contract.js";
 
+// Route trust class, applied by both the daemon router and the gateway IPC proxy
+export {
+  DEFAULT_ROUTE_TRUST_CLASSES,
+  isTrustCheckedScopeProfile,
+  routeAdmitsTrustClass,
+  tokenMayReachRoute,
+  TRUST_EXEMPT_SCOPE_PROFILES,
+} from "./route-trust-class.js";
+
 // Invite contract (shared gateway ↔ daemon) — hash/generate helpers,
 // channel gating, redemption outcome, method map + invite IPC schemas
 export {

package/node_modules/@vellumai/gateway-client/src/route-trust-class.ts

@@ -0,0 +1,94 @@
+/**
+ * Which trust classes a route admits, shared by the daemon's HTTP router and
+ * the gateway's IPC proxy so both enforcement points apply one rule.
+ *
+ * A route policy's `allowedTrustClasses` reaches the gateway on the IPC route
+ * schema as plain strings, and is absent from a null policy or a schema served
+ * by a daemon that predates the field. Absent means guardian only.
+ */
+
+import { isTrustClass, type TrustClass } from "./trust-verdict-contract.js";
+
+/**
+ * Scope profiles whose holders are not trust-checked: the guardian's own
+ * client, and service, local and single-route grants that route policy
+ * already governs. Any profile not listed here is trust-checked, so an
+ * unknown or newly added profile fails closed until it is judged exempt.
+ */
+export const TRUST_EXEMPT_SCOPE_PROFILES: readonly string[] = [
+  "actor_client_v1",
+  "gateway_ingress_v1",
+  "gateway_service_v1",
+  "local_v1",
+  "oauth_proxy_v1",
+  "speech_relay_v1",
+  "ui_page_v1",
+];
+
+const TRUST_EXEMPT_SET: ReadonlySet<string> = new Set(
+  TRUST_EXEMPT_SCOPE_PROFILES,
+);
+
+/**
+ * True when a token of `profile` reaches a route only if the route admits
+ * its holder's trust class.
+ */
+export function isTrustCheckedScopeProfile(profile: string): boolean {
+  return !TRUST_EXEMPT_SET.has(profile);
+}
+
+/** Trust classes a route admits when its policy names none. */
+export const DEFAULT_ROUTE_TRUST_CLASSES: readonly TrustClass[] = ["guardian"];
+
+/**
+ * Whether a route admitting `allowedTrustClasses` admits a caller of
+ * `trustClass`. A value outside the vocabulary is refused, since a wire-sourced
+ * class can carry anything.
+ */
+export function routeAdmitsTrustClass(
+  allowedTrustClasses: readonly string[] | undefined,
+  trustClass: string | undefined,
+): boolean {
+  if (typeof trustClass !== "string" || !isTrustClass(trustClass)) {
+    return false;
+  }
+  return (allowedTrustClasses ?? DEFAULT_ROUTE_TRUST_CLASSES).includes(
+    trustClass,
+  );
+}
+
+/**
+ * Whether a caller whose token carries `scopeProfile` may reach a route
+ * admitting `allowedTrustClasses`.
+ *
+ * A trust-exempt profile stands for the guardian, so it reaches exactly the
+ * routes that admit `guardian`, with no lookup. That is every route naming no
+ * classes.
+ *
+ * A trust-checked token never speaks for the guardian, so a route admitting no
+ * other class refuses it without calling `resolveTrustClass`. Otherwise the
+ * resolved class must be one the route admits and must not be `guardian`. A
+ * resolver that throws or resolves nothing refuses.
+ */
+export async function tokenMayReachRoute(
+  scopeProfile: string,
+  allowedTrustClasses: readonly string[] | undefined,
+  resolveTrustClass: () => Promise<string | undefined>,
+): Promise<boolean> {
+  if (!isTrustCheckedScopeProfile(scopeProfile)) {
+    return routeAdmitsTrustClass(allowedTrustClasses, "guardian");
+  }
+  const allowed = allowedTrustClasses ?? DEFAULT_ROUTE_TRUST_CLASSES;
+  if (!allowed.some((trustClass) => trustClass !== "guardian")) {
+    return false;
+  }
+  let trustClass: string | undefined;
+  try {
+    trustClass = await resolveTrustClass();
+  } catch {
+    return false;
+  }
+  return (
+    trustClass !== "guardian" && routeAdmitsTrustClass(allowed, trustClass)
+  );
+}

package/node_modules/@vellumai/service-contracts/src/__tests__/channels.test.ts

@@ -24,6 +24,7 @@ describe("isChannelId", () => {
     // so these must remain canonical for that assertion to mean anything.
     expect(isChannelId("platform")).toBe(true);
     expect(isChannelId("vellum")).toBe(true);
+    expect(isChannelId("vellum-shared")).toBe(true);
   });
 
   test("includes discord", () => {
@@ -58,6 +59,7 @@ describe("botProviderForChannel and channelForBotProvider", () => {
   test("answer nothing for a channel without a bot, a person's grant, or an unknown key", () => {
     expect(botProviderForChannel("phone")).toBeUndefined();
     expect(botProviderForChannel("vellum")).toBeUndefined();
+    expect(botProviderForChannel("vellum-shared")).toBeUndefined();
     expect(botProviderForChannel("not-a-channel")).toBeUndefined();
     // `slack` is the person's integration standing beside the bot's key.
     expect(channelForBotProvider("slack")).toBeUndefined();

package/node_modules/@vellumai/service-contracts/src/channels.ts

@@ -4,8 +4,9 @@
  *
  * A "channel" is an external messaging surface an actor can reach the
  * assistant through (Slack, Telegram, WhatsApp, phone, …) plus a couple of
- * internal ids (`vellum` for native app conversations, `platform` for the
- * internal control plane). This is the single source of truth for that set:
+ * internal ids (`vellum` for native app conversations, `vellum-shared` for
+ * conversations a guardian shares with a contact, `platform` for the internal
+ * control plane). This is the single source of truth for that set:
  *
  * One id, `plugin`, does not name a surface: it names *every* surface a plugin
  * brings. A plugin channel's real identity is the plugin, which is workspace
@@ -41,6 +42,9 @@ export const CHANNEL_IDS = [
   "a2a",
   "discord",
   "plugin",
+  // Internal id for conversations a guardian shares with a contact. It has no
+  // transport: the contact's own client holds the connection.
+  "vellum-shared",
 ] as const;
 
 export type ChannelId = (typeof CHANNEL_IDS)[number];
@@ -78,8 +82,8 @@ export function isChannelId(value: unknown): value is ChannelId {
  * here would be a second copy of a different fact.
  *
  * Channels absent from this map reach the assistant without a bot credential
- * of their own: `phone` through the voice provider, `vellum` and `platform`
- * internally.
+ * of their own: `phone` through the voice provider, `vellum`, `vellum-shared`
+ * and `platform` internally.
  */
 export const CHANNEL_BOT_PROVIDER = {
   slack: "slack_channel",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/vellum-gateway",
-  "version": "0.12.6",
+  "version": "0.12.7-staging.1",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -133,6 +133,7 @@ describe("GET /v1/channel-admission-policy", () => {
     store.set("a2a", "guardian_only");
     store.set("vellum", "guardian_only");
     store.set("whatsapp", "guardian_only");
+    store.set("vellum-shared", "guardian_only");
 
     const handler = createChannelAdmissionPolicyListHandler();
     const res = await handler(
@@ -145,6 +146,7 @@ describe("GET /v1/channel-admission-policy", () => {
     expect(seen.has("a2a")).toBe(false);
     expect(seen.has("vellum")).toBe(false);
     expect(seen.has("whatsapp")).toBe(false);
+    expect(seen.has("vellum-shared")).toBe(false);
     // phone is enforced + visible; other visible channels still surface.
     expect(seen.has("phone")).toBe(true);
     expect(seen.has("telegram")).toBe(true);
@@ -161,11 +163,10 @@ describe("PUT /v1/channel-admission-policy/:channelType", () => {
   test("upserts a valid policy and invalidates the cache", async () => {
     const handler = createChannelAdmissionPolicySetHandler();
     const res = await handler(
-      jsonRequest(
-        "http://localhost/v1/channel-admission-policy/slack",
-        "PUT",
-        { policy: "guardian_only", note: "tight" },
-      ),
+      jsonRequest("http://localhost/v1/channel-admission-policy/slack", "PUT", {
+        policy: "guardian_only",
+        note: "tight",
+      }),
       "slack",
     );
     expect(res.status).toBe(200);
@@ -199,11 +200,9 @@ describe("PUT /v1/channel-admission-policy/:channelType", () => {
   test("rejects invalid policy with 400", async () => {
     const handler = createChannelAdmissionPolicySetHandler();
     const res = await handler(
-      jsonRequest(
-        "http://localhost/v1/channel-admission-policy/email",
-        "PUT",
-        { policy: "lets-everyone-in" },
-      ),
+      jsonRequest("http://localhost/v1/channel-admission-policy/email", "PUT", {
+        policy: "lets-everyone-in",
+      }),
       "email",
     );
     expect(res.status).toBe(400);
@@ -242,11 +241,11 @@ describe("PUT /v1/channel-admission-policy/:channelType", () => {
     expect(body.policy.note).toBeNull();
   });
 
-  test("rejects PUT for hidden channels (`vellum`, `whatsapp`) with 403", async () => {
+  test("rejects PUT for hidden channels (`vellum`, `vellum-shared`, `whatsapp`) with 403", async () => {
     // Hidden channels are managed automatically and not user-configurable;
     // even a non-kill-switch policy must be rejected so no stranded row forms.
     const handler = createChannelAdmissionPolicySetHandler();
-    for (const channel of ["vellum", "whatsapp"] as const) {
+    for (const channel of ["vellum", "vellum-shared", "whatsapp"] as const) {
       const res = await handler(
         jsonRequest(
           `http://localhost/v1/channel-admission-policy/${channel}`,
@@ -298,7 +297,10 @@ describe("DELETE /v1/channel-admission-policy/:channelType", () => {
     store.set("slack", "guardian_only");
     const handler = createChannelAdmissionPolicyDeleteHandler();
     const res = await handler(
-      jsonRequest("http://localhost/v1/channel-admission-policy/slack", "DELETE"),
+      jsonRequest(
+        "http://localhost/v1/channel-admission-policy/slack",
+        "DELETE",
+      ),
       "slack",
     );
     expect(res.status).toBe(200);
@@ -335,7 +337,9 @@ describe("GET /v1/channel-admission-policy — phone enforced", () => {
       jsonRequest("http://localhost/v1/channel-admission-policy", "GET"),
     );
     expect(res.status).toBe(200);
-    const body = (await res.json()) as { policies: Array<{ channelType: string }> };
+    const body = (await res.json()) as {
+      policies: Array<{ channelType: string }>;
+    };
     const seen = new Set(body.policies.map((p) => p.channelType));
     expect(seen.has("phone")).toBe(true);
     // Confirm other non-exempt channels still appear.