@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -121,6 +121,27 @@ const CATALOG_RECORD: CatalogRecord = {
       "Selects which concept pages to inject for the next agent turn by routing over a cached page index.",
     domain: "memory",
   },
+  memoryV3Filter: {
+    id: "memoryV3Filter",
+    displayName: "Memory V3 Filter",
+    description:
+      "Cheaply filters the V3 multi-lane candidate set before descent.",
+    domain: "memory",
+  },
+  memoryV3Descent: {
+    id: "memoryV3Descent",
+    displayName: "Memory V3 Descent",
+    description:
+      "Drives the V3 bounded-descent traversal through the memory tree.",
+    domain: "memory",
+  },
+  memoryV3Gate: {
+    id: "memoryV3Gate",
+    displayName: "Memory V3 Gate",
+    description:
+      "Final capable gate that decides which V3 candidates are injected for the next turn.",
+    domain: "memory",
+  },
   memoryV2Consolidation: {
     id: "memoryV2Consolidation",
     displayName: "Memory V2 Consolidation",
@@ -314,13 +335,6 @@ const CATALOG_RECORD: CatalogRecord = {
       "Generates contextual conversation-starter suggestions for the Home page.",
     domain: "ui",
   },
-  queryComplexityRouter: {
-    id: "queryComplexityRouter",
-    displayName: "Query Complexity Router",
-    description:
-      "Classifies user message complexity to route to the appropriate inference profile.",
-    domain: "agentLoop",
-  },
 };
 
 // Source of truth for call-site display metadata. API responses and usage

package/src/config/schemas/heartbeat.ts

@@ -11,7 +11,7 @@ export const HeartbeatConfigSchema = z
       .number({ error: "heartbeat.intervalMs must be a number" })
       .int("heartbeat.intervalMs must be an integer")
       .positive("heartbeat.intervalMs must be a positive integer")
-      .default(30 * 60_000)
+      .default(60 * 60_000)
       .describe("Time between heartbeat checks in milliseconds"),
     cronExpression: z
       .string()

package/src/config/schemas/llm.ts

@@ -49,6 +49,9 @@ export const LLMCallSiteEnum = z.enum([
   "memoryV2Migration",
   "memoryV2Sweep",
   "memoryRouter",
+  "memoryV3Filter",
+  "memoryV3Descent",
+  "memoryV3Gate",
   "memoryV2Consolidation",
   "memoryRetrospective",
   "recall",
@@ -78,7 +81,6 @@ export const LLMCallSiteEnum = z.enum([
   "proactiveArtifactBuild",
   "homeGreeting",
   "homeSuggestedPrompts",
-  "queryComplexityRouter",
 ]);
 export type LLMCallSite = z.infer<typeof LLMCallSiteEnum>;
 
@@ -152,10 +154,18 @@ const TemperatureSchema = z.number().min(0).max(2).nullable();
 // defaulted (`ThinkingSchema`) and fragment (`ThinkingFragmentSchema`) views.
 const ThinkingEnabledSchema = z.boolean();
 const ThinkingStreamThinkingSchema = z.boolean();
+// Gemini-style thinking depth knob. Maps to Gemini's `thinkingLevel`. Other
+// providers (Anthropic, OpenRouter) ignore this field — they use `effort`
+// instead to size reasoning. Optional with no default so the underlying
+// provider can pick its own default (Gemini 3.x defaults to "medium").
+export const THINKING_LEVELS = ["minimal", "low", "medium", "high"] as const;
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+const ThinkingLevelSchema = z.enum(THINKING_LEVELS);
 
 const ThinkingSchema = z.object({
   enabled: ThinkingEnabledSchema.default(true),
   streamThinking: ThinkingStreamThinkingSchema.default(true),
+  level: ThinkingLevelSchema.optional(),
 });
 
 // Fragment view: every field optional, no defaults injected. Defining this
@@ -165,6 +175,7 @@ const ThinkingSchema = z.object({
 const ThinkingFragmentSchema = z.object({
   enabled: ThinkingEnabledSchema.optional(),
   streamThinking: ThinkingStreamThinkingSchema.optional(),
+  level: ThinkingLevelSchema.optional(),
 });
 
 // Leaf primitives for context-overflow recovery.
@@ -298,7 +309,7 @@ export const LLMConfigBase = z.object({
    * naturally — the underlying profile-level field is on `ProfileEntry`.
    */
   provider_connection: z.string().min(1).optional(),
-  model: ModelSchema.default("claude-opus-4-7"),
+  model: ModelSchema.default("claude-opus-4-8"),
   maxTokens: MaxTokensSchema.default(64000),
   effort: EffortEnum.default("max"),
   speed: SpeedEnum.default("standard"),
@@ -333,6 +344,27 @@ type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
 export const ProfileStatusSchema = z.enum(["active", "disabled"]);
 export type ProfileStatus = z.infer<typeof ProfileStatusSchema>;
 
+// ---------------------------------------------------------------------------
+// Mix profiles
+//
+// A "mix" profile carries no model config of its own. Instead it references a
+// weighted list of other (standard) profiles; at resolve time exactly one
+// constituent is chosen by weight. The pick is a deterministic function of a
+// per-conversation seed (the conversation id — see `resolveCallSiteConfig`'s
+// `selectionSeed`), so a conversation always lands on the same arm across all
+// its turns, retries, and even daemon restarts, while different conversations
+// split according to the weights — and the chosen arm is recordable for A/B
+// evaluation. Weights are relative (normalized by their sum at pick time), so
+// `[{weight:80},{weight:20}]` and `[{weight:4},{weight:1}]` are equivalent.
+// ---------------------------------------------------------------------------
+const MixArmSchema = z.object({
+  profile: z.string().min(1),
+  weight: z.number().finite().positive(),
+});
+export type MixArm = z.infer<typeof MixArmSchema>;
+
+const MixSchema = z.array(MixArmSchema).min(2);
+
 /**
  * A named profile entry: an `LLMConfigFragment` augmented with
  * presentation/ownership metadata. These fields are intentionally kept off
@@ -368,6 +400,17 @@ export const ProfileEntry = LLMConfigFragment.extend({
    * #30362 even though the schema didn't accept it until now.
    */
   status: ProfileStatusSchema.nullable().optional(),
+  /**
+   * When present, this profile is a "mix": it carries no model config and
+   * instead references a weighted list of standard profiles. The resolver
+   * expands a mix by a seeded weighted pick (see `resolveCallSiteConfig`).
+   * `LLMSchema.superRefine` enforces that (a) every referenced profile exists,
+   * (b) no referenced profile is itself a mix (no nesting), (c) no arm
+   * references the mix itself, and (d) a mix carries no `LLMConfigFragment`
+   * config field — only metadata (`label`, `description`, `status`, `source`)
+   * may accompany `mix`.
+   */
+  mix: MixSchema.optional(),
 });
 export type ProfileEntry = z.infer<typeof ProfileEntry>;
 
@@ -433,6 +476,63 @@ export const LLMSchema = z
         message: `Profile "${config.activeProfile}" referenced by llm.activeProfile is not defined in llm.profiles`,
       });
     }
+
+    // --- Mix profile validation --------------------------------------------
+    // Config keys a mix profile must NOT also set (a mix only references other
+    // profiles + metadata). Derived from the fragment shape plus the
+    // ProfileEntry-only `provider_connection` so it can't drift if a new config
+    // field is added to `LLMConfigFragment`.
+    const MIX_DISALLOWED_CONFIG_KEYS = [
+      ...Object.keys(LLMConfigFragment.shape),
+      "provider_connection",
+    ];
+    const mixProfileNames = new Set(
+      Object.entries(config.profiles ?? {})
+        .filter(([, profile]) => profile?.mix != null)
+        .map(([name]) => name),
+    );
+    for (const [name, profile] of Object.entries(config.profiles ?? {})) {
+      if (profile?.mix == null) continue;
+      // (d) A mix must not also carry model config — the resolved config comes
+      // entirely from the chosen constituent.
+      for (const key of MIX_DISALLOWED_CONFIG_KEYS) {
+        if ((profile as Record<string, unknown>)[key] !== undefined) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["profiles", name, key],
+            message: `Mix profile "${name}" cannot also set "${key}" — a mix only references other profiles plus metadata (label, description, status).`,
+          });
+        }
+      }
+      for (const [index, arm] of profile.mix.entries()) {
+        // (c) No self-reference.
+        if (arm.profile === name) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["profiles", name, "mix", index, "profile"],
+            message: `Mix profile "${name}" cannot reference itself.`,
+          });
+          continue;
+        }
+        // (a) Referenced profile must exist.
+        if (!profileNames.has(arm.profile)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["profiles", name, "mix", index, "profile"],
+            message: `Mix profile "${name}" references profile "${arm.profile}" which is not defined in llm.profiles.`,
+          });
+          continue;
+        }
+        // (b) No nesting — a mix arm must be a standard (non-mix) profile.
+        if (mixProfileNames.has(arm.profile)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["profiles", name, "mix", index, "profile"],
+            message: `Mix profile "${name}" references another mix profile "${arm.profile}" — mixes cannot be nested; constituents must be standard profiles.`,
+          });
+        }
+      }
+    }
   });
 
 export type LLMConfig = z.infer<typeof LLMSchema>;

package/src/config/schemas/memory-v2.ts

@@ -322,6 +322,23 @@ export const MemoryV2ConfigSchema = z
           .describe(
             "Pool size for the tier-2 'useful' batch. `null` (default) disables tier 2 — pages skip straight from tier 1 to tier 3. When set, the top-M pages by injection-frequency EMA (excluding tier 1) become their own parallel batch ordered by score desc. Pages with score 0 (never selected since EMA tracking began) are ineligible for tier 2 and stay in tier 3 regardless of `tier2_size`. Score is the time-decayed sum `Σ exp(-λ(now - tᵢ))` with 3-day half-life, computed on read from `memory_v2_injection_events`.",
           ),
+        historical_pairs: z
+          .number()
+          .int()
+          .min(1)
+          .default(1)
+          .describe(
+            "Number of recent (assistant, user) turn pairs to render inside the router prompt's `<last_turn>` block. Each pair is the assistant's reply followed by the user message that came after; the most recent pair's user line is the just-arrived turn that triggered the router. `1` (default) shows only the prior assistant reply plus the current user message — bit-identical to pre-knob behavior. Higher values walk further back through conversation history to give the router more dialogue context at the cost of larger per-turn prompt size. Pairs are emitted in chronological order (oldest first).",
+          ),
+        historical_pairs_max_chars: z
+          .number()
+          .int()
+          .min(1)
+          .nullable()
+          .default(null)
+          .describe(
+            "Optional character cap on the total message content rendered inside `<last_turn>`. `null` (default) means no limit — every message inside the configured `historical_pairs` window is included verbatim. When set, the router walks the assembled pairs newest-first; messages are included until the budget is exhausted, at which point the oldest still-includable message is front-truncated with a leading `…` marker. Older pairs whose content does not fit are dropped entirely. The cap counts message content only — framing characters (`[assistant]: `, `[user]: `, newlines) are not deducted from the budget. Set this when raising `historical_pairs` on workspaces with long messages so the router prompt stays bounded.",
+          ),
       })
       .default({
         enabled: true,
@@ -330,6 +347,8 @@ export const MemoryV2ConfigSchema = z
         batch_size: null,
         tier1_size: null,
         tier2_size: null,
+        historical_pairs: 1,
+        historical_pairs_max_chars: null,
       })
       .describe(
         "LLM router configuration. When enabled, a single router LLM call replaces spreading activation for per-turn page selection.",
@@ -369,3 +388,256 @@ export const MemoryV2ConfigSchema = z
   });
 
 export type MemoryV2Config = z.infer<typeof MemoryV2ConfigSchema>;
+
+/**
+ * Per-lane system-prompt override for a v3 LLM call site. `override` is an
+ * inline prompt string (highest precedence); `path` points at a file whose
+ * contents replace the bundled prompt. Both default to `null` (use the bundled
+ * prompt). Shared by the filter, descent, and gate entries under
+ * `memory.v3.prompts`. The whole object is `.default(...)`-wrapped so an
+ * omitted lane parses to `{ override: null, path: null }`.
+ */
+const V3PromptOverrideSchema = z
+  .object({
+    override: z
+      .string({ error: "memory.v3.prompts.*.override must be a string" })
+      .nullable()
+      .default(null)
+      .describe(
+        "Optional inline system-prompt string that replaces the bundled prompt for this lane. Takes precedence over `path`. An empty or whitespace-only string is ignored (falls back to `path` / bundled).",
+      ),
+    path: z
+      .string({ error: "memory.v3.prompts.*.path must be a string" })
+      .nullable()
+      .default(null)
+      .describe(
+        "Optional path to a file whose contents replace the bundled prompt for this lane. Absolute paths are used as-is, a leading `~/` expands to the home directory, otherwise the path resolves under the workspace root. If the file is missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
+      ),
+  })
+  .default({ override: null, path: null });
+
+/**
+ * Memory v3 (multi-lane, bounded-descent retrieval) configuration.
+ *
+ * Additive scaffolding only — defaults to `enabled: false` so existing
+ * configs are untouched and the v3 retrieval loop stays inert until later
+ * PRs wire it up. Every field carries a default and the whole block is
+ * `.default(...)`-wrapped so a config that omits `memory.v3` entirely still
+ * parses to these documented defaults.
+ */
+export const MemoryV3ConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "memory.v3.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Whether the v3 memory subsystem (multi-lane bounded-descent retrieval) is enabled. Off by default until the v3 loop is wired up.",
+      ),
+    shadow: z
+      .boolean({ error: "memory.v3.shadow must be a boolean" })
+      .default(false)
+      .describe(
+        "Live-shadow toggle: when on, the v3 retrieval loop runs alongside the active path for comparison without affecting injected context. Consumed by a later PR.",
+      ),
+    passCap: z
+      .number({ error: "memory.v3.passCap must be a number" })
+      .int("memory.v3.passCap must be an integer")
+      .default(3)
+      .describe(
+        "Maximum number of retrieval passes (router → descent rounds) the v3 loop may run per turn.",
+      ),
+    breadthBudget: z
+      .number({ error: "memory.v3.breadthBudget must be a number" })
+      .int("memory.v3.breadthBudget must be an integer")
+      .default(6)
+      .describe(
+        "Per-pass breadth budget — the number of frontier candidates the v3 loop may expand at each step.",
+      ),
+    maxDepth: z
+      .number({ error: "memory.v3.maxDepth must be a number" })
+      .int("memory.v3.maxDepth must be an integer")
+      .default(6)
+      .describe(
+        "Maximum descent depth the v3 loop traverses through the memory tree before stopping.",
+      ),
+    denseQuota: z
+      .object({
+        activeDomain: z
+          .number({
+            error: "memory.v3.denseQuota.activeDomain must be a number",
+          })
+          .default(30)
+          .describe(
+            "Dense-lane candidate quota allocated to the conversation's active domain.",
+          ),
+        offDomain: z
+          .number({ error: "memory.v3.denseQuota.offDomain must be a number" })
+          .default(8)
+          .describe(
+            "Dense-lane candidate quota allocated to off-domain (exploratory) retrieval.",
+          ),
+      })
+      .default({ activeDomain: 30, offDomain: 8 })
+      .describe(
+        "Dense-lane candidate quotas split between the active domain and off-domain exploration.",
+      ),
+    hotLimit: z
+      .number({ error: "memory.v3.hotLimit must be a number" })
+      .int("memory.v3.hotLimit must be an integer")
+      .positive("memory.v3.hotLimit must be positive")
+      .default(50)
+      .describe(
+        "Top-N cap on the hot scout lane, ranked by injection-frequency EMA. Hot hits are sticky (kept past the gate), so this bounds how many always-on pages the lane forces into the selection. Without a cap a mature corpus — where nearly every page has been injected at some point — surfaces the entire corpus.",
+      ),
+    lanes: z
+      .object({
+        hot: z
+          .boolean()
+          .default(true)
+          .describe("Whether the hot (recently-touched) retrieval lane is on."),
+        sparse: z
+          .boolean()
+          .default(true)
+          .describe("Whether the sparse (BM25-style keyword) lane is on."),
+        dense: z
+          .boolean()
+          .default(true)
+          .describe("Whether the dense (embedding-similarity) lane is on."),
+        tree: z
+          .boolean()
+          .default(true)
+          .describe("Whether the tree (hierarchical descent) lane is on."),
+        edges: z
+          .boolean()
+          .default(true)
+          .describe("Whether the edges (graph-adjacency) lane is on."),
+      })
+      .default({
+        hot: true,
+        sparse: true,
+        dense: true,
+        tree: true,
+        edges: true,
+      })
+      .describe(
+        "Per-lane on/off toggles for the v3 multi-lane retrieval fanout. All lanes on by default.",
+      ),
+    edges: z
+      .object({
+        learnedAdjacencyThreshold: z
+          .number({
+            error: "memory.v3.edges.learnedAdjacencyThreshold must be a number",
+          })
+          .min(0, "memory.v3.edges.learnedAdjacencyThreshold must be >= 0")
+          .default(0)
+          .describe(
+            "Association-strength cutoff for merging the learned co-retrieval graph (memory_v3_auto_edges) into the edge-expansion lane. Seeded edges are weighted seedWeight × NPMI, so this is effectively a minimum-NPMI gate: NPMI ≥ threshold / seedWeight (e.g. with the default seedWeight 2.0, threshold 1.0 ≈ NPMI ≥ 0.5, 1.2 ≈ NPMI ≥ 0.6). When > 0, edges at or above this weight are read via aboveThreshold() and merged with the curated frontmatter graph as expandEdges' extraAdjacency. 0 (default) = OFF: the edge lane uses curated edges only and behavior is unchanged. Seed the learned graph with `assistant memory v3 seed-edges`.",
+          ),
+        maxPulls: z
+          .number({ error: "memory.v3.edges.maxPulls must be a number" })
+          .min(0, "memory.v3.edges.maxPulls must be >= 0")
+          .default(400)
+          .describe(
+            "Hard cap on the edge lane's contribution to the gate's candidate pool (the unioned 1–2 hop curated∪learned neighborhood). The shipped default 400 lets a dense curated graph dominate the pool and drown the gate's recall of high-precision hits; lower values (~40) keep the lane focused. 0 effectively disables edge pulls.",
+          ),
+      })
+      .default({ learnedAdjacencyThreshold: 0, maxPulls: 400 })
+      .describe(
+        "Edge-expansion lane configuration. Gates whether the learned co-retrieval graph augments the curated edge graph.",
+      ),
+    ks: z
+      .array(z.number({ error: "memory.v3.ks entries must be numbers" }))
+      .default([5, 10, 25, 50])
+      .describe(
+        "Evaluation top-K cutoffs the v3 loop reports metrics at (e.g. recall@K).",
+      ),
+    write: z
+      .object({
+        enabled: z
+          .boolean({ error: "memory.v3.write.enabled must be a boolean" })
+          .default(false)
+          .describe(
+            "Whether v3 consolidation owns the shared-buffer drain + tree build. Off by default — v2 consolidation stays the sole buffer-drainer. Does NOT introduce a separate buffer.",
+          ),
+        consolidateIntervalMs: z
+          .number({
+            error: "memory.v3.write.consolidateIntervalMs must be a number",
+          })
+          .int("memory.v3.write.consolidateIntervalMs must be an integer")
+          .positive("memory.v3.write.consolidateIntervalMs must be positive")
+          .default(3600000)
+          .describe(
+            "Interval, in milliseconds, between scheduled v3 consolidation runs once the v3 write path owns the drain. Default 1 hour.",
+          ),
+        coactivation: z
+          .boolean({ error: "memory.v3.write.coactivation must be a boolean" })
+          .default(false)
+          .describe(
+            "Whether v3 consolidation learns co-activation edges during the tree build. Off by default; consumed by a later PR.",
+          ),
+      })
+      .default({
+        enabled: false,
+        consolidateIntervalMs: 3600000,
+        coactivation: false,
+      })
+      .describe(
+        "Memory v3 write-path configuration. All default-off scaffolding — controls whether v3 consolidation owns the shared-buffer drain + tree build. Consumed by later PRs.",
+      ),
+    prompts: z
+      .object({
+        filter: V3PromptOverrideSchema.describe(
+          "Override for the dense-hit filter lane's system prompt.",
+        ),
+        descent: V3PromptOverrideSchema.describe(
+          "Override for the tree-walk descent driver's system prompt.",
+        ),
+        gate: V3PromptOverrideSchema.describe(
+          "Override for the selection gate's system prompt.",
+        ),
+      })
+      .default({
+        filter: { override: null, path: null },
+        descent: { override: null, path: null },
+        gate: { override: null, path: null },
+      })
+      .describe(
+        "Per-lane system-prompt overrides for the three v3 LLM call sites (filter, descent, gate). Each entry takes an inline `override` string (highest precedence) and/or a file `path` whose contents replace the bundled prompt; absolute paths are used as-is, a leading `~/` expands to the home directory, otherwise the path resolves under the workspace root. An empty/whitespace inline override or a missing/unreadable/empty file falls back to the bundled prompt. Lets the prompts be iterated at runtime without a rebuild/restart — mirroring `memory.v2.router.router_prompt_path`.",
+      ),
+    gateCandidateSummaries: z
+      .boolean({
+        error: "memory.v3.gateCandidateSummaries must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "When true, the selection gate sees each candidate as `slug — summary` instead of the bare slug, so it can judge relevance on page content. Off by default: with the bundled (precision-leaning) gate prompt this makes the gate more selective. It pays off paired with a recall-leaning gate prompt override, where the summaries let the gate recognize non-obvious associative/emotional matches it would otherwise pass over. Adds the candidate summaries to the gate prompt (larger input).",
+      ),
+  })
+  .default({
+    enabled: false,
+    shadow: false,
+    passCap: 3,
+    breadthBudget: 6,
+    maxDepth: 6,
+    denseQuota: { activeDomain: 30, offDomain: 8 },
+    hotLimit: 50,
+    lanes: { hot: true, sparse: true, dense: true, tree: true, edges: true },
+    edges: { learnedAdjacencyThreshold: 0, maxPulls: 400 },
+    ks: [5, 10, 25, 50],
+    write: {
+      enabled: false,
+      consolidateIntervalMs: 3600000,
+      coactivation: false,
+    },
+    prompts: {
+      filter: { override: null, path: null },
+      descent: { override: null, path: null },
+      gate: { override: null, path: null },
+    },
+    gateCandidateSummaries: false,
+  })
+  .describe(
+    "Memory v3 — multi-lane bounded-descent retrieval. Additive scaffolding, disabled by default.",
+  );
+
+export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

package/src/config/schemas/memory.ts

@@ -16,7 +16,7 @@ import {
   MemorySegmentationConfigSchema,
   QdrantConfigSchema,
 } from "./memory-storage.js";
-import { MemoryV2ConfigSchema } from "./memory-v2.js";
+import { MemoryV2ConfigSchema, MemoryV3ConfigSchema } from "./memory-v2.js";
 
 export const MemoryConfigSchema = z
   .object({
@@ -50,6 +50,7 @@ export const MemoryConfigSchema = z
       MemorySummarizationConfigSchema.parse({}),
     ),
     v2: MemoryV2ConfigSchema.default(MemoryV2ConfigSchema.parse({})),
+    v3: MemoryV3ConfigSchema.default(MemoryV3ConfigSchema.parse({})),
     retrospective: MemoryRetrospectiveConfigSchema.default(
       MemoryRetrospectiveConfigSchema.parse({}),
     ),

package/src/config/schemas/services.ts

@@ -46,13 +46,17 @@ const ImageGenerationServiceSchema = BaseServiceSchema.extend({
 });
 
 const WebSearchServiceSchema = BaseServiceSchema.extend({
+  // Provider choice for app-executed search in Your Own mode, or the native
+  // hosted-search preference when set to `inference-provider-native`. In
+  // Managed mode, non-native inference providers can still use the platform
+  // managed search proxy through the app-executed `web_search` tool.
   provider: z
     .enum(VALID_WEB_SEARCH_PROVIDERS)
     .default("inference-provider-native"),
 });
 
 const GoogleOAuthServiceSchema = BaseServiceSchema.extend({
-  mode: ServiceModeSchema.default("your-own"),
+  mode: ServiceModeSchema.default("managed"),
 });
 
 const OutlookOAuthServiceSchema = BaseServiceSchema.extend({
@@ -68,7 +72,7 @@ const GitHubOAuthServiceSchema = BaseServiceSchema.extend({
 });
 
 const NotionOAuthServiceSchema = BaseServiceSchema.extend({
-  mode: ServiceModeSchema.default("your-own"),
+  mode: ServiceModeSchema.default("managed"),
 });
 
 const TwitterOAuthServiceSchema = BaseServiceSchema.extend({

package/src/config/seed-inference-profiles.ts

@@ -1,7 +1,6 @@
 import type { DrizzleDb } from "../memory/db-connection.js";
 import {
   createConnection,
-  disableManagedConnectionsForByokHatch,
   getConnection,
   MANAGED_CONNECTION_NAMES,
   PROVIDERS_REQUIRING_BASE_URL_AND_MODELS,
@@ -123,9 +122,18 @@ const USER_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
   },
 };
 
-export const MANAGED_PROFILE_NAMES = new Set(
-  Object.keys(MANAGED_PROFILE_TEMPLATES),
-);
+/**
+ * The "auto" profile key. When active, the daemon injects the
+ * `switch_inference_profile` tool and lets the model self-select a profile
+ * per query. No provider/model — the resolver falls through to the call-site
+ * default (balanced or custom-balanced for BYOK).
+ */
+export const AUTO_PROFILE_KEY = "auto";
+
+export const MANAGED_PROFILE_NAMES = new Set([
+  ...Object.keys(MANAGED_PROFILE_TEMPLATES),
+  AUTO_PROFILE_KEY,
+]);
 
 export type SeedInferenceProfilesOptions = {
   /**
@@ -263,21 +271,28 @@ export function seedInferenceProfiles(
     profiles[name] = next as ProfileEntry;
   }
 
+  // 1b. Auto profile — a metadata-only profile with no provider/model. When
+  //     the user selects "Auto", the resolver falls through to the call-site
+  //     default (balanced or custom-balanced), and the agent loop injects the
+  //     switch_inference_profile tool so the model can self-select per query.
+  if (!preservedProfileNames.has(AUTO_PROFILE_KEY)) {
+    const previousAuto = readObject(profiles[AUTO_PROFILE_KEY]);
+    const autoEntry: Record<string, unknown> = {
+      source: "managed",
+      label: "Auto",
+      description:
+        "Automatically routes each query to the best profile — fast for simple questions, capable for complex ones",
+    };
+    if (previousAuto) {
+      if ("label" in previousAuto) autoEntry.label = previousAuto.label;
+      if ("status" in previousAuto) autoEntry.status = previousAuto.status;
+    }
+    profiles[AUTO_PROFILE_KEY] = autoEntry as ProfileEntry;
+  }
+
   // 2. User profiles — only at hatch time for off-platform installations.
   let userConnectionName: string | undefined;
   if (options.isHatch && !isPlatform) {
-    // BYOK hatch: disable canonical managed connections so the picker doesn't
-    // surface unusable platform-auth options on day one. If the hatch overlay
-    // selected a managed profile, leave that connection active; the user has
-    // already chosen managed inference. Runs only here, only at hatch —
-    // `seedCanonicalConnections` leaves `status` alone on subsequent boots so
-    // a post-hatch user re-enable persists.
-    if (options.db) {
-      disableManagedConnectionsForByokHatch(options.db, {
-        excludeConnection: hatchSelectedManagedConnection,
-      });
-    }
-
     const hatchProvider = readString(readObject(llm.default)?.provider);
     if (
       hatchProvider &&
@@ -336,10 +351,15 @@ export function seedInferenceProfiles(
   }
 
   // Profile ordering — ensure all seeded profiles appear in the order array.
+  // "auto" is prepended so it appears first in the picker.
   const profileOrder = Array.isArray(llm.profileOrder)
     ? (llm.profileOrder as string[])
     : [];
   const orderSet = new Set(profileOrder);
+  if (!orderSet.has(AUTO_PROFILE_KEY)) {
+    profileOrder.unshift(AUTO_PROFILE_KEY);
+    orderSet.add(AUTO_PROFILE_KEY);
+  }
   for (const name of Object.keys(MANAGED_PROFILE_TEMPLATES)) {
     if (!orderSet.has(name)) {
       profileOrder.push(name);