@vellumai/assistant 0.12.3-dev.202609221714.83d90c3 → 0.12.3-dev.202609222016.8d633dd

package/openapi.yaml

@@ -21412,6 +21412,10 @@ paths:
                                         type: string
                                       mayRequireJavaScript:
                                         type: boolean
+                                      startIndexPastEnd:
+                                        type: boolean
+                                      providerWarning:
+                                        type: string
                                     required:
                                       - url
                                       - finalUrl
@@ -22026,6 +22030,10 @@ paths:
                                                 type: string
                                               mayRequireJavaScript:
                                                 type: boolean
+                                              startIndexPastEnd:
+                                                type: boolean
+                                              providerWarning:
+                                                type: string
                                             required:
                                               - url
                                               - finalUrl

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.3-dev.202609221714.83d90c3",
+  "version": "0.12.3-dev.202609222016.8d633dd",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-pairing.test.ts

@@ -996,6 +996,12 @@ describe("pairDeliveryWithConversation", () => {
     expect(createConversationMock).not.toHaveBeenCalled();
     expect(addMessageMock).toHaveBeenCalledTimes(1);
     expect(messagesInvalidated).toContain("conv-foreground");
+    // The transcript is this notification's only home, so a chat marked Done
+    // comes back for it.
+    const options = addMessageMock.mock.calls[0]![3] as {
+      skipResurface?: boolean;
+    };
+    expect(options.skipResurface).toBe(false);
   });
 
   test("appended notification body skips indexing", async () => {
@@ -1017,8 +1023,12 @@ describe("pairDeliveryWithConversation", () => {
 
     const options = addMessageMock.mock.calls[0]![3] as {
       skipIndexing?: boolean;
+      skipResurface?: boolean;
     };
     expect(options.skipIndexing).toBe(true);
+    // The bell carries this one (async-background), so the append is
+    // bookkeeping and never resurfaces a chat the user marked Done.
+    expect(options.skipResurface).toBe(true);
   });
 
   test("passive vellum signal appends regardless of the producing conversation's source", async () => {

package/src/__tests__/job-handler-registration-guard.test.ts

@@ -35,6 +35,7 @@ const MEMORY_JOB_TYPES = [
   "memory_retrospective",
   "memory_retrospective_sweep",
   "skill_card_insert",
+  "skill_update_receipt",
   "pkb_filing",
   "pkb_compaction",
 ].sort();

package/src/__tests__/openai-responses-prompt-cache.test.ts

@@ -446,7 +446,7 @@ describe("OpenAIResponsesProvider explicit prompt caching (GPT-5.6+)", () => {
     expect(JSON.stringify(messages)).not.toContain("prompt_cache_breakpoint");
   });
 
-  test("catalog flags GPT-5.6 and GPT-6 Astra direct-openai rows", () => {
+  test("catalog flags GPT-5.6 and GPT-6 direct-openai rows", () => {
     const openai = PROVIDER_CATALOG.find((p) => p.id === "openai");
     const flagged = (openai?.models ?? [])
       .filter((m) => m.supportsPromptCacheBreakpoints)
@@ -457,6 +457,8 @@ describe("OpenAIResponsesProvider explicit prompt caching (GPT-5.6+)", () => {
       "gpt-5.6-sol",
       "gpt-5.6-terra",
       "gpt-6-astra",
+      "gpt-6-luna",
+      "gpt-6-sol",
     ]);
   });
 });

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -196,6 +196,9 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../daemon/trust-context.js",
     "../../../home/job-handlers/conversation-starters.js",
     "../../../media/job-handlers/media-processing.js",
+    // The skill-update receipt job announces a burst through the
+    // notification pipeline's single entry point. No plugin-api equivalent.
+    "../../../notifications/emit-signal.js",
     "../../../permissions/types.js",
     "../../../persistence/auto-analysis-constants.js",
     "../../../persistence/checkpoints.js",

package/src/__tests__/pricing.test.ts

@@ -135,6 +135,39 @@ describe("resolvePricing", () => {
       expect(result.estimatedCostUsd).toBeCloseTo(0.5 + 0.625 + 0.05, 10);
     });
 
+    test("bills GPT-6 Sol at published short-context rates", () => {
+      const result = resolvePricingForUsage("openai", "gpt-6-sol", {
+        directInputTokens: 50_000,
+        outputTokens: 50_000,
+        cacheCreationInputTokens: 50_000,
+        cacheReadInputTokens: 50_000,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      // 0.05M x $2 direct + 0.05M x $2.5 write + 0.05M x $0.2 read
+      // + 0.05M x $10 output.
+      expect(result.estimatedCostUsd).toBeCloseTo(0.1 + 0.125 + 0.01 + 0.5, 10);
+    });
+
+    test("bills GPT-6 Luna at the long-context tier above 272k", () => {
+      const result = resolvePricingForUsage("openai", "gpt-6-luna", {
+        directInputTokens: 500_000,
+        outputTokens: 1_000_000,
+        cacheCreationInputTokens: 500_000,
+        cacheReadInputTokens: 1_000_000,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      // Tier rates: 0.5M x $0.2 direct + 0.5M x $0.25 write + 1M x $0.02 read
+      // + 1M x $0.75 output.
+      expect(result.estimatedCostUsd).toBeCloseTo(
+        0.1 + 0.125 + 0.02 + 0.75,
+        10,
+      );
+    });
+
     test("bills GPT-6 Astra at the long-context tier above 272k", () => {
       const result = resolvePricingForUsage("openai", "gpt-6-astra", {
         directInputTokens: 500_000,

package/src/api/events/tool-result.ts

@@ -112,6 +112,16 @@ export const WebFetchMetadataSchema = z.object({
   durationMs: z.number(),
   errorMessage: z.string().optional(),
   mayRequireJavaScript: z.boolean().optional(),
+  /**
+   * The requested `start_index` was past the end of the page, so nothing was
+   * read. Always set, true or false, by an assistant whose metadata carries
+   * every warning a reader acts on (this and `providerWarning` included); a
+   * record without it came from one that predates them, whose remaining
+   * warnings are only in the result text.
+   */
+  startIndexPastEnd: z.boolean().optional(),
+  /** A hosted provider's own warning about the fetch, verbatim. */
+  providerWarning: z.string().optional(),
 });
 
 export type WebFetchMetadata = z.infer<typeof WebFetchMetadataSchema>;

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

@@ -16,9 +16,9 @@
  * decision stands exactly as it would without the judge.
  */
 
+import { askTypesafeNoul } from "../providers/jev/ask.js";
 import type { Message, Provider } from "../providers/types.js";
 import { safeStringSlice } from "../util/unicode.js";
-import { askTypesafeNoul } from "./typesafe-noul.js";
 
 export const VOICE_ESCALATION_JUDGE_CALL_SITE = "voiceEscalationJudge";
 

package/src/cli/lib/__tests__/plugin-catalog-cache.test.ts

@@ -228,4 +228,64 @@ describe("mergePlatformCatalogWithBundledLocals", () => {
     expect(merged.matches[1]?.source.kind).toBe("local");
     expect(merged.ref).toBe("main");
   });
+  test("keeps the bundled integration when a platform row without one shadows it", () => {
+    const integration = {
+      kind: "mcp",
+      displayName: "Fathom",
+      documentationUrl: "https://example.com/docs",
+      verifiedAt: "2026-09-10",
+      verification: "documentation-only",
+      setup: { mode: "oauth", instructions: "Sign in." },
+      logo: "fathom.png",
+    } as const;
+    const platformIntegration = { ...integration, displayName: "Platform" };
+    const platform: PluginCatalog = {
+      ref: "main",
+      matches: [
+        {
+          name: "fathom",
+          path: "github:provider/fathom@pin",
+          category: null,
+          source: {
+            kind: "github",
+            repo: "provider/fathom",
+            ref: "0".repeat(40),
+          },
+        },
+        {
+          name: "linear",
+          path: "github:provider/linear@pin",
+          category: null,
+          integration: platformIntegration,
+          source: {
+            kind: "github",
+            repo: "provider/linear",
+            ref: "0".repeat(40),
+          },
+        },
+      ],
+    };
+    const bundled: PluginCatalog = {
+      ref: "bundled",
+      matches: ["fathom", "linear"].map((name) => ({
+        name,
+        path: `local:plugins/mcp-catalog/${name}@1.0.0`,
+        category: null,
+        integration,
+        source: {
+          kind: "local",
+          path: `plugins/mcp-catalog/${name}`,
+          version: "1.0.0",
+        },
+      })),
+    };
+
+    const merged = mergePlatformCatalogWithBundledLocals(platform, bundled);
+
+    const [fathom, linear] = merged.matches;
+    expect(fathom?.source.kind).toBe("github");
+    expect(fathom?.integration).toEqual(integration);
+    expect(linear?.source.kind).toBe("github");
+    expect(linear?.integration).toEqual(platformIntegration);
+  });
 });

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

@@ -161,14 +161,78 @@ describe("fetchPluginCatalogFromPlatform", () => {
     await expect(promise).rejects.toMatchObject({ status: 502 });
   });
 
-  test("throws on a schema violation", async () => {
+  test.each([
+    ["a missing plugins array", {}],
+    ["a non-array plugins field", { plugins: "nope" }],
+    ["a non-object body", []],
+  ])("throws on an invalid envelope (%s)", async (_label, body) => {
     const promise = fetchPluginCatalogFromPlatform({
-      fetch: platformFetch({ plugins: [{ repo: "acme/x", ref: SHA_A }] }),
+      fetch: platformFetch(body),
     });
     await expect(promise).rejects.toBeInstanceOf(PluginCatalogUnavailableError);
     await expect(promise).rejects.toMatchObject({ status: 502 });
   });
 
+  test("skips rows that fail the base row schema and keeps the rest", async () => {
+    const catalog = await fetchPluginCatalogFromPlatform({
+      fetch: platformFetch({
+        plugins: [
+          { repo: "acme/nameless", ref: SHA_A },
+          { name: 42, repo: "acme/numeric", ref: SHA_A },
+          "not-a-row",
+          { name: "good", repo: "acme/good", ref: SHA_B },
+        ],
+      }),
+    });
+    expect(catalog.matches.map((m) => m.name)).toEqual(["good"]);
+  });
+
+  test("keeps a row whose integration is invalid, without the integration", async () => {
+    const catalog = await fetchPluginCatalogFromPlatform({
+      fetch: platformFetch({
+        plugins: [
+          {
+            name: "snake-case",
+            repo: "acme/snake-case",
+            ref: SHA_A,
+            description: "kept",
+            integration: {
+              kind: "mcp",
+              display_name: "Snake Case",
+              documentation_url: "https://example.com/docs",
+              verified_at: "2026-09-10",
+              verification: "documentation-only",
+              setup: { mode: "oauth", instructions: "Sign in." },
+              logo: "snake-case.png",
+            },
+          },
+          {
+            name: "valid",
+            repo: "acme/valid",
+            ref: SHA_B,
+            integration: {
+              kind: "mcp",
+              displayName: "Valid",
+              documentationUrl: "https://example.com/docs",
+              verifiedAt: "2026-09-10",
+              verification: "documentation-only",
+              setup: { mode: "manual", instructions: "Paste a key." },
+              logo: "valid.png",
+            },
+          },
+        ],
+      }),
+    });
+
+    expect(catalog.matches.map((m) => m.name)).toEqual(["snake-case", "valid"]);
+    expect(catalog.matches[0]).toMatchObject({
+      name: "snake-case",
+      description: "kept",
+    });
+    expect(catalog.matches[0]?.integration).toBeUndefined();
+    expect(catalog.matches[1]?.integration?.displayName).toBe("Valid");
+  });
+
   test("throws when fetch rejects (network error / abort)", async () => {
     const promise = fetchPluginCatalogFromPlatform({
       fetch: (async () => {

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

@@ -26,16 +26,31 @@ interface CacheEntry {
 
 const cache = new Map<string, CacheEntry>();
 
-/** Add bundled local packages without overriding platform-authoritative rows. */
+/**
+ * Add bundled local packages without overriding platform-authoritative rows.
+ * A platform row without an integration borrows the bundled row's
+ * integration of the same name, so an integration the platform omits or
+ * serves malformed never disappears from the catalog.
+ */
 export function mergePlatformCatalogWithBundledLocals(
   platform: PluginCatalog,
   bundledLocal: PluginCatalog = readBundledLocalPluginCatalog(),
 ): PluginCatalog {
+  const bundledByName = new Map(
+    bundledLocal.matches.map((match) => [match.name, match]),
+  );
+  const platformMatches = platform.matches.map((match) => {
+    const bundledIntegration = bundledByName.get(match.name)?.integration;
+    if (match.integration || !bundledIntegration) {
+      return match;
+    }
+    return { ...match, integration: bundledIntegration };
+  });
   const seen = new Set(platform.matches.map((match) => match.name));
   return {
     ref: platform.ref,
     matches: [
-      ...platform.matches,
+      ...platformMatches,
       ...bundledLocal.matches.filter((match) => !seen.has(match.name)),
     ].sort((a, b) => a.name.localeCompare(b.name)),
   };

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/config/__tests__/default-profile-catalog.test.ts

@@ -10,6 +10,7 @@ import {
   getEffectiveProfiles,
   getEffectiveProfilesForProvider,
   getUserSelectableProfilesForProvider,
+  MANAGED_PROFILE_TEMPLATES,
   PROFILE_IMPLS,
   resolveDefaultProfileForProvider,
 } from "../default-profile-catalog.js";
@@ -79,6 +80,33 @@ describe("getEffectiveProfiles", () => {
     ).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)),

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/call-site-defaults.ts

@@ -159,6 +159,12 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   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" },

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,
@@ -17,6 +18,7 @@ import {
   FALLBACK_PROFILE_BY_KEY,
   isDefaultProfileKey,
   isDefaultProfileProvider,
+  isFlagGatedProfileKey,
   isManagedOnlyProfileKey,
   JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
@@ -407,6 +409,27 @@ export const JEV_MANAGED_PROFILE_TEMPLATE: DefaultProfileTemplate = {
   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 and the managed Jev profile. Backups come after the
@@ -521,6 +544,7 @@ 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,
 ]);
 
@@ -535,6 +559,7 @@ 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,
 ]);
 
@@ -666,6 +691,10 @@ function buildDefaultProfileEntries(): Record<string, ProfileEntry> {
     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,
@@ -757,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;