@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

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__/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

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

@@ -8,6 +8,7 @@ import { isCodexSubscriptionModel } from "../providers/openai/codex-models.js";
 import type { ModelIntent } from "../providers/types.js";
 import { getManagedUpstream } from "../providers/vellum-model-routing.js";
 import {
+  AUTO_PROFILE_KEY,
   BACKUP_PROFILE_KEYS,
   type BackupProfileKey,
   DEFAULT_PROFILE_KEYS,
@@ -15,12 +16,15 @@ import {
   type DefaultProfileKey,
   type DefaultProfileProvider,
   FALLBACK_PROFILE_BY_KEY,
-  isBackupProfileKey,
   isDefaultProfileKey,
   isDefaultProfileProvider,
+  isFlagGatedProfileKey,
+  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 +389,60 @@ 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 },
+};
+
+/**
+ * The Auto profile: the managed Balanced body under its own label, so that
+ * anything dispatching the name directly runs Balanced. The per-message
+ * choice among the defaults happens in the agent loop, not here (see
+ * `AUTO_PROFILE_KEY`). No `fallbackProfile`: the code-owned fallback mapping
+ * is keyed by default profile, and a direct dispatch of this name is already
+ * the fallback path. Flag-gated like `os-beta`: NOT in
+ * `MANAGED_PROFILE_TEMPLATES`, so the unconditional boot seed never creates
+ * it; the flag-gated profile reconcile materializes it while the
+ * `auto-profile` feature flag is on.
+ */
+export const AUTO_PROFILE_TEMPLATE: DefaultProfileTemplate = (() => {
+  const { fallbackProfile: _fallbackProfile, ...balanced } =
+    VELLUM_PROFILE_IMPLS.balanced;
+  return {
+    ...balanced,
+    label: "Auto",
+    description: "Picks the profile that fits each message, in beta",
+  };
+})();
+
 /**
  * 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 +530,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 +543,8 @@ 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,
+  AUTO_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 ]);
 
@@ -507,6 +558,8 @@ 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,
+  AUTO_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 ]);
 
@@ -590,6 +643,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 +687,14 @@ 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[AUTO_PROFILE_KEY] = materializeProfile(
+    AUTO_PROFILE_TEMPLATE,
+    AUTO_PROFILE_TEMPLATE.provider,
+  );
   entries[OS_BETA_PROFILE_KEY] = materializeProfile(
     OS_BETA_PROFILE_TEMPLATE,
     OS_BETA_PROFILE_TEMPLATE.provider,
@@ -697,12 +771,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;
@@ -711,7 +786,7 @@ function resolveAgainstBody(
     return { ...body };
   }
   if (workspace == null) {
-    return name === OS_BETA_PROFILE_KEY ? undefined : { ...body };
+    return isFlagGatedProfileKey(name) ? undefined : { ...body };
   }
   if (workspace.source !== "managed") {
     return workspace;
@@ -787,14 +862,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 +998,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;
+}