@vellumai/assistant 0.8.6 → 0.8.7

package/src/cli/lib/cli-colors.ts

@@ -1,12 +1,30 @@
 /**
- * Minimal ANSI red wrapper for CLI error output. Respects `NO_COLOR`
- * (https://no-color.org/) and skips coloring when stderr is not a TTY so
- * piped/captured output stays clean.
+ * Minimal ANSI color wrappers for CLI output. Each helper respects `NO_COLOR`
+ * (https://no-color.org/) and skips coloring when the relevant stream is not
+ * a TTY so piped/captured output stays clean.
+ *
+ * `red` / `green` gate on stderr (error/success lines tend to land there in
+ * the existing commands), `dim` gates on stdout (used for muted body text).
  */
+
+function colorsDisabled(): boolean {
+  return process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== "";
+}
+
 export function red(text: string): string {
   if (!process.stderr.isTTY) return text;
-  if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== "") {
-    return text;
-  }
+  if (colorsDisabled()) return text;
   return `\x1b[31m${text}\x1b[0m`;
 }
+
+export function green(text: string): string {
+  if (!process.stderr.isTTY) return text;
+  if (colorsDisabled()) return text;
+  return `\x1b[32m${text}\x1b[0m`;
+}
+
+export function dim(text: string): string {
+  if (!process.stdout.isTTY) return text;
+  if (colorsDisabled()) return text;
+  return `\x1b[2m${text}\x1b[0m`;
+}

package/src/cli/program.ts

@@ -4,7 +4,6 @@ import { Command } from "commander";
 
 import { initFeatureFlagOverrides } from "../config/assistant-feature-flags.js";
 import { getConfigReadOnly } from "../config/loader.js";
-import { isEmailEnabled } from "../email/feature-gate.js";
 import { isExternalPluginsEnabled } from "../plugins/feature-gate.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import { APP_VERSION } from "../version.js";
@@ -26,6 +25,7 @@ import { registerContactsCommand } from "./commands/contacts.js";
 import { registerConversationsCommand } from "./commands/conversations.js";
 import { registerCredentialExecutionCommand } from "./commands/credential-execution.js";
 import { registerCredentialsCommand } from "./commands/credentials.js";
+import { registerDbCommand } from "./commands/db/index.js";
 import { registerDefaultAction } from "./commands/default-action.js";
 import { registerDomainCommand } from "./commands/domain.js";
 import { registerEmailCommand } from "./commands/email.js";
@@ -122,10 +122,9 @@ Examples:
   registerConversationsCommand(program);
   registerCredentialExecutionCommand(program);
   registerCredentialsCommand(program);
-  if (isEmailEnabled(getConfigReadOnly())) {
-    registerDomainCommand(program);
-    registerEmailCommand(program);
-  }
+  registerDbCommand(program);
+  registerDomainCommand(program);
+  registerEmailCommand(program);
   registerGatewayCommand(program);
   registerImageGenerationCommand(program);
   registerInferenceCommand(program);

package/src/config/__tests__/feature-flag-registry-guard.test.ts

@@ -31,7 +31,7 @@ function loadRegistry(): Record<string, unknown> {
   return JSON.parse(raw);
 }
 
-const VALID_SCOPES = new Set(["assistant", "client"]);
+const VALID_SCOPES = new Set(["assistant", "client", "both"]);
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -169,7 +169,7 @@ describe("unified feature flag registry guard", () => {
       const scope = flag.scope as string;
       if (!VALID_SCOPES.has(scope)) {
         violations.push(
-          `flag '${flag.id}' has invalid scope '${scope}' (expected 'assistant' or 'client')`,
+          `flag '${flag.id}' has invalid scope '${scope}' (expected 'assistant', 'client', or 'both')`,
         );
       }
     }

package/src/config/assistant-feature-flags.ts

@@ -89,7 +89,7 @@ function loadDefaultsRegistry(): FeatureFlagDefaultsRegistry {
 
 /**
  * Parse the unified registry JSON into a flat key -> default map,
- * filtering to assistant-scope flags only.
+ * filtering to flags the backend consumes (`assistant`- and `both`-scope).
  */
 function parseRegistryToDefaults(parsed: unknown): FeatureFlagDefaultsRegistry {
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
@@ -101,7 +101,7 @@ function parseRegistryToDefaults(parsed: unknown): FeatureFlagDefaultsRegistry {
   for (const flag of registry.flags) {
     if (!flag || typeof flag !== "object" || Array.isArray(flag)) continue;
     const entry = flag as Record<string, unknown>;
-    if (entry.scope !== "assistant") continue;
+    if (entry.scope !== "assistant" && entry.scope !== "both") continue;
     if (typeof entry.key !== "string") continue;
     if (typeof entry.defaultEnabled !== "boolean") continue;
 

package/src/config/bundled-skills/app-builder/SKILL.md

@@ -135,13 +135,24 @@ assistant config get llm.activeProfile
 
 If the profile is already `quality-optimized`, skip the rest of this step and proceed to Step 1.
 
-**If the active profile is `balanced`, `cost-optimized`, or any non-quality profile, you MUST ask the user for permission before switching. Do NOT open an inference session without explicit user confirmation.** Use `assistant ui confirm`:
+**If the active profile is `balanced`, `cost-optimized`, or any non-quality profile, you MUST ask the user for permission before switching. Do NOT open an inference session without explicit user confirmation.** Use the `ui_show` tool to present an inline `confirmation` surface and wait for the action. Do not call the shell command `assistant ui confirm`; that CLI-mediated confirmation can block the build flow before the app work starts.
 
 ```
-assistant ui confirm --message "App building works best with a high-quality model — it makes better design decisions, writes cleaner components, and produces more visually polished results. Switch to the quality profile for this build? (You can switch back after.)"
+ui_show({
+  surface_type: "confirmation",
+  title: "Use quality model for this app?",
+  data: {
+    message: "The current model profile is `<profile>`. App building works best with `quality-optimized` because it makes better design decisions, writes cleaner components, and produces more visually polished results.",
+    detail: "Choose whether to switch for this build or keep the current profile and build now.",
+    confirmLabel: "Switch for this build",
+    cancelLabel: "Keep current profile"
+  },
+  display: "inline",
+  await_action: true
+})
 ```
 
-If `assistant ui confirm` isn't available on this binary, ask the user directly in conversation instead. **Either way, wait for the user's answer before proceeding.**
+If `ui_show` is unavailable or the current channel cannot render confirmation surfaces, ask the user directly in conversation as a fallback. Wait for the user's answer before proceeding.
 
 **Only if the user confirms**, open an inference session:
 

package/src/config/bundled-skills/media-processing/services/reduce.ts

@@ -195,15 +195,12 @@ async function sendToClaude(
   const { signal, cleanup } = createTimeout(REDUCE_TIMEOUT_MS);
 
   try {
-    const response = await provider.sendMessage(
-      [userMessage(userContent)],
-      [],
-      effectiveSystemPrompt,
-      {
-        config: model ? { model } : {},
-        signal,
-      },
-    );
+    const response = await provider.sendMessage([userMessage(userContent)], {
+      tools: [],
+      systemPrompt: effectiveSystemPrompt,
+      config: model ? { model } : {},
+      signal,
+    });
     cleanup();
 
     const answer = extractAllText(response);

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/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-registry.json

@@ -49,14 +49,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",
@@ -371,7 +363,7 @@
     },
     {
       "id": "home-page",
-      "scope": "client",
+      "scope": "both",
       "key": "home-page",
       "label": "Home Page",
       "description": "Enable the Home page as the default landing view.",
@@ -440,6 +432,30 @@
       "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": "self-intro-greeting",
+      "scope": "assistant",
+      "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. See assistant/src/daemon/first-greeting.ts (buildSelfIntroMessage).",
+      "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", () => {
@@ -212,231 +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 },
-      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/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/llm.ts

@@ -49,9 +49,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
+>;