@vellumai/assistant 0.8.5 → 0.8.7

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

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import { MemoryConfigSchema } from "../memory.js";
-import { MemoryV2ConfigSchema, MemoryV3ConfigSchema } from "../memory-v2.js";
+import { MemoryV2ConfigSchema } from "../memory-v2.js";
 
 describe("MemoryV2ConfigSchema", () => {
   test("parses an empty object to documented defaults", () => {
@@ -212,216 +212,6 @@ describe("MemoryV2ConfigSchema", () => {
   });
 });
 
-describe("MemoryV3ConfigSchema", () => {
-  test("parses an empty object to documented defaults", () => {
-    const parsed = MemoryV3ConfigSchema.parse({});
-    expect(parsed).toEqual({
-      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 },
-      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,
-    });
-  });
-
-  test("parses undefined to the same defaults (top-level .default)", () => {
-    expect(MemoryV3ConfigSchema.parse(undefined)).toEqual(
-      MemoryV3ConfigSchema.parse({}),
-    );
-  });
-
-  test("defaults to disabled for backwards compatibility", () => {
-    expect(MemoryV3ConfigSchema.parse({}).enabled).toBe(false);
-    expect(MemoryV3ConfigSchema.parse({}).shadow).toBe(false);
-  });
-
-  test("accepts explicit scalar overrides", () => {
-    const parsed = MemoryV3ConfigSchema.parse({
-      enabled: true,
-      shadow: true,
-      passCap: 5,
-      breadthBudget: 10,
-      maxDepth: 8,
-    });
-    expect(parsed.enabled).toBe(true);
-    expect(parsed.shadow).toBe(true);
-    expect(parsed.passCap).toBe(5);
-    expect(parsed.breadthBudget).toBe(10);
-    expect(parsed.maxDepth).toBe(8);
-  });
-
-  test("accepts explicit denseQuota override", () => {
-    const parsed = MemoryV3ConfigSchema.parse({
-      denseQuota: { activeDomain: 50, offDomain: 12 },
-    });
-    expect(parsed.denseQuota).toEqual({ activeDomain: 50, offDomain: 12 });
-  });
-
-  test("accepts a partial lanes override and defaults the rest", () => {
-    const parsed = MemoryV3ConfigSchema.parse({ lanes: { dense: false } });
-    expect(parsed.lanes).toEqual({
-      hot: true,
-      sparse: true,
-      dense: false,
-      tree: true,
-      edges: true,
-    });
-  });
-
-  test("accepts an explicit ks override", () => {
-    const parsed = MemoryV3ConfigSchema.parse({ ks: [1, 3, 7] });
-    expect(parsed.ks).toEqual([1, 3, 7]);
-  });
-
-  test("rejects a non-boolean enabled", () => {
-    expect(() => MemoryV3ConfigSchema.parse({ enabled: "yes" })).toThrow();
-  });
-
-  test("rejects a non-integer passCap", () => {
-    expect(() => MemoryV3ConfigSchema.parse({ passCap: 2.5 })).toThrow();
-  });
-
-  test("rejects non-number ks entries", () => {
-    expect(() => MemoryV3ConfigSchema.parse({ ks: ["a"] })).toThrow();
-  });
-
-  test("parses the write subtree to safe off defaults when omitted", () => {
-    const parsed = MemoryV3ConfigSchema.parse({});
-    expect(parsed.write).toEqual({
-      enabled: false,
-      consolidateIntervalMs: 3600000,
-      coactivation: false,
-    });
-  });
-
-  test("accepts a partial write override and defaults the rest", () => {
-    const parsed = MemoryV3ConfigSchema.parse({ write: { enabled: true } });
-    expect(parsed.write).toEqual({
-      enabled: true,
-      consolidateIntervalMs: 3600000,
-      coactivation: false,
-    });
-  });
-
-  test("rejects a non-integer write.consolidateIntervalMs", () => {
-    expect(() =>
-      MemoryV3ConfigSchema.parse({ write: { consolidateIntervalMs: 1.5 } }),
-    ).toThrow();
-  });
-
-  test("rejects a non-positive write.consolidateIntervalMs", () => {
-    // 0 or negative would make the scheduler's `now - lastRun >= interval`
-    // check always true, flooding the queue with consolidation jobs.
-    expect(() =>
-      MemoryV3ConfigSchema.parse({ write: { consolidateIntervalMs: 0 } }),
-    ).toThrow();
-    expect(() =>
-      MemoryV3ConfigSchema.parse({ write: { consolidateIntervalMs: -1000 } }),
-    ).toThrow();
-  });
-
-  test("accepts a positive write.consolidateIntervalMs override", () => {
-    const parsed = MemoryV3ConfigSchema.parse({
-      write: { consolidateIntervalMs: 1800000 },
-    });
-    expect(parsed.write.consolidateIntervalMs).toBe(1800000);
-  });
-
-  test("parses the prompts subtree to null overrides when omitted", () => {
-    const parsed = MemoryV3ConfigSchema.parse({});
-    expect(parsed.prompts).toEqual({
-      filter: { override: null, path: null },
-      descent: { override: null, path: null },
-      gate: { override: null, path: null },
-    });
-  });
-
-  test("accepts a partial prompts override and defaults the rest", () => {
-    const parsed = MemoryV3ConfigSchema.parse({
-      prompts: { filter: { override: "custom filter prompt" } },
-    });
-    expect(parsed.prompts.filter).toEqual({
-      override: "custom filter prompt",
-      path: null,
-    });
-    // Lanes not mentioned keep their null defaults.
-    expect(parsed.prompts.descent).toEqual({ override: null, path: null });
-    expect(parsed.prompts.gate).toEqual({ override: null, path: null });
-  });
-
-  test("accepts a file path override for a prompt lane", () => {
-    const parsed = MemoryV3ConfigSchema.parse({
-      prompts: { gate: { path: "~/prompts/v3-gate.md" } },
-    });
-    expect(parsed.prompts.gate).toEqual({
-      override: null,
-      path: "~/prompts/v3-gate.md",
-    });
-  });
-
-  test("rejects a non-string prompts override", () => {
-    expect(() =>
-      MemoryV3ConfigSchema.parse({ prompts: { filter: { override: 42 } } }),
-    ).toThrow();
-  });
-
-  test("rejects a non-string prompts path", () => {
-    expect(() =>
-      MemoryV3ConfigSchema.parse({ prompts: { descent: { path: 7 } } }),
-    ).toThrow();
-  });
-});
-
-describe("MemoryConfigSchema integration with v3 block", () => {
-  test("includes a v3 block defaulting to disabled when v3 is omitted", () => {
-    const parsed = MemoryConfigSchema.parse({});
-    expect(parsed.v3).toBeDefined();
-    expect(parsed.v3.enabled).toBe(false);
-    expect(parsed.v3.shadow).toBe(false);
-    expect(parsed.v3.passCap).toBe(3);
-    expect(parsed.v3.lanes.dense).toBe(true);
-    expect(parsed.v3.ks).toEqual([5, 10, 25, 50]);
-    expect(parsed.v3.write).toEqual({
-      enabled: false,
-      consolidateIntervalMs: 3600000,
-      coactivation: false,
-    });
-  });
-
-  test("leaves pre-existing configs (no v3 key) otherwise unchanged", () => {
-    // A config authored before v3 existed parses fine and its v2 block is
-    // untouched; the v3 block is purely additive.
-    const parsed = MemoryConfigSchema.parse({ v2: { top_k: 50 } });
-    expect(parsed.v2.top_k).toBe(50);
-    expect(parsed.v3.enabled).toBe(false);
-  });
-
-  test("propagates v3 overrides through MemoryConfigSchema", () => {
-    const parsed = MemoryConfigSchema.parse({
-      v3: { enabled: true, passCap: 4 },
-    });
-    expect(parsed.v3.enabled).toBe(true);
-    expect(parsed.v3.passCap).toBe(4);
-    // Non-overridden v3 fields keep their defaults.
-    expect(parsed.v3.maxDepth).toBe(6);
-  });
-});
-
 describe("MemoryConfigSchema integration with v2 block", () => {
   test("parses an empty memory config and includes a v2 block with defaults", () => {
     const parsed = MemoryConfigSchema.parse({});

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

@@ -121,25 +121,18 @@ 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",
+  memoryV3RouteL1: {
+    id: "memoryV3RouteL1",
+    displayName: "Memory V3 L1 Router",
     description:
-      "Cheaply filters the V3 multi-lane candidate set before descent.",
+      "Picks which leaves of the topic tree to open for the next agent turn by routing over a cache-warm static leaf block.",
     domain: "memory",
   },
-  memoryV3Descent: {
-    id: "memoryV3Descent",
-    displayName: "Memory V3 Descent",
+  memoryV3SelectL2: {
+    id: "memoryV3SelectL2",
+    displayName: "Memory V3 L2 Selector",
     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.",
+      "Selects which pages within an opened topic-tree leaf are relevant for the next agent turn, one bounded call per leaf over a cache-warm static page block.",
     domain: "memory",
   },
   memoryV2Consolidation: {

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,9 +49,8 @@ export const LLMCallSiteEnum = z.enum([
   "memoryV2Migration",
   "memoryV2Sweep",
   "memoryRouter",
-  "memoryV3Filter",
-  "memoryV3Descent",
-  "memoryV3Gate",
+  "memoryV3RouteL1",
+  "memoryV3SelectL2",
   "memoryV2Consolidation",
   "memoryRetrospective",
   "recall",
@@ -309,7 +308,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 +343,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 +399,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 +475,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-lifecycle.ts

@@ -165,6 +165,30 @@ export const MemoryCleanupConfigSchema = z
   })
   .describe("Automatic memory cleanup and garbage collection settings");
 
+export const MemoryMaintenanceConfigSchema = z
+  .object({
+    intervalMs: z
+      .number({ error: "memory.maintenance.intervalMs must be a number" })
+      .int("memory.maintenance.intervalMs must be an integer")
+      .positive("memory.maintenance.intervalMs must be a positive integer")
+      .default(24 * 60 * 60 * 1000)
+      .describe(
+        "Minimum interval between database maintenance (VACUUM / PRAGMA optimize) runs, in milliseconds",
+      ),
+    quietPeriodMs: z
+      .number({ error: "memory.maintenance.quietPeriodMs must be a number" })
+      .int("memory.maintenance.quietPeriodMs must be an integer")
+      .nonnegative("memory.maintenance.quietPeriodMs must be non-negative")
+      .default(3 * 60 * 60 * 1000)
+      .describe(
+        "Database maintenance is deferred unless at least this many milliseconds have elapsed since the last user message, so the VACUUM's exclusive lock never collides with an active user (0 disables the quiet-period gate)",
+      ),
+  })
+  .describe("Database maintenance (VACUUM / PRAGMA optimize) scheduling");
+
 export type MemoryJobsConfig = z.infer<typeof MemoryJobsConfigSchema>;
 export type MemoryRetentionConfig = z.infer<typeof MemoryRetentionConfigSchema>;
 export type MemoryCleanupConfig = z.infer<typeof MemoryCleanupConfigSchema>;
+export type MemoryMaintenanceConfig = z.infer<
+  typeof MemoryMaintenanceConfigSchema
+>;