@vellumai/assistant 0.8.5 → 0.8.6

package/src/config/bundled-skills/schedule/SKILL.md

@@ -100,7 +100,7 @@ Use `notify` for simple reminders ("remind me to take medicine at 9am"), `execut
 
 ## Conversation Reuse
 
-By default, each schedule run creates a new conversation. For recurring schedules that benefit from accumulating context across runs (e.g. polling-style jobs, daily digests that reference prior results), set `reuse_conversation: true`. When enabled, subsequent runs reuse the conversation from the last successful run instead of creating a new one.
+Recurring schedules reuse the same conversation across runs by default — subsequent runs continue the conversation from the last successful run, preserving context and channel thread continuity. Set `reuse_conversation: false` explicitly if each run should start with a fresh conversation (e.g. independent reports that shouldn't accumulate prior context). One-shot schedules always create a fresh conversation.
 
 - Only applies to **recurring** schedules; ignored for one-shot schedules.
 - If the prior conversation has been deleted, a new one is created automatically.

package/src/config/bundled-skills/schedule/TOOLS.json

@@ -62,7 +62,7 @@
           },
           "reuse_conversation": {
             "type": "boolean",
-            "description": "When true, reuse the same conversation across recurring schedule runs instead of creating a new one each time. Useful for polling-style schedules that accumulate context over time. Ignored for one-shot schedules. Defaults to false."
+            "description": "When true, reuse the same conversation across recurring schedule runs instead of creating a new one each time. Defaults to true for recurring schedules, false for one-shot. Set to false explicitly if each run should start fresh."
           },
           "max_retries": {
             "type": "integer",
@@ -161,7 +161,7 @@
           },
           "reuse_conversation": {
             "type": "boolean",
-            "description": "When true, reuse the same conversation across recurring schedule runs instead of creating a new one each time. Useful for polling-style schedules that accumulate context over time. Ignored for one-shot schedules."
+            "description": "When true, reuse the same conversation across recurring schedule runs instead of creating a new one each time. Defaults to true for recurring schedules. Set to false explicitly if each run should start fresh."
           },
           "max_retries": {
             "type": "integer",

package/src/config/bundled-skills/settings/tools/open-system-settings.ts

@@ -42,6 +42,7 @@ export async function run(
     context.sendToClient({
       type: "open_url",
       url: meta.url,
+      conversationId: context.conversationId,
     });
   }
 

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

@@ -23,7 +23,7 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   emptyStateGreeting: { profile: "balanced" },
 
   memoryRouter: {
-    profile: "balanced",
+    profile: "cost-optimized",
     contextWindow: { maxInputTokens: 1000000 },
   },
   recall: {

package/src/config/feature-flag-cache.ts

@@ -0,0 +1,86 @@
+/**
+ * Module-level cache for resolved feature flag override values.
+ *
+ * Lives in its own module (rather than alongside the resolver in
+ * `assistant-feature-flags.ts`) so test code can read/write the cache
+ * without going through `assistant-feature-flags.ts` — which transitively
+ * pulls `util/logger.js` (pino) and the gateway IPC client. Stdlib-only
+ * by design: this file must remain safe to import from the test
+ * preload's load-time chain, where a broken `node_modules` symlink has
+ * historically tripped the env override (see DB ghost #3,
+ * /workspace/journal/2026-05-25-db-ghost-3-recovery.md).
+ *
+ * State is held on `globalThis.vellumAssistant.featureFlagCache` so test
+ * helpers in `__tests__/` can read/write it WITHOUT importing this
+ * module — they declare the same slot shape locally and access the
+ * globalThis namespace directly. See
+ * `__tests__/feature-flag-test-helpers.ts` for the test-side mirror;
+ * the slot shape MUST stay in sync between the two.
+ *
+ * Both `overrides` and `fromGateway` were previously module-level `let`
+ * bindings inside `assistant-feature-flags.ts`. The semantics are
+ * preserved exactly: `overrides === null` means "no fetch has populated
+ * the cache yet"; `fromGateway === true` means "the cache is
+ * authoritative — `initFeatureFlagOverrides()` should not clobber it".
+ *
+ * Consumers:
+ *   - `assistant-feature-flags.ts` (resolver — reads/writes via gateway fetch)
+ *   - `__tests__/feature-flag-test-helpers.ts` (seeds for tests, via globalThis)
+ */
+
+type FlagSlot = {
+  overrides: Record<string, boolean> | null;
+  fromGateway: boolean;
+};
+
+type VellumAssistantNamespace = {
+  featureFlagCache?: FlagSlot;
+};
+
+function slot(): FlagSlot {
+  const g = globalThis as { vellumAssistant?: VellumAssistantNamespace };
+  const ns = (g.vellumAssistant ??= {});
+  return (ns.featureFlagCache ??= { overrides: null, fromGateway: false });
+}
+
+/** Read the current override cache. `null` means not yet populated. */
+export function getCachedOverrides(): Record<string, boolean> | null {
+  return slot().overrides;
+}
+
+/**
+ * True when the cache was populated by either a gateway IPC fetch or by a
+ * test helper. Used by `initFeatureFlagOverrides()` to short-circuit a
+ * second fetch (e.g. when a CLI entry point runs after the daemon has
+ * already initialized) and by tests to prevent the retry loop from
+ * clobbering preseeded state.
+ */
+export function isCachedFromGateway(): boolean {
+  return slot().fromGateway;
+}
+
+/**
+ * Replace the cache with a clone of `overrides`. The `fromGateway` flag
+ * is set by the caller — production callers pass `true` after a
+ * successful gateway fetch; test helpers also pass `true` so subsequent
+ * `initFeatureFlagOverrides()` calls are no-ops.
+ */
+export function setCachedOverrides(
+  overrides: Record<string, boolean>,
+  options: { fromGateway: boolean },
+): void {
+  const s = slot();
+  s.overrides = { ...overrides };
+  s.fromGateway = options.fromGateway;
+}
+
+/**
+ * Drop the cache. The next `loadOverrides()` returns an empty record (so
+ * flag checks fall through to registry defaults) and the next
+ * `initFeatureFlagOverrides()` re-fetches from the gateway.
+ */
+export function clearCachedOverrides(): void {
+  const s = slot();
+  s.overrides = null;
+  s.fromGateway = false;
+}

package/src/config/feature-flag-registry.json

@@ -25,6 +25,14 @@
       "description": "Enable user-hosted onboarding flow",
       "defaultEnabled": false
     },
+    {
+      "id": "prechat-onboarding-condensed-flow",
+      "scope": "client",
+      "key": "prechat-onboarding-condensed-flow",
+      "label": "Condensed Pre-chat Onboarding",
+      "description": "Enable the condensed pre-chat onboarding flow for a standard LaunchDarkly percentage rollout.",
+      "defaultEnabled": false
+    },
     {
       "id": "local-docker-enabled",
       "scope": "client",
@@ -190,7 +198,7 @@
       "scope": "assistant",
       "key": "fast-mode",
       "label": "Fast Mode",
-      "description": "Enable Anthropic fast mode for Opus models (4.6, 4.7), delivering up to 2.5x higher output tokens per second at premium pricing",
+      "description": "Enable Anthropic fast mode for Opus models (4.6, 4.7, 4.8), delivering up to 2.5x higher output tokens per second at premium pricing",
       "defaultEnabled": false
     },
     {
@@ -281,14 +289,6 @@
       "description": "Expose the developer-only Compaction Playground tab in macOS Settings and enable the /playground/* HTTP endpoints for exercising compaction conditions. Dev-only; default off.",
       "defaultEnabled": false
     },
-    {
-      "id": "safe-storage-limits",
-      "scope": "assistant",
-      "key": "safe-storage-limits",
-      "label": "Safe Storage Limits",
-      "description": "Enable disk pressure protection flows that block background work and remote actors while storage is critically low.",
-      "defaultEnabled": false
-    },
     {
       "id": "account-deletion",
       "scope": "assistant",
@@ -313,14 +313,6 @@
       "description": "Show the 'Analyze' / 'Analyze conversation' option in conversation context menus and the conversation title actions dropdown.",
       "defaultEnabled": false
     },
-    {
-      "id": "pro-plan-adjust",
-      "scope": "client",
-      "key": "pro-plan-adjust",
-      "label": "Pro Plan Adjust",
-      "description": "Show the rich Plan card (current plan, features, Manage/Upgrade CTA) at the top of the macOS Settings \u2192 Billing tab.",
-      "defaultEnabled": false
-    },
     {
       "id": "external-plugins",
       "scope": "assistant",
@@ -440,6 +432,14 @@
       "label": "Memory Router Playground",
       "description": "Expose the developer-only Memory Router Playground tab in macOS Settings and the /assistant/memory-router-playground web page for dry-running v4 router config overrides against the live page index. Dev-only; default off.",
       "defaultEnabled": false
+    },
+    {
+      "id": "platform-features-in-local-mode",
+      "scope": "assistant",
+      "key": "platform-features-in-local-mode",
+      "label": "Platform Features in Local Mode",
+      "description": "When enabled, the assistant can call the Vellum platform API from local mode. When disabled, all platform API clients in the daemon, gateway, CES, and web UI no-op with a debug log instead of making outbound requests.",
+      "defaultEnabled": true
     }
   ]
 }

package/src/config/llm-context-resolution.ts

@@ -27,12 +27,21 @@ export function resolveEffectiveContextWindow({
   llm,
   callSite,
   overrideProfile,
+  selectionSeed,
 }: {
   llm: LLMConfig;
   callSite: LLMCallSite;
   overrideProfile?: string;
+  /**
+   * Per-conversation mix seed (the conversation id). Threaded so context-window
+   * sizing for a mix profile reflects the same arm the dispatch path picks.
+   */
+  selectionSeed?: string;
 }): EffectiveContextWindow {
-  const resolved = resolveCallSiteConfig(callSite, llm, { overrideProfile });
+  const resolved = resolveCallSiteConfig(callSite, llm, {
+    overrideProfile,
+    selectionSeed,
+  });
   const catalogModel = PROVIDER_CATALOG.find(
     (provider) => provider.id === resolved.provider,
   )?.models.find((model) => model.id === resolved.model);

package/src/config/llm-resolver.ts

@@ -42,33 +42,60 @@ import {
  * resolver stays pure; schema validation in `LLMSchema.superRefine` catches
  * unknown `activeProfile` references at config-load time.
  *
- * Pure & synchronous: no I/O, no async work.
+ * A profile reference that points at a "mix" profile is expanded to one of its
+ * constituent profiles by a seeded weighted pick (see `resolveProfileFragment`
+ * and `opts.selectionSeed`). Expansion happens uniformly at every dereference
+ * spot, so a mix works as `activeProfile`, `overrideProfile`, or a call-site
+ * `profile`.
+ *
+ * Pure & synchronous: no I/O, no async work. (Random selection only occurs for
+ * mix profiles when no `selectionSeed` is supplied; with a seed the pick is
+ * deterministic.)
  */
+export interface ResolveCallSiteOpts {
+  overrideProfile?: string;
+  /**
+   * Per-conversation seed for expanding `mix` profiles. The chosen constituent
+   * is a deterministic function of `selectionSeed` + the mix profile's own
+   * name, so every `resolveCallSiteConfig` call for the same conversation picks
+   * the SAME arm (stable across turns, retries, and restarts). Pass the
+   * conversation id. When absent, the resolver falls back to a fresh random
+   * pick per call — acceptable only for one-shot/background call sites that
+   * resolve config exactly once per invocation.
+   */
+  selectionSeed?: string;
+  /**
+   * Invoked once for each mix profile the resolver expands, reporting which
+   * constituent was chosen. Used by A/B-eval recording (usage attribution).
+   */
+  onMixSelected?: (info: { mixProfile: string; chosenProfile: string }) => void;
+}
+
 export function resolveCallSiteConfig(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,
-  opts: { overrideProfile?: string } = {},
+  opts: ResolveCallSiteOpts = {},
 ): z.infer<typeof LLMConfigBase> {
   const layers: Mergeable[] = [llm.default as Mergeable];
 
-  const activeFragment =
-    llm.activeProfile != null ? llm.profiles?.[llm.activeProfile] : undefined;
-  const overrideFragment =
-    opts.overrideProfile != null
-      ? llm.profiles?.[opts.overrideProfile]
-      : undefined;
+  const activeFragment = resolveProfileFragment(llm.activeProfile, llm, opts);
+  const overrideFragment = resolveProfileFragment(
+    opts.overrideProfile,
+    llm,
+    opts,
+  );
   const site =
     llm.callSites?.[callSite] ??
     effectiveDefault(callSite, llm, opts.overrideProfile != null);
 
   if (callSite === "mainAgent") {
-    appendCallSiteLayers(layers, callSite, llm, site);
+    appendCallSiteLayers(layers, callSite, llm, site, opts);
     appendProfileLayer(layers, activeFragment);
     appendProfileLayer(layers, overrideFragment);
   } else {
     appendProfileLayer(layers, activeFragment);
     appendProfileLayer(layers, overrideFragment);
-    appendCallSiteLayers(layers, callSite, llm, site);
+    appendCallSiteLayers(layers, callSite, llm, site, opts);
   }
 
   return finalize(deepMerge(...layers.map(withImpliedProviderForKnownModel)));
@@ -80,6 +107,81 @@ export function resolveCallSiteConfig(
 
 type Mergeable = Record<string, unknown>;
 
+/**
+ * FNV-1a 32-bit string hash → unit float in [0, 1). Deterministic and stable
+ * across runtimes — the mix-pick contract depends on identical output for
+ * identical input forever, so the constants must never change. (Mirrors the
+ * private hash in `memory/v2/page-index.ts`; intentionally re-declared here so
+ * the resolver's determinism contract is self-contained and cannot be broken
+ * by an unrelated edit to that module.)
+ */
+function seededUnitFloat(seed: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  // `>>> 0` → unsigned 32-bit; divide by 2^32 to land in [0, 1).
+  return (h >>> 0) / 0x100000000;
+}
+
+/**
+ * Pick one entry from a weighted list given a unit float in [0, 1). Weights
+ * are relative and normalized by their sum. Assumes `entries` is non-empty
+ * with positive weights (guaranteed by `MixSchema`: `.min(2)` + positive).
+ */
+function weightedPick<T extends { weight: number }>(
+  entries: readonly T[],
+  unit: number,
+): T {
+  const total = entries.reduce((sum, e) => sum + e.weight, 0);
+  // Defensive: a degenerate total (unreachable post-schema) → first arm.
+  if (!(total > 0)) return entries[0];
+  let threshold = unit * total;
+  for (const entry of entries) {
+    threshold -= entry.weight;
+    if (threshold < 0) return entry;
+  }
+  // Floating-point fall-through (unit ≈ 1): return the last arm.
+  return entries[entries.length - 1];
+}
+
+/**
+ * Dereference a profile name to its concrete `ProfileEntry`, expanding a mix
+ * profile by a seeded weighted pick. Returns `undefined` when the name is
+ * unknown (parity with the silent fall-through callers already rely on).
+ *
+ * Mix expansion is one level only — `LLMSchema.superRefine` guarantees arms
+ * are standard (non-mix) profiles, so this never recurses unboundedly. A
+ * chosen arm pointing at a missing profile (only reachable in hand-crafted,
+ * unparsed configs) falls through to `undefined`.
+ *
+ * Pure & synchronous (the only impurity is `Math.random()` in the no-seed
+ * fallback path).
+ */
+function resolveProfileFragment(
+  name: string | undefined,
+  llm: z.infer<typeof LLMSchema>,
+  opts: ResolveCallSiteOpts,
+): ProfileEntry | undefined {
+  if (name == null) return undefined;
+  const entry = llm.profiles?.[name];
+  if (entry?.mix == null) return entry;
+
+  // Mix: pick one constituent. Seed by per-conversation seed + the mix's own
+  // name so two different mixes in the same conversation pick independently,
+  // but the same mix always resolves to the same arm within the conversation.
+  const unit =
+    opts.selectionSeed != null
+      ? seededUnitFloat(`${opts.selectionSeed}\u0000${name}`)
+      : Math.random();
+  const chosen = weightedPick(entry.mix, unit);
+  opts.onMixSelected?.({ mixProfile: name, chosenProfile: chosen.profile });
+
+  // The chosen arm must be a standard profile (enforced by superRefine).
+  return llm.profiles?.[chosen.profile];
+}
+
 /**
  * Returns the effective default profile key the resolver would actually
  * select for a call site when no per-turn `overrideProfile` is supplied.
@@ -170,16 +272,16 @@ function appendCallSiteLayers(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,
   site: z.infer<typeof LLMSchema>["callSites"][LLMCallSite] | undefined,
+  opts: ResolveCallSiteOpts,
 ): void {
   if (site != null) {
     if (site.profile != null) {
-      const profileFragment: ProfileEntry | undefined =
-        llm.profiles?.[site.profile];
+      const profileFragment = resolveProfileFragment(site.profile, llm, opts);
       if (profileFragment == null) {
         // Defensive: `LLMSchema.superRefine` already rejects unknown profile
-        // references at config load, so this branch is unreachable for any
-        // config that survived schema validation. Throw a clear error in case
-        // a hand-crafted (un-parsed) config slips through.
+        // references (and unknown mix arms) at config load, so this branch is
+        // unreachable for any config that survived schema validation. Throw a
+        // clear error in case a hand-crafted (un-parsed) config slips through.
         throw new Error(
           `LLM call site "${callSite}" references undefined profile "${site.profile}"`,
         );
@@ -198,6 +300,10 @@ function profileConfigFragment(profile: ProfileEntry): Mergeable {
     source: _source,
     label: _label,
     description: _description,
+    // `mix` never reaches here in practice (a mix expands to a standard
+    // profile before this point), but strip it defensively so it can never
+    // leak into the merged `LLMConfigBase`.
+    mix: _mix,
     ...config
   } = profile;
   return config as Mergeable;

package/src/config/loader.ts

@@ -122,6 +122,9 @@ export function getDeploymentContextDefaults(): Record<string, unknown> {
   if (process.env.IS_PLATFORM !== "true" && process.env.IS_PLATFORM !== "1") {
     return {};
   }
+  // `web-search.mode = managed` enables platform-backed app-executed search
+  // for non-native inference providers while preserving provider-native hosted
+  // search for providers/models that support it.
   const managed = { mode: "managed" as const };
   return {
     services: {
@@ -161,11 +164,7 @@ export function fillContextDefaultsForMissingKeys(
 ): void {
   for (const [key, value] of Object.entries(contextDefaults)) {
     const fileVal = fileConfig[key];
-    if (
-      value !== null &&
-      typeof value === "object" &&
-      !Array.isArray(value)
-    ) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
       const targetChild = readPlainObject(target[key]);
       const fileChild = readPlainObject(fileVal);
       if (targetChild) {

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

@@ -224,6 +224,7 @@ describe("MemoryV3ConfigSchema", () => {
       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,
@@ -272,6 +273,20 @@ describe("MemoryV3ConfigSchema", () => {
     expect(parsed.denseQuota).toEqual({ activeDomain: 50, offDomain: 12 });
   });
 
+  test("accepts a partial denseQuota override and defaults the rest", () => {
+    // Overriding only one leaf must merge with defaults, not fail validation
+    // (which would discard the entire user config).
+    const onlyActive = MemoryV3ConfigSchema.parse({
+      denseQuota: { activeDomain: 50 },
+    });
+    expect(onlyActive.denseQuota).toEqual({ activeDomain: 50, offDomain: 8 });
+
+    const onlyOff = MemoryV3ConfigSchema.parse({
+      denseQuota: { offDomain: 12 },
+    });
+    expect(onlyOff.denseQuota).toEqual({ activeDomain: 30, offDomain: 12 });
+  });
+
   test("accepts a partial lanes override and defaults the rest", () => {
     const parsed = MemoryV3ConfigSchema.parse({ lanes: { dense: false } });
     expect(parsed.lanes).toEqual({

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

@@ -309,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"),
@@ -344,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
@@ -379,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>;
 
@@ -444,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

@@ -466,11 +466,13 @@ export const MemoryV3ConfigSchema = 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.",
           ),
@@ -520,6 +522,29 @@ export const MemoryV3ConfigSchema = z
       .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])
@@ -597,6 +622,7 @@ export const MemoryV3ConfigSchema = z
     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,