@vellumai/assistant 0.12.4-staging.1 → 0.12.4-staging.3

package/src/calls/__tests__/typesafe-noul.test.ts

@@ -0,0 +1,66 @@
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+import type { Provider } from "../../providers/types.js";
+
+let configured: {
+  provider: Provider;
+  configuredProviderName: string;
+  entryRouted: boolean;
+} | null = null;
+
+const actual = await import("../../providers/provider-send-message.js");
+mock.module("../../providers/provider-send-message.js", () => ({
+  ...actual,
+  resolveConfiguredProvider: async () => configured,
+}));
+
+const { resolveTypesafeProvider } = await import("../typesafe-noul.js");
+
+afterAll(() => {
+  mock.restore();
+});
+
+function stub(name: string): Provider {
+  return {
+    name,
+    defaultModel: "jev-latest",
+    sendMessage: async () => {
+      throw new Error("not dispatched in this test");
+    },
+  } as unknown as Provider;
+}
+
+describe("resolveTypesafeProvider", () => {
+  test("a BYOK TypeSafe profile resolves", async () => {
+    configured = {
+      provider: stub("typesafe"),
+      configuredProviderName: "typesafe",
+      entryRouted: false,
+    };
+    expect((await resolveTypesafeProvider("voiceEscalationJudge"))?.name).toBe(
+      "typesafe",
+    );
+  });
+
+  test("a managed Jev profile resolves although it is configured as vellum", async () => {
+    configured = {
+      provider: stub("typesafe"),
+      configuredProviderName: "vellum",
+      entryRouted: false,
+    };
+    expect((await resolveTypesafeProvider("voiceEscalationJudge"))?.name).toBe(
+      "typesafe",
+    );
+  });
+
+  test("any other dispatched provider is unavailable", async () => {
+    configured = {
+      provider: stub("anthropic"),
+      configuredProviderName: "vellum",
+      entryRouted: false,
+    };
+    expect(await resolveTypesafeProvider("voiceEscalationJudge")).toBeNull();
+    configured = null;
+    expect(await resolveTypesafeProvider("voiceEscalationJudge")).toBeNull();
+  });
+});

package/src/calls/typesafe-noul.ts

@@ -28,12 +28,18 @@ export interface TypesafeNoulResult {
   latencyMs: number;
 }
 
-/** The call site's provider when it resolves to TypeSafe, else null. */
+/**
+ * The call site's provider when it resolves to TypeSafe, else null. Judged
+ * on the dispatched adapter's name rather than the configured provider: a
+ * managed profile is configured as `vellum` and only substitutes the
+ * TypeSafe upstream at dispatch, so the configured name alone would report
+ * the managed Jev profile as unavailable.
+ */
 export async function resolveTypesafeProvider(
   callSite: LLMCallSite,
 ): Promise<Provider | null> {
   const resolved = await resolveConfiguredProvider(callSite);
-  return resolved?.configuredProviderName === TYPESAFE_PROVIDER_NAME
+  return resolved?.provider.name === TYPESAFE_PROVIDER_NAME
     ? resolved.provider
     : null;
 }

package/src/calls/voice-escalation-judge.ts

@@ -9,10 +9,11 @@
  * correct reply need something the front door cannot do from here? A
  * confident yes overrules a front-door answer and hands the turn off.
  *
- * The judge runs only when the `voiceEscalationJudge` call site resolves to
- * the TypeSafe provider. Every other outcome (no such profile, provider
- * error, timeout, unparseable answer) is a "clear" verdict, so the front
- * door's own decision stands exactly as it would without the judge.
+ * The judge uses managed Jev by default when Vellum-managed inference is
+ * available. An explicit TypeSafe call-site override can use a user-owned
+ * connection. Every other outcome (unavailable route, provider error,
+ * timeout, unparseable answer) is a "clear" verdict, so the front door's own
+ * decision stands exactly as it would without the judge.
  */
 
 import type { Message, Provider } from "../providers/types.js";

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

@@ -5,6 +5,7 @@ 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,
@@ -59,6 +60,37 @@ 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 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 +112,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/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,14 @@ 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,
+  },
+  // 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

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

@@ -15,12 +15,14 @@ import {
   type DefaultProfileKey,
   type DefaultProfileProvider,
   FALLBACK_PROFILE_BY_KEY,
-  isBackupProfileKey,
   isDefaultProfileKey,
   isDefaultProfileProvider,
+  isManagedOnlyProfileKey,
+  JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 } from "./default-profile-names.js";
 import { resolveDefaultConnectionName } from "./default-provider-resolution.js";
+import { profileSupportsTextGeneration } from "./profile-text-generation.js";
 import {
   backupProfilesResolveUnderDefaultProvider,
   DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS,
@@ -385,18 +387,39 @@ export const PROFILE_IMPLS: Record<
   Record<DefaultProfileProvider, DefaultProfileTemplate>
 >;
 
+/**
+ * The managed Jev profile: TypeSafe's System One decision model through the
+ * platform proxy. Managed column only, because the platform is the only
+ * route the catalog offers for it here, and never a conversation profile,
+ * because `jev-latest` returns structured answers rather than chat text
+ * (`supportsText: false` on the `typesafe` catalog entry). Its budget is
+ * TypeSafe's published request limit rather than the default context window.
+ */
+export const JEV_MANAGED_PROFILE_TEMPLATE: DefaultProfileTemplate = {
+  model: "jev-latest",
+  provider: "vellum",
+  source: "managed",
+  label: "Jev",
+  description:
+    "TypeSafe decision model for yes/no verdicts, for the voice judges and memory selection",
+  maxTokens: 4096,
+  thinking: { enabled: false, streamThinking: false },
+  contextWindow: { maxInputTokens: 32_000 },
+};
+
 /**
  * Managed profiles, i.e. the `vellum` column keyed by profile name, plus the
- * managed backup profiles. Backups come after the primaries, which is what
- * places them after the primaries in the seeded `profileOrder`: the seeder
- * inserts missing managed keys in this record's order. Keyed by the
- * user-facing defaults only: an internal profile is code-resolved and never
- * listed or ordered.
+ * managed backup profiles and the managed Jev profile. Backups come after the
+ * primaries, which is what places them after the primaries in the seeded
+ * `profileOrder`: the seeder inserts missing managed keys in this record's
+ * order. Keyed by the user-facing defaults only: an internal profile is
+ * code-resolved and never listed or ordered.
  */
 export const MANAGED_PROFILE_TEMPLATES: Record<string, DefaultProfileTemplate> =
   Object.fromEntries([
     ...DEFAULT_PROFILE_KEYS.map((key) => [key, PROFILE_IMPLS[key].vellum]),
     ...BACKUP_PROFILE_KEYS.map((key) => [key, BACKUP_PROFILE_IMPLS[key]]),
+    [JEV_MANAGED_PROFILE_KEY, JEV_MANAGED_PROFILE_TEMPLATE],
   ]);
 
 /**
@@ -484,6 +507,9 @@ export const OS_BETA_PROFILE_TEMPLATE: DefaultProfileTemplate = {
 export const CODE_OWNED_PROFILE_NAMES = new Set<string>([
   "latency-optimized",
   ...BACKUP_PROFILE_KEYS,
+  // A shadow could repoint the judges at a chat model, which answers a
+  // yes/no question with prose the verdict parser cannot read.
+  JEV_MANAGED_PROFILE_KEY,
 ]);
 
 // All managed profiles, including the flag-gated os-beta, are invariant:
@@ -494,6 +520,7 @@ export const CODE_OWNED_PROFILE_NAMES = new Set<string>([
 export const INVARIANT_PROFILE_NAMES = new Set<string>([
   ...DEFAULT_PROFILE_KEYS,
   ...BACKUP_PROFILE_KEYS,
+  JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 ]);
 
@@ -507,6 +534,7 @@ export const INVARIANT_PROFILE_NAMES = new Set<string>([
 export const MANAGED_PROFILE_NAMES = new Set<string>([
   ...DEFAULT_PROFILE_KEYS,
   ...BACKUP_PROFILE_KEYS,
+  JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 ]);
 
@@ -590,6 +618,19 @@ for (const key of BACKUP_PROFILE_KEYS) {
   }
 }
 
+// The managed Jev profile pins a model the platform proxy must front, and the
+// judges depend on it being the non-text TypeSafe model rather than a chat
+// model that happens to share the id.
+if (
+  getManagedUpstream(JEV_MANAGED_PROFILE_TEMPLATE.model ?? "") !== "typesafe"
+) {
+  throw new Error(
+    `JEV_MANAGED_PROFILE_TEMPLATE references model "${JEV_MANAGED_PROFILE_TEMPLATE.model ?? ""}" ` +
+      `which the managed route does not serve through typesafe. ` +
+      `Update model-catalog.ts, platform-proxy/constants.ts, or default-profile-catalog.ts.`,
+  );
+}
+
 // Provider choices without a named column materialize from the shared BYOK
 // templates; verify each one's resolved model lands in the catalog.
 for (const provider of DEFAULT_PROVIDER_CHOICES) {
@@ -621,6 +662,10 @@ function buildDefaultProfileEntries(): Record<string, ProfileEntry> {
     const impl = BACKUP_PROFILE_IMPLS[key];
     entries[key] = materializeProfile(impl, impl.provider);
   }
+  entries[JEV_MANAGED_PROFILE_KEY] = materializeProfile(
+    JEV_MANAGED_PROFILE_TEMPLATE,
+    JEV_MANAGED_PROFILE_TEMPLATE.provider,
+  );
   entries[OS_BETA_PROFILE_KEY] = materializeProfile(
     OS_BETA_PROFILE_TEMPLATE,
     OS_BETA_PROFILE_TEMPLATE.provider,
@@ -697,12 +742,13 @@ function resolveAgainstBody(
   if (body == null) {
     // A managed stub is the workspace's slot for a code-owned profile, never
     // a profile of its own, so with no body behind it there is nothing to
-    // resolve. Only a backup name reaches this branch with a stub (the
-    // default keys always have a body), and it reaches it on the columns
-    // where the backups do not exist. Resolving to the stub would list a
-    // profile with no provider or model and let a reference to it look
-    // valid, which is precisely what `LLMSchema` rejects on those columns.
-    if (isBackupProfileKey(name) && workspace?.source === "managed") {
+    // resolve. Only a managed-only name (a backup, the Jev profile) reaches
+    // this branch with a stub (the default keys always have a body), and it
+    // reaches it on the columns where those profiles do not exist. Resolving
+    // to the stub would list a profile with no provider or model and let a
+    // reference to it look valid, which is precisely what `LLMSchema` rejects
+    // on those columns.
+    if (isManagedOnlyProfileKey(name) && workspace?.source === "managed") {
       return undefined;
     }
     return workspace;
@@ -787,14 +833,14 @@ function defaultProfileBodyForProvider(
   defaultProvider: DefaultProviderConfig | null,
 ): ProfileEntry | undefined {
   if (!isDefaultProfileKey(name)) {
-    // Backup profiles are companions of the managed (`vellum`) column only:
-    // under a BYOK or chatgpt default provider the primaries carry no
-    // `fallbackProfile` pointers, and the backups must not materialize
-    // either, since the install may hold no credential for the backup's
+    // Backup profiles and the managed Jev profile exist on the managed
+    // (`vellum`) column only: under a BYOK or chatgpt default provider the
+    // primaries carry no `fallbackProfile` pointers, and neither may
+    // materialize, since the install may hold no credential for their
     // provider. A null defaultProvider predates `llm.defaultProvider` and
-    // resolves to the managed column, so it keeps its backups.
+    // resolves to the managed column, so it keeps them.
     if (
-      isBackupProfileKey(name) &&
+      isManagedOnlyProfileKey(name) &&
       !backupProfilesResolveUnderDefaultProvider(defaultProvider)
     ) {
       return undefined;
@@ -923,3 +969,27 @@ export function getUserSelectableProfilesForProvider(
   }
   return selectable;
 }
+
+/**
+ * The profiles a conversation can run on: the user-selectable view minus any
+ * profile whose model returns structured answers rather than chat text (the
+ * managed Jev profile). Every surface that picks or validates a conversation
+ * profile (the `/model` command, a per-conversation pin, the plugin and
+ * workflow listings) reads this view; the call-site override pickers keep
+ * the wider selectable view, since the verdict sites are what Jev is for.
+ */
+export function getConversationProfilesForProvider(
+  workspaceProfiles: Record<string, ProfileEntry> | undefined,
+  defaultProvider: DefaultProviderConfig | null,
+): Record<string, ProfileEntry> {
+  const selectable = getUserSelectableProfilesForProvider(
+    workspaceProfiles,
+    defaultProvider,
+  );
+  for (const [name, entry] of Object.entries(selectable)) {
+    if (!profileSupportsTextGeneration(entry, selectable)) {
+      delete selectable[name];
+    }
+  }
+  return selectable;
+}

package/src/config/default-profile-names.ts

@@ -67,6 +67,41 @@ export function isBackupProfileKey(value: string): value is BackupProfileKey {
   return (BACKUP_PROFILE_KEYS as readonly string[]).includes(value);
 }
 
+/**
+ * Managed profile for the TypeSafe decision model (Jev). Deliberately NOT
+ * part of `DEFAULT_PROFILE_KEYS`: it has no BYOK column, because the
+ * platform serves Jev only through the managed route, and its model returns
+ * structured answers rather than chat text, so it can never be the active
+ * or conversation profile. It exists as a pin target for the call sites
+ * that consume a yes/no verdict (the voice judges, the memory selector).
+ */
+export const JEV_MANAGED_PROFILE_KEY = "jev-managed";
+
+/**
+ * The call sites that consume a structured verdict and so may be pinned to
+ * the Jev profile. Every other site expects chat text or a tool call, which
+ * the decision model never produces.
+ */
+export const JEV_MANAGED_PROFILE_CALL_SITES = [
+  "voiceEscalationJudge",
+  "voiceContinuationJudge",
+  "memoryV3SelectL2",
+] as const;
+
+/**
+ * Keys whose profile exists on the managed (`vellum`) column only: the
+ * backups and the Jev profile. Under a BYOK or ChatGPT default provider
+ * these names have no body to resolve to.
+ */
+export const MANAGED_ONLY_PROFILE_KEYS = [
+  ...BACKUP_PROFILE_KEYS,
+  JEV_MANAGED_PROFILE_KEY,
+] as const;
+
+export function isManagedOnlyProfileKey(value: string): boolean {
+  return (MANAGED_ONLY_PROFILE_KEYS as readonly string[]).includes(value);
+}
+
 /**
  * Flag-gated default profile: only available while the `os-beta` feature
  * flag has reconciled it into the workspace (see `sync-gated-profiles.ts`).

package/src/config/inference-profile-validation.ts

@@ -1,4 +1,4 @@
-import { getUserSelectableProfilesForProvider } from "./default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "./default-profile-catalog.js";
 import { getConfigReadOnly } from "./loader.js";
 
 /**
@@ -6,17 +6,18 @@ import { getConfigReadOnly } from "./loader.js";
  * (code-defined defaults + workspace `llm.profiles`). Returns a user-facing
  * error message when the key is empty or unknown, or `null` when valid.
  *
- * Resolved through the `llm.defaultProvider`-aware user-selectable view so
- * availability matches what a direct profile pin can choose. Managed backup
- * routes remain available to automatic fallback resolution but are not
- * reported as selectable profiles.
+ * Resolved through the `llm.defaultProvider`-aware conversation view, since
+ * every caller (schedules, subagent spawns, per-conversation pins) runs chat
+ * turns on the result. Managed backup routes remain available to automatic
+ * fallback resolution, and the managed Jev profile to the verdict call
+ * sites, but neither is reported as a selectable profile here.
  */
 export function validateInferenceProfileKey(profile: string): string | null {
   if (!profile.trim()) {
     return "inferenceProfile must be a non-empty string";
   }
   const llm = getConfigReadOnly().llm;
-  const profiles = getUserSelectableProfilesForProvider(
+  const profiles = getConversationProfilesForProvider(
     llm?.profiles,
     llm?.defaultProvider ?? null,
   );

package/src/config/llm-resolver.ts

@@ -627,6 +627,22 @@ export function resolveDefaultProfileKey(
   return selectWinningProfile(callSite, llm, {}).profileName ?? undefined;
 }
 
+/**
+ * Returns the code-owned profile tier for catalog display when that tier is
+ * available through the workspace's default provider. Workspace call-site
+ * pins do not affect this value. A managed-only tier on a BYOK install returns
+ * undefined so clients do not report a profile that cannot run there.
+ */
+export function resolveShippedDefaultProfileKey(
+  callSite: LLMCallSite,
+  llm: z.infer<typeof LLMSchema>,
+): string | undefined {
+  const intent = CALL_SITE_DEFAULTS[callSite]?.profile ?? "balanced";
+  return usableDefaultIntent(intent, llm, {}, () => undefined) == null
+    ? undefined
+    : intent;
+}
+
 /**
  * Returns the profile key that `resolveCallSiteConfig` treats as the winning
  * (highest-precedence) profile for a turn — the profile whose fragment supplies

package/src/config/profile-text-generation.test.ts

@@ -15,6 +15,15 @@ describe("profileSupportsTextGeneration", () => {
     ).toBe(false);
   });
 
+  test("false for the managed Jev profile shape", () => {
+    expect(
+      profileSupportsTextGeneration(
+        { provider: "vellum", model: "jev-latest" },
+        {},
+      ),
+    ).toBe(false);
+  });
+
   test("true for a chat model and for unlisted custom ids", () => {
     expect(
       profileSupportsTextGeneration(

package/src/config/schemas/call-site-catalog.ts

@@ -307,7 +307,7 @@ const CATALOG_RECORD: CatalogRecord = {
     id: "voiceEscalationJudge",
     displayName: "Voice Escalation Judge",
     description:
-      "Second opinion on the voice front door's escalate decision. Runs only when pinned to a TypeSafe profile; a confident 'needs tools' verdict hands the turn to the escalated leg.",
+      "Second opinion on the voice front door's escalate decision. Uses managed Jev when Vellum-managed inference is available, or an explicitly configured TypeSafe profile; a confident 'needs tools' verdict hands the turn to the escalated leg.",
     domain: "agentLoop",
   },
   voiceContinuationJudge: {