@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231715.8da971c

package/src/cli/lib/plugin-catalog-platform.ts

@@ -7,15 +7,17 @@
  * catalog sourced from the platform is indistinguishable from one read off
  * GitHub.
  *
- * Every failure mode (non-2xx, unreachable/aborted, malformed body) throws
- * {@link PluginCatalogUnavailableError} — the fetcher never returns a partial
- * or silently-empty catalog, so a caller can safely fall back to a bundled
- * offline copy instead of mistaking an outage for "no plugins".
+ * Every failure mode (non-2xx, unreachable/aborted, malformed envelope)
+ * throws {@link PluginCatalogUnavailableError}, so a caller never mistakes an
+ * outage for "no plugins". Rows are validated one at a time: a row with an
+ * invalid `integration` is kept without it, and a row that fails the base
+ * row schema is skipped, so one bad row never blanks the whole catalog.
  */
 
 import { z } from "zod";
 
 import { getPlatformBaseUrl } from "../../config/env.js";
+import { getLogger } from "../../util/logger.js";
 import {
   type MarketplaceEntry,
   mcpIntegrationSchema,
@@ -27,9 +29,12 @@ import {
   type SearchPluginsDeps,
 } from "./search-plugins.js";
 
+const log = getLogger("plugin-catalog");
+
 /**
  * One flattened row from the platform catalog. Unknown keys (`id`,
- * `display_name`) are accepted and dropped — zod strips them by default.
+ * `display_name`) are accepted and dropped (zod strips them by default).
+ * `integration` is validated separately by {@link integrationSchema}.
  */
 const platformPluginRowSchema = z.object({
   name: z.string(),
@@ -41,11 +46,13 @@ const platformPluginRowSchema = z.object({
   category: z.string().nullable().optional(),
   homepage: z.string().nullable().optional(),
   license: z.string().nullable().optional(),
-  integration: mcpIntegrationSchema.nullable().optional(),
+  integration: z.unknown(),
 });
 
+const integrationSchema = mcpIntegrationSchema.nullable().optional();
+
 const platformCatalogSchema = z.object({
-  plugins: z.array(platformPluginRowSchema),
+  plugins: z.array(z.unknown()),
 });
 
 /**
@@ -99,10 +106,22 @@ export async function fetchPluginCatalogFromPlatform(
   }
 
   const entries: MarketplaceEntry[] = [];
-  for (const row of parsed.data.plugins) {
+  const skippedRows: string[] = [];
+  const droppedIntegrations: string[] = [];
+  for (const [index, rawRow] of parsed.data.plugins.entries()) {
+    const rowResult = platformPluginRowSchema.safeParse(rawRow);
+    if (!rowResult.success) {
+      skippedRows.push(describeInvalidRow(rawRow, index));
+      continue;
+    }
+    const row = rowResult.data;
     if (!row.repo || !row.ref) {
       continue;
     }
+    const integrationResult = integrationSchema.safeParse(row.integration);
+    if (!integrationResult.success) {
+      droppedIntegrations.push(row.name);
+    }
     entries.push({
       name: row.name,
       source: {
@@ -116,12 +135,32 @@ export async function fetchPluginCatalogFromPlatform(
       category: row.category ?? undefined,
       homepage: row.homepage ?? undefined,
       license: row.license ?? undefined,
-      integration: row.integration ?? undefined,
+      integration: integrationResult.success
+        ? (integrationResult.data ?? undefined)
+        : undefined,
     });
   }
 
+  if (skippedRows.length > 0 || droppedIntegrations.length > 0) {
+    log.warn(
+      { skippedRows, droppedIntegrations },
+      "platform plugin catalog contained invalid rows; skipped rows and dropped integrations",
+    );
+  }
+
   return {
     ref: opts?.ref ?? "platform",
     matches: projectMarketplaceEntries(entries),
   };
 }
+
+/** Name of an invalid row for logging, or its position when it has none. */
+function describeInvalidRow(row: unknown, index: number): string {
+  if (row && typeof row === "object" && "name" in row) {
+    const name = (row as { name: unknown }).name;
+    if (typeof name === "string" && name.length > 0) {
+      return name;
+    }
+  }
+  return `#${index}`;
+}

package/src/cli/lib/plugin-catalog-visibility.ts

@@ -0,0 +1,41 @@
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
+import type { PluginCatalog } from "./search-plugins.js";
+
+export const MCP_CATALOG_QA_INTEGRATIONS_FLAG = "mcp-catalog-qa-integrations";
+
+const MCP_CATALOG_QA_INTEGRATION_NAMES = new Set([
+  "gamma",
+  "guru",
+  "intercom",
+  "ramp",
+  "semrush",
+  "typeform",
+]);
+
+export type PluginCatalogFeatureFlagResolver = (key: string) => boolean;
+
+export function isPluginCatalogEntryVisible(
+  name: string,
+  isFeatureFlagEnabled: PluginCatalogFeatureFlagResolver = isAssistantFeatureFlagEnabled,
+): boolean {
+  return (
+    !MCP_CATALOG_QA_INTEGRATION_NAMES.has(name) ||
+    isFeatureFlagEnabled(MCP_CATALOG_QA_INTEGRATIONS_FLAG)
+  );
+}
+
+/**
+ * Hide catalog entries whose OAuth flows are still being validated. Installed
+ * plugins are unaffected because this filter only applies to catalog reads.
+ */
+export function filterPluginCatalogByFeatureFlags(
+  catalog: PluginCatalog,
+  isFeatureFlagEnabled: PluginCatalogFeatureFlagResolver = isAssistantFeatureFlagEnabled,
+): PluginCatalog {
+  const matches = catalog.matches.filter((match) =>
+    isPluginCatalogEntryVisible(match.name, isFeatureFlagEnabled),
+  );
+  return matches.length === catalog.matches.length
+    ? catalog
+    : { ...catalog, matches };
+}

package/src/cli/lib/plugin-details.ts

@@ -46,6 +46,7 @@ import {
   findCatalogEntry,
   resolveSourceFromMatch,
 } from "./plugin-catalog-resolve.js";
+import { isPluginCatalogEntryVisible } from "./plugin-catalog-visibility.js";
 import { DEFAULT_PLUGIN_REF } from "./plugin-constants.js";
 import { readValidatedPluginIcon } from "./plugin-icon-file.js";
 import { fetchMarketplaceEntries } from "./plugin-marketplace.js";
@@ -156,8 +157,8 @@ export class PluginDetailsNotFoundError extends Error {
  * Resolve the detail view for {@link opts.name}.
  *
  * Throws {@link PluginDetailsNotFoundError} when the name is neither installed
- * locally nor present in the catalog (gated at the default ref, the GitHub
- * marketplace at an explicit historical ref). A gated-catalog outage
+ * locally nor present in the visibility-gated catalog at either the default
+ * or an explicit historical ref. A gated-catalog outage
  * ({@link PluginCatalogUnavailableError}) degrades to the on-disk fields only
  * when a local copy exists; with nothing installed to render it propagates so
  * the caller can map the transient failure to a retryable 503 rather than a
@@ -400,11 +401,10 @@ async function fetchRawFile(
 /**
  * Resolve the external catalog entry claiming {@link name}.
  *
- * The default ref reads the gated catalog (the same source search / install
- * use). An explicit historical {@link ref} reads the GitHub marketplace
- * manifest at that revision — the gated catalog is ref-agnostic, so honoring a
- * reviewed/rolled-back revision is inherently a git lookup, matching the pin
- * history / inspect carve-out.
+ * Both default and historical-ref lookups apply catalog visibility first. The
+ * default ref then reads the gated catalog used by search and install, while an
+ * explicit historical {@link ref} reads the GitHub marketplace manifest at
+ * that revision.
  *
  * A gated-catalog outage (fail-hard {@link PluginCatalogUnavailableError})
  * propagates when nothing is installed — there is nothing to render and the
@@ -420,6 +420,9 @@ async function resolveCatalogEntry(
   fetchFn: FetchLike,
   installed: boolean,
 ): Promise<PluginSearchMatch | null> {
+  if (!isPluginCatalogEntryVisible(name)) {
+    return null;
+  }
   try {
     const match =
       ref === DEFAULT_PLUGIN_REF

package/src/cli/lib/search-plugins.ts

@@ -19,6 +19,8 @@ import type { MarketplaceEntry } from "./plugin-marketplace.js";
 export interface SearchPluginsDeps {
   /** HTTP client. Production callers pass `globalThis.fetch.bind(globalThis)`. */
   readonly fetch: FetchLike;
+  /** Optional feature-flag resolver for deterministic tests. */
+  readonly featureFlagEnabled?: (key: string) => boolean;
 }
 
 /** Where a catalog match comes from. */

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

@@ -5,10 +5,12 @@ import { resolveModelIntent } from "../../providers/model-intents.js";
 import { CALL_SITE_DEFAULTS } from "../call-site-defaults.js";
 import {
   CODE_DEFAULT_PROFILE_ENTRIES,
+  getConversationProfilesForProvider,
   getEffectiveProfile,
   getEffectiveProfiles,
   getEffectiveProfilesForProvider,
   getUserSelectableProfilesForProvider,
+  MANAGED_PROFILE_TEMPLATES,
   PROFILE_IMPLS,
   resolveDefaultProfileForProvider,
 } from "../default-profile-catalog.js";
@@ -59,6 +61,64 @@ describe("getEffectiveProfiles", () => {
     }
   });
 
+  test("the managed Jev profile routes jev-latest through TypeSafe and is managed-only", () => {
+    const jev = CODE_DEFAULT_PROFILE_ENTRIES["jev-managed"];
+    expect(jev.model).toBe("jev-latest");
+    expect(jev.provider_connection).toBeUndefined();
+    expect(resolveRoutingIdentity(jev.provider, jev.model)).toEqual({
+      connectionName: "vellum",
+      expectedProvider: "typesafe",
+    });
+    expect(
+      resolveDefaultProfileForProvider(undefined, "jev-managed", null),
+    ).toBeDefined();
+    expect(
+      resolveDefaultProfileForProvider(undefined, "jev-managed", {
+        provider: "anthropic",
+        connectionName: "anthropic-personal",
+      }),
+    ).toBeUndefined();
+  });
+
+  test("the Auto profile is the managed Balanced body relabeled, managed-only, and flag-gated", () => {
+    const auto = CODE_DEFAULT_PROFILE_ENTRIES.auto;
+    const balanced = CODE_DEFAULT_PROFILE_ENTRIES.balanced;
+    expect(auto.label).toBe("Auto");
+    expect(auto.model).toBe(balanced.model);
+    expect(auto.provider).toBe(balanced.provider);
+    expect(auto.fallbackProfile).toBeUndefined();
+    // Not seeded unconditionally: the flag reconcile writes the stub.
+    expect(Object.keys(MANAGED_PROFILE_TEMPLATES)).not.toContain("auto");
+    expect(
+      resolveDefaultProfileForProvider(undefined, "auto", null),
+    ).toBeUndefined();
+    const stub: Record<string, ProfileEntry> = { auto: { source: "managed" } };
+    expect(resolveDefaultProfileForProvider(stub, "auto", null)?.model).toBe(
+      balanced.model,
+    );
+    expect(
+      resolveDefaultProfileForProvider(stub, "auto", {
+        provider: "anthropic",
+        connectionName: "anthropic-personal",
+      }),
+    ).toBeUndefined();
+    expect(
+      Object.keys(getConversationProfilesForProvider(stub, null)),
+    ).toContain("auto");
+  });
+
+  test("the conversation view drops the managed Jev profile but keeps it selectable for call sites", () => {
+    expect(
+      Object.keys(getConversationProfilesForProvider(undefined, null)),
+    ).not.toContain("jev-managed");
+    expect(
+      Object.keys(getUserSelectableProfilesForProvider(undefined, null)),
+    ).toContain("jev-managed");
+    expect(
+      Object.keys(getConversationProfilesForProvider(undefined, null)),
+    ).toContain("balanced");
+  });
+
   test("the managed Balanced profile routes GLM 5.3 Flash through Fireworks", () => {
     const balanced = CODE_DEFAULT_PROFILE_ENTRIES.balanced;
     expect(balanced.model).toBe("accounts/fireworks/models/glm-5p3-flash");
@@ -80,7 +140,7 @@ describe("getEffectiveProfiles", () => {
   test("defaults absent from the workspace resolve from the catalog; os-beta stays flag-gated", () => {
     const effective = getEffectiveProfiles(undefined);
     expect(Object.keys(effective).sort()).toEqual(
-      [...DEFAULT_PROFILE_KEYS, ...BACKUP_PROFILE_KEYS].sort(),
+      [...DEFAULT_PROFILE_KEYS, ...BACKUP_PROFILE_KEYS, "jev-managed"].sort(),
     );
     expect(getEffectiveProfile({}, "balanced")?.model).toBe(
       CODE_DEFAULT_PROFILE_ENTRIES.balanced.model as string,

package/src/config/__tests__/jev-managed-profile.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+
+import { LLMSchema } from "../schemas/llm.js";
+
+const PIN = { callSites: { voiceEscalationJudge: { profile: "jev-managed" } } };
+
+describe("jev-managed as a call-site pin target", () => {
+  test("resolves under the managed default provider", () => {
+    expect(LLMSchema.safeParse(PIN).success).toBe(true);
+    expect(
+      LLMSchema.safeParse({
+        ...PIN,
+        defaultProvider: { provider: "vellum" },
+      }).success,
+    ).toBe(true);
+  });
+
+  test("can be pinned only to the verdict-consuming call sites", () => {
+    for (const site of [
+      "voiceEscalationJudge",
+      "voiceContinuationJudge",
+      "memoryV3SelectL2",
+    ]) {
+      expect(
+        LLMSchema.safeParse({
+          callSites: { [site]: { profile: "jev-managed" } },
+        }).success,
+      ).toBe(true);
+    }
+    const result = LLMSchema.safeParse({
+      callSites: { conversationTitle: { profile: "jev-managed" } },
+    });
+    expect(result.success).toBe(false);
+    expect(JSON.stringify(result.error?.issues)).toContain(
+      "can only be pinned to",
+    );
+  });
+
+  test("cannot be a mix constituent", () => {
+    const result = LLMSchema.safeParse({
+      profiles: {
+        blend: {
+          mix: [
+            { profile: "jev-managed", weight: 1 },
+            { profile: "balanced", weight: 1 },
+          ],
+        },
+      },
+    });
+    expect(result.success).toBe(false);
+    expect(JSON.stringify(result.error?.issues)).toContain(
+      "cannot be a mix constituent",
+    );
+  });
+
+  test("is rejected as the active or advisor profile even on the managed column", () => {
+    for (const field of ["activeProfile", "advisorProfile"] as const) {
+      const result = LLMSchema.safeParse({ [field]: "jev-managed" });
+      expect(result.success).toBe(false);
+      expect(JSON.stringify(result.error?.issues)).toContain(
+        "structured answers rather than chat text",
+      );
+    }
+    expect(LLMSchema.safeParse({ activeProfile: "balanced" }).success).toBe(
+      true,
+    );
+  });
+
+  test("is rejected under a BYOK default provider, where it has no body", () => {
+    const result = LLMSchema.safeParse({
+      ...PIN,
+      defaultProvider: {
+        provider: "anthropic",
+        connectionName: "anthropic-personal",
+      },
+    });
+    expect(result.success).toBe(false);
+    expect(JSON.stringify(result.error?.issues)).toContain(
+      "managed Jev profile",
+    );
+  });
+});

package/src/config/__tests__/platform-identity.test.ts

@@ -116,6 +116,7 @@ describe("fetchPlatformIdentityIds", () => {
 describe("resolvePlatformAssistantId", () => {
   const originalFetch = globalThis.fetch;
   const originalAssistantApiKeyEnv = process.env.ASSISTANT_API_KEY;
+  const originalPlatformUrlEnv = process.env.VELLUM_PLATFORM_URL;
   const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
   let fetchImpl: (
     input: RequestInfo | URL,
@@ -149,6 +150,11 @@ describe("resolvePlatformAssistantId", () => {
     } else {
       process.env.ASSISTANT_API_KEY = originalAssistantApiKeyEnv;
     }
+    if (originalPlatformUrlEnv === undefined) {
+      delete process.env.VELLUM_PLATFORM_URL;
+    } else {
+      process.env.VELLUM_PLATFORM_URL = originalPlatformUrlEnv;
+    }
     setPlatformBaseUrl(undefined);
     setPlatformAssistantId(undefined);
     setPlatformOrganizationId(undefined);
@@ -198,6 +204,59 @@ describe("resolvePlatformAssistantId", () => {
     expect(fetchCalls).toHaveLength(1);
   });
 
+  test("retries validate inside the cooldown once a different API key is stored", async () => {
+    process.env.ASSISTANT_API_KEY = "rejected-key";
+    setPlatformBaseUrl(BASE_URL);
+    fetchImpl = async () => new Response("no", { status: 401 });
+
+    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    expect(fetchCalls).toHaveLength(1);
+
+    process.env.ASSISTANT_API_KEY = "replacement-key";
+    fetchImpl = async () =>
+      new Response(
+        JSON.stringify({
+          assistant_id: ASSISTANT_ID,
+          organization_id: ORG_ID,
+          user_id: USER_ID,
+        }),
+        { status: 200 },
+      );
+
+    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    expect(fetchCalls).toHaveLength(2);
+    const headers = new Headers(fetchCalls[1]?.init?.headers);
+    expect(headers.get("Authorization")).toBe("Api-Key replacement-key");
+  });
+
+  test("retries validate inside the cooldown once a different base URL is stored", async () => {
+    process.env.ASSISTANT_API_KEY = "assistant-key";
+    // The environment URL outranks the in-memory override (and the test
+    // preload sets one), so the base URL is changed through the environment.
+    process.env.VELLUM_PLATFORM_URL = "https://old.example.com";
+    fetchImpl = async () => new Response("no", { status: 401 });
+
+    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    expect(fetchCalls).toHaveLength(1);
+
+    process.env.VELLUM_PLATFORM_URL = BASE_URL;
+    fetchImpl = async () =>
+      new Response(
+        JSON.stringify({
+          assistant_id: ASSISTANT_ID,
+          organization_id: ORG_ID,
+          user_id: USER_ID,
+        }),
+        { status: 200 },
+      );
+
+    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    expect(fetchCalls).toHaveLength(2);
+    expect(fetchCalls[1]?.url).toBe(
+      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
+    );
+  });
+
   test("retries validate after a failed attempt once the cooldown is cleared", async () => {
     process.env.ASSISTANT_API_KEY = "assistant-key";
     setPlatformBaseUrl(BASE_URL);

package/src/config/__tests__/sync-gated-profiles.test.ts

@@ -368,4 +368,75 @@ describe("reconcileFlagGatedProfiles", () => {
     expect(reconcileFlagGatedProfiles()).toBe(false);
     expect(readFileSync(CONFIG_PATH, "utf-8")).toBe(before);
   });
+
+  test("auto-profile flag on materializes the managed auto profile at the head of the order", () => {
+    process.env.IS_PLATFORM = "true";
+    seedBalancedConfig();
+    setOverridesForTesting({ "auto-profile": true });
+
+    expect(reconcileFlagGatedProfiles()).toBe(true);
+
+    const raw = readConfig();
+    expect(raw.llm.profiles.auto).toEqual({ source: "managed" });
+    expect(raw.llm.profileOrder[0]).toBe("auto");
+    const effective = getEffectiveProfile(raw.llm.profiles, "auto")!;
+    expect(effective.label).toBe("Auto");
+    expect(effective.model).toBe(
+      getEffectiveProfile(raw.llm.profiles, "balanced")!.model,
+    );
+    expect(LLMSchema.safeParse(raw.llm).success).toBe(true);
+  });
+
+  test("auto-profile flag on in BYOK mode writes a plain stub that the effective view hides", () => {
+    seedBalancedConfig();
+    setOverridesForTesting({ "auto-profile": true });
+
+    expect(reconcileFlagGatedProfiles()).toBe(true);
+
+    const raw = readConfig();
+    expect(raw.llm.profiles.auto).toEqual({ source: "managed" });
+    expect(getEffectiveProfile(raw.llm.profiles, "auto")).toBeDefined();
+  });
+
+  test("auto-profile flag off removes the managed auto profile and repoints its references", () => {
+    process.env.IS_PLATFORM = "true";
+    seedBalancedConfig();
+    setOverridesForTesting({ "auto-profile": true });
+    reconcileFlagGatedProfiles();
+
+    const raw = readConfig();
+    raw.llm.activeProfile = "auto";
+    (raw.llm as Record<string, unknown>).callSites = {
+      subagentSpawn: { profile: "auto" },
+    };
+    writeConfig(raw);
+    invalidateConfigCache();
+
+    setOverridesForTesting({ "auto-profile": false });
+    expect(reconcileFlagGatedProfiles()).toBe(true);
+
+    const after = readConfig();
+    expect(after.llm.profiles.auto).toBeUndefined();
+    expect(after.llm.profileOrder.includes("auto")).toBe(false);
+    expect(after.llm.activeProfile).toBe("balanced");
+    expect((after.llm as Record<string, unknown>).callSites).toEqual({
+      subagentSpawn: {},
+    });
+  });
+
+  test("os-beta and auto-profile reconcile independently in one pass", () => {
+    process.env.IS_PLATFORM = "true";
+    seedBalancedConfig();
+    setOverridesForTesting({ "os-beta": true, "auto-profile": true });
+    expect(reconcileFlagGatedProfiles()).toBe(true);
+    let order = readConfig().llm.profileOrder;
+    expect(order[0]).toBe("auto");
+    expect(order.indexOf("os-beta")).toBe(order.indexOf("balanced") + 1);
+
+    setOverridesForTesting({ "os-beta": false, "auto-profile": true });
+    expect(reconcileFlagGatedProfiles()).toBe(true);
+    order = readConfig().llm.profileOrder;
+    expect(order[0]).toBe("auto");
+    expect(order.includes("os-beta")).toBe(false);
+  });
 });

package/src/config/bundled-skills/screen-annotation/SKILL.md

@@ -46,9 +46,12 @@ nothing, because no control is called that. Give the label on its own:
 The arrow points at the middle of the control and stops just short, so what
 you are sending someone to stays visible the whole time.
 
-You are answered with what was drawn and the name it resolved to, which is not
-always the name you asked for. Say the resolved one out loud: it is the word
-the user can see.
+You are answered with what was drawn and the accessibility name it resolved
+to. Some apps expose internal names such as `ToolbarExportControl` instead of
+the visible label. When a returned name identifies the intended control in
+the shared image, use that exact name as `target`; use the visible label in
+the caption and speech. Do not invent an internal name or choose an unclear
+candidate.
 
 A name the surface does not carry draws nothing and comes back with the names
 it does carry. That is the answer, not a setback: the thing is nearly always

package/src/config/call-site-defaults.ts

@@ -1,3 +1,4 @@
+import { JEV_MANAGED_PROFILE_KEY } from "./default-profile-names.js";
 import { type LLMCallSite } from "./schemas/llm.js";
 
 type CallSiteDefaultConfig = {
@@ -123,9 +124,8 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     effort: "low",
     thinking: { enabled: false },
   },
-  // The dictation cleanup pass, and nothing else runs on this site. The
-  // caller has already stopped speaking and has nothing on screen until this
-  // answers, so it is priced as a latency call.
+  // Voice intent classification and explicit selected-text edits are
+  // latency-sensitive: the caller is waiting for insertion or dispatch.
   interactionClassifier: {
     profile: "latency-optimized",
     effort: "low",
@@ -153,14 +153,20 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     effort: "low",
     thinking: { enabled: false },
   },
-  // The escalation judge only runs when this site resolves to the TypeSafe
-  // provider (see calls/voice-escalation-judge.ts), so the shipped default is
-  // any ordinary profile: the judge stays off until a user pins a TypeSafe
-  // profile here.
-  voiceEscalationJudge: { profile: "cost-optimized" },
-  // Same arrangement for the barge-in continuation judge
-  // (live-voice/continuation-judge.ts): off until a TypeSafe profile is
-  // pinned here.
+  // The managed-only profile resolves through the Vellum connection. On a
+  // BYOK install it has no body, so the judge is unavailable and the front
+  // door's own decision stands.
+  voiceEscalationJudge: {
+    profile: JEV_MANAGED_PROFILE_KEY,
+  },
+  // Picks the default profile for a turn pinned to the Auto profile. On a
+  // BYOK install the managed-only Jev profile has no body, so the router is
+  // unavailable and the turn runs on Balanced.
+  autoProfileRouter: {
+    profile: JEV_MANAGED_PROFILE_KEY,
+  },
+  // The barge-in continuation judge remains off until a TypeSafe profile is
+  // pinned here (see live-voice/continuation-judge.ts).
   voiceContinuationJudge: { profile: "cost-optimized" },
   // Names the background continuation a barge-in spawns, from the interrupted
   // transcript. The label is fixed at spawn, so the call runs under a short