@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/config/bundled-skills/messaging/tools/messaging-send.ts

@@ -238,8 +238,13 @@ export async function run(
             binding.conversationId,
             "assistant",
             JSON.stringify([{ type: "text", text }]),
-            { automated: true, crossPostedFrom: context.conversationId },
-            { skipIndexing: true },
+            {
+              metadata: {
+                automated: true,
+                crossPostedFrom: context.conversationId,
+              },
+              skipIndexing: true,
+            },
           );
           syncMessageToDisk(
             binding.conversationId,

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

@@ -94,7 +94,7 @@ The `mode` parameter controls what happens when a schedule fires:
 
 - **execute** (default) - sends the schedule's message to a background assistant conversation for autonomous handling. The assistant processes the message as if the user sent it.
 - **notify** - sends a notification to the user via the notification pipeline. No assistant processing occurs.
-- **script** - runs the `script` field as a shell command directly. No LLM invoked, no conversation created. stdout/stderr are captured in the schedule run record. Exit code 0 = success, non-zero = error. Commands run in the workspace directory with a 60-second timeout.
+- **script** - runs the `script` field as a shell command directly. No LLM invoked, no conversation created. stdout/stderr are captured in the schedule run record. Exit code 0 = success, non-zero = error. Commands run in the workspace directory with a 60-second timeout by default. Override the timeout per schedule with `timeout_ms` (range 1000–1800000 ms) when a script needs more or less time; pass `timeout_ms: null` on update to revert to the default. The guardian can also adjust this from the /assistant/settings/schedules page.
 
 Use `notify` for simple reminders ("remind me to take medicine at 9am"), `execute` for tasks that need assistant action ("check my calendar at 8am and send me a digest"), and `script` for lightweight shell automations that don't need LLM involvement ("refresh a cache", "poll an API", "rotate logs").
 

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

@@ -71,6 +71,10 @@
           "retry_backoff_ms": {
             "type": "integer",
             "description": "Base backoff delay in milliseconds between retries. Exponential backoff is applied. Defaults to 60000."
+          },
+          "timeout_ms": {
+            "type": "integer",
+            "description": "For script mode: maximum time in milliseconds the shell command may run before it is killed. Defaults to 60000 (60s). Allowed range: 1000 to 1800000."
           }
         },
         "required": ["name"]
@@ -170,6 +174,10 @@
           "retry_backoff_ms": {
             "type": "integer",
             "description": "Base backoff delay in milliseconds between retries. Exponential backoff is applied. Defaults to 60000."
+          },
+          "timeout_ms": {
+            "type": ["integer", "null"],
+            "description": "For script mode: maximum time in milliseconds the shell command may run before it is killed (default 60000, range 1000 to 1800000). Pass null to clear a custom timeout and revert to the default."
           }
         },
         "required": ["job_id"]

package/src/config/bundled-tool-registry.ts

@@ -23,6 +23,7 @@ import * as acpSteer from "./bundled-skills/acp/tools/acp-steer.js";
 import * as appCreate from "./bundled-skills/app-builder/tools/app-create.js";
 import * as appDelete from "./bundled-skills/app-builder/tools/app-delete.js";
 import * as appGenerateIcon from "./bundled-skills/app-builder/tools/app-generate-icon.js";
+import * as appList from "./bundled-skills/app-builder/tools/app-list.js";
 import * as appRefresh from "./bundled-skills/app-builder/tools/app-refresh.js";
 // ── app-control ────────────────────────────────────────────────────────────────
 import * as appControlClick from "./bundled-skills/app-control/tools/app-control-click.js";
@@ -142,6 +143,7 @@ export const bundledToolRegistry = new Map<string, SkillToolScript>([
   ["app-builder:tools/app-delete.ts", appDelete],
   ["app-builder:tools/app-refresh.ts", appRefresh],
   ["app-builder:tools/app-generate-icon.ts", appGenerateIcon],
+  ["app-builder:tools/app-list.ts", appList],
 
   // app-control
   ["app-control:tools/app-control-start.ts", appControlStart],

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

@@ -26,6 +26,8 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     profile: "cost-optimized",
     contextWindow: { maxInputTokens: 1000000 },
   },
+  memoryV3RouteL1: { profile: "balanced", temperature: 0 },
+  memoryV3SelectL2: { profile: "balanced", temperature: 0 },
   recall: {
     profile: "balanced",
     maxTokens: 4096,
@@ -47,13 +49,6 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   memoryV2Migration: { profile: "cost-optimized" },
   memoryV2Sweep: { profile: "cost-optimized" },
   memoryV2Consolidation: { profile: "balanced" },
-  // memory v3: cheap filter + descent, capable gate. All three are
-  // selection/classification calls, not generation — pin temperature to 0 so
-  // the same candidate set yields the same keep/descend/select decision instead
-  // of sampling-driven variance.
-  memoryV3Filter: { profile: "cost-optimized", temperature: 0 },
-  memoryV3Descent: { profile: "cost-optimized", temperature: 0 },
-  memoryV3Gate: { profile: "balanced", temperature: 0 },
   conversationSummarization: { profile: "cost-optimized" },
   conversationTitle: { profile: "cost-optimized" },
   approvalCopy: { profile: "cost-optimized" },

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

@@ -29,7 +29,7 @@
  */
 
 type FlagSlot = {
-  overrides: Record<string, boolean> | null;
+  overrides: Record<string, boolean | string> | null;
   fromGateway: boolean;
 };
 
@@ -44,7 +44,7 @@ function slot(): FlagSlot {
 }
 
 /** Read the current override cache. `null` means not yet populated. */
-export function getCachedOverrides(): Record<string, boolean> | null {
+export function getCachedOverrides(): Record<string, boolean | string> | null {
   return slot().overrides;
 }
 
@@ -66,7 +66,7 @@ export function isCachedFromGateway(): boolean {
  * `initFeatureFlagOverrides()` calls are no-ops.
  */
 export function setCachedOverrides(
-  overrides: Record<string, boolean>,
+  overrides: Record<string, boolean | string>,
   options: { fromGateway: boolean },
 ): void {
   const s = slot();

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

@@ -26,11 +26,19 @@
       "defaultEnabled": false
     },
     {
-      "id": "prechat-onboarding-condensed-flow",
+      "id": "pre-chat-onboarding-experiment-2026-06-06",
       "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.",
+      "key": "pre-chat-onboarding-experiment-2026-06-06",
+      "label": "Pre-chat Onboarding Experiment 2026-06-06",
+      "description": "Pre-chat onboarding experiment with control and variant-a arms. Control shows the full funnel; variant-a shows the condensed pared-down flow.",
+      "defaultEnabled": "control"
+    },
+    {
+      "id": "experiment-activation-flow-2026-06-03",
+      "scope": "client",
+      "key": "experiment-activation-flow-2026-06-03",
+      "label": "Activation Flow Experiment 2026-06-03",
+      "description": "Route allowlisted users to the activation-rail bootstrap template after pre-chat. Off by default and targeted through LaunchDarkly.",
       "defaultEnabled": false
     },
     {
@@ -49,14 +57,6 @@
       "description": "Enable the A2A (Agent-to-Agent) channel for inter-assistant communication via the open A2A protocol",
       "defaultEnabled": false
     },
-    {
-      "id": "email-channel",
-      "scope": "assistant",
-      "key": "email-channel",
-      "label": "Email Channel",
-      "description": "Enable the entire email integration: email CLI commands, email channel, domain registration, sequences, email readiness probes, invite adapters, and the email-setup skill",
-      "defaultEnabled": false
-    },
     {
       "id": "settings-developer-nav",
       "scope": "assistant",
@@ -65,6 +65,14 @@
       "description": "Control Developer nav visibility in macOS settings",
       "defaultEnabled": false
     },
+    {
+      "id": "system-schedule-toggles",
+      "scope": "assistant",
+      "key": "system-schedule-toggles",
+      "label": "System Schedule Toggles",
+      "description": "Show Heartbeat and Consolidation pause toggles on the schedules settings page. The toggles only pause automatic runs; manual Run now remains available.",
+      "defaultEnabled": false
+    },
     {
       "id": "developer-menu-items",
       "scope": "client",
@@ -440,6 +448,54 @@
       "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
+    },
+    {
+      "id": "memory-v3-shadow",
+      "scope": "assistant",
+      "key": "memory-v3-shadow",
+      "label": "Memory v3 Shadow",
+      "description": "When on, runs the new memory-v3 topic-tree retrieval alongside v2 in shadow mode: logs selections to memory_v3_selections, does not modify injected context. Off by default.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "memory-v3-live",
+      "scope": "assistant",
+      "key": "memory-v3-live",
+      "label": "Memory v3 Live",
+      "description": "When on, memory-v3 topic-tree retrieval becomes the live injected memory source (suppressing v2 injection). Off by default; only enable after shadow telemetry validates the design.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "empty-state-dynamic-greetings",
+      "scope": "assistant",
+      "key": "empty-state-dynamic-greetings",
+      "label": "Dynamic Empty-State Greetings",
+      "description": "Enable the empty new-chat screen to refresh cached greeting options via the empty-state greeting LLM call site. When off, the assistant serves workspace-authored greetings or static fallbacks only.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "self-intro-greeting",
+      "scope": "both",
+      "key": "self-intro-greeting",
+      "label": "Self-intro first message",
+      "description": "On the first conversation, send a natural self-introduction (e.g. \"Hi Vela, I'm alex. Nice to meet you.\") on the user's behalf and route it through real LLM inference, instead of serving the canned first greeting. Names come from the onboarding context; falls back to the canned greeting when no name is known. Exposed to clients so pre-hatch onboarding can compute the source-of-truth initial message, and to the assistant so older clients can still be gated server-side. See assistant/src/daemon/first-greeting.ts (buildSelfIntroMessage).",
+      "defaultEnabled": false
+    },
+    {
+      "id": "provider-first-profile-creation",
+      "scope": "client",
+      "key": "provider-first-profile-creation",
+      "label": "Provider-First Profile Creation",
+      "description": "New profile creation flow: pick (or inline-create) a provider first, then a model, with pre-filled provider and profile name/key, plus a quick-add \"+\" in the chat composer's Model Profile menu. When off, profile creation uses the previous field order and there is no composer quick-add.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "acp",
+      "scope": "assistant",
+      "key": "acp",
+      "label": "ACP Coding Agents",
+      "description": "Enable spawning and steering external coding agents (Claude Code, Codex, Gemini) via the Agent Client Protocol. Alternative gate to the acp.enabled workspace config field; either enables the subsystem.",
+      "defaultEnabled": false
     }
   ]
 }

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", () => {
@@ -23,6 +23,7 @@ describe("MemoryV2ConfigSchema", () => {
       bm25_k1: 1.2,
       bm25_b: 0.4,
       consolidation_interval_hours: 4,
+      consolidation_enabled: true,
       consolidation_max_buffer_lines: 100,
       max_page_chars: 5000,
       consolidation_prompt_path: null,
@@ -212,231 +213,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 },
-      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,
-    });
-  });
-
-  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 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({
-      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/__tests__/memory-v3.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+
+import { MemoryV3ConfigSchema } from "../memory-v3.js";
+
+describe("MemoryV3ConfigSchema", () => {
+  test("parses an empty object to documented defaults", () => {
+    const parsed = MemoryV3ConfigSchema.parse({});
+    expect(parsed).toEqual({
+      workingSet: { maxPages: 150, evictWindow: 5 },
+      l2Concurrency: 16,
+    });
+  });
+
+  test("accepts an explicit l2Concurrency override", () => {
+    expect(MemoryV3ConfigSchema.parse({ l2Concurrency: 8 }).l2Concurrency).toBe(
+      8,
+    );
+  });
+
+  test("rejects a non-positive or non-integer l2Concurrency", () => {
+    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: 0 })).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: -4 })).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: 1.5 })).toThrow();
+  });
+});

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

@@ -56,6 +56,15 @@ export const HeartbeatConfigSchema = z
       .describe(
         "Maximum heartbeats that can run consecutively without a guardian message. Counter resets when the guardian sends a message. Set to null for unlimited.",
       ),
+    maxDailyRuns: z
+      .number({ error: "heartbeat.maxDailyRuns must be a number" })
+      .int("heartbeat.maxDailyRuns must be an integer")
+      .positive("heartbeat.maxDailyRuns must be a positive integer")
+      .nullable()
+      .default(2)
+      .describe(
+        "Maximum heartbeats that can run per calendar day. Resets at midnight local time. Set to null for unlimited.",
+      ),
     disposition: z
       .string({ error: "heartbeat.disposition must be a string" })
       .default(

package/src/config/schemas/llm.ts

@@ -21,6 +21,7 @@ const LLMProvider = z.enum([
   "fireworks",
   "openrouter",
   "openai-compatible",
+  "minimax",
 ]);
 type LLMProvider = z.infer<typeof LLMProvider>;
 
@@ -49,9 +50,8 @@ export const LLMCallSiteEnum = z.enum([
   "memoryV2Migration",
   "memoryV2Sweep",
   "memoryRouter",
-  "memoryV3Filter",
-  "memoryV3Descent",
-  "memoryV3Gate",
+  "memoryV3RouteL1",
+  "memoryV3SelectL2",
   "memoryV2Consolidation",
   "memoryRetrospective",
   "recall",

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
+>;