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

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

@@ -194,6 +194,14 @@ export const MemoryV2ConfigSchema = z
       .describe(
         "Hours between scheduled consolidation runs that synthesize buffered memories into concept pages",
       ),
+    consolidation_enabled: z
+      .boolean({
+        error: "memory.v2.consolidation_enabled must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Whether automatic scheduled consolidation runs are enabled. Manual run-now requests remain available while memory.v2.enabled is true.",
+      ),
     consolidation_max_buffer_lines: z
       .number({
         error: "memory.v2.consolidation_max_buffer_lines must be a number",
@@ -388,230 +396,3 @@ export const MemoryV2ConfigSchema = z
   });
 
 export type MemoryV2Config = z.infer<typeof MemoryV2ConfigSchema>;
-
-/**
- * Per-lane system-prompt override for a v3 LLM call site. `override` is an
- * inline prompt string (highest precedence); `path` points at a file whose
- * contents replace the bundled prompt. Both default to `null` (use the bundled
- * prompt). Shared by the filter, descent, and gate entries under
- * `memory.v3.prompts`. The whole object is `.default(...)`-wrapped so an
- * omitted lane parses to `{ override: null, path: null }`.
- */
-const V3PromptOverrideSchema = z
-  .object({
-    override: z
-      .string({ error: "memory.v3.prompts.*.override must be a string" })
-      .nullable()
-      .default(null)
-      .describe(
-        "Optional inline system-prompt string that replaces the bundled prompt for this lane. Takes precedence over `path`. An empty or whitespace-only string is ignored (falls back to `path` / bundled).",
-      ),
-    path: z
-      .string({ error: "memory.v3.prompts.*.path must be a string" })
-      .nullable()
-      .default(null)
-      .describe(
-        "Optional path to a file whose contents replace the bundled prompt for this lane. Absolute paths are used as-is, a leading `~/` expands to the home directory, otherwise the path resolves under the workspace root. If the file is missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
-      ),
-  })
-  .default({ override: null, path: null });
-
-/**
- * Memory v3 (multi-lane, bounded-descent retrieval) configuration.
- *
- * Additive scaffolding only — defaults to `enabled: false` so existing
- * configs are untouched and the v3 retrieval loop stays inert until later
- * PRs wire it up. Every field carries a default and the whole block is
- * `.default(...)`-wrapped so a config that omits `memory.v3` entirely still
- * parses to these documented defaults.
- */
-export const MemoryV3ConfigSchema = z
-  .object({
-    enabled: z
-      .boolean({ error: "memory.v3.enabled must be a boolean" })
-      .default(false)
-      .describe(
-        "Whether the v3 memory subsystem (multi-lane bounded-descent retrieval) is enabled. Off by default until the v3 loop is wired up.",
-      ),
-    shadow: z
-      .boolean({ error: "memory.v3.shadow must be a boolean" })
-      .default(false)
-      .describe(
-        "Live-shadow toggle: when on, the v3 retrieval loop runs alongside the active path for comparison without affecting injected context. Consumed by a later PR.",
-      ),
-    passCap: z
-      .number({ error: "memory.v3.passCap must be a number" })
-      .int("memory.v3.passCap must be an integer")
-      .default(3)
-      .describe(
-        "Maximum number of retrieval passes (router → descent rounds) the v3 loop may run per turn.",
-      ),
-    breadthBudget: z
-      .number({ error: "memory.v3.breadthBudget must be a number" })
-      .int("memory.v3.breadthBudget must be an integer")
-      .default(6)
-      .describe(
-        "Per-pass breadth budget — the number of frontier candidates the v3 loop may expand at each step.",
-      ),
-    maxDepth: z
-      .number({ error: "memory.v3.maxDepth must be a number" })
-      .int("memory.v3.maxDepth must be an integer")
-      .default(6)
-      .describe(
-        "Maximum descent depth the v3 loop traverses through the memory tree before stopping.",
-      ),
-    denseQuota: z
-      .object({
-        activeDomain: z
-          .number({
-            error: "memory.v3.denseQuota.activeDomain must be a number",
-          })
-          .describe(
-            "Dense-lane candidate quota allocated to the conversation's active domain.",
-          ),
-        offDomain: z
-          .number({ error: "memory.v3.denseQuota.offDomain must be a number" })
-          .describe(
-            "Dense-lane candidate quota allocated to off-domain (exploratory) retrieval.",
-          ),
-      })
-      .default({ activeDomain: 30, offDomain: 8 })
-      .describe(
-        "Dense-lane candidate quotas split between the active domain and off-domain exploration.",
-      ),
-    hotLimit: z
-      .number({ error: "memory.v3.hotLimit must be a number" })
-      .int("memory.v3.hotLimit must be an integer")
-      .positive("memory.v3.hotLimit must be positive")
-      .default(50)
-      .describe(
-        "Top-N cap on the hot scout lane, ranked by injection-frequency EMA. Hot hits are sticky (kept past the gate), so this bounds how many always-on pages the lane forces into the selection. Without a cap a mature corpus — where nearly every page has been injected at some point — surfaces the entire corpus.",
-      ),
-    lanes: z
-      .object({
-        hot: z
-          .boolean()
-          .default(true)
-          .describe("Whether the hot (recently-touched) retrieval lane is on."),
-        sparse: z
-          .boolean()
-          .default(true)
-          .describe("Whether the sparse (BM25-style keyword) lane is on."),
-        dense: z
-          .boolean()
-          .default(true)
-          .describe("Whether the dense (embedding-similarity) lane is on."),
-        tree: z
-          .boolean()
-          .default(true)
-          .describe("Whether the tree (hierarchical descent) lane is on."),
-        edges: z
-          .boolean()
-          .default(true)
-          .describe("Whether the edges (graph-adjacency) lane is on."),
-      })
-      .default({
-        hot: true,
-        sparse: true,
-        dense: true,
-        tree: true,
-        edges: true,
-      })
-      .describe(
-        "Per-lane on/off toggles for the v3 multi-lane retrieval fanout. All lanes on by default.",
-      ),
-    ks: z
-      .array(z.number({ error: "memory.v3.ks entries must be numbers" }))
-      .default([5, 10, 25, 50])
-      .describe(
-        "Evaluation top-K cutoffs the v3 loop reports metrics at (e.g. recall@K).",
-      ),
-    write: z
-      .object({
-        enabled: z
-          .boolean({ error: "memory.v3.write.enabled must be a boolean" })
-          .default(false)
-          .describe(
-            "Whether v3 consolidation owns the shared-buffer drain + tree build. Off by default — v2 consolidation stays the sole buffer-drainer. Does NOT introduce a separate buffer.",
-          ),
-        consolidateIntervalMs: z
-          .number({
-            error: "memory.v3.write.consolidateIntervalMs must be a number",
-          })
-          .int("memory.v3.write.consolidateIntervalMs must be an integer")
-          .positive("memory.v3.write.consolidateIntervalMs must be positive")
-          .default(3600000)
-          .describe(
-            "Interval, in milliseconds, between scheduled v3 consolidation runs once the v3 write path owns the drain. Default 1 hour.",
-          ),
-        coactivation: z
-          .boolean({ error: "memory.v3.write.coactivation must be a boolean" })
-          .default(false)
-          .describe(
-            "Whether v3 consolidation learns co-activation edges during the tree build. Off by default; consumed by a later PR.",
-          ),
-      })
-      .default({
-        enabled: false,
-        consolidateIntervalMs: 3600000,
-        coactivation: false,
-      })
-      .describe(
-        "Memory v3 write-path configuration. All default-off scaffolding — controls whether v3 consolidation owns the shared-buffer drain + tree build. Consumed by later PRs.",
-      ),
-    prompts: z
-      .object({
-        filter: V3PromptOverrideSchema.describe(
-          "Override for the dense-hit filter lane's system prompt.",
-        ),
-        descent: V3PromptOverrideSchema.describe(
-          "Override for the tree-walk descent driver's system prompt.",
-        ),
-        gate: V3PromptOverrideSchema.describe(
-          "Override for the selection gate's system prompt.",
-        ),
-      })
-      .default({
-        filter: { override: null, path: null },
-        descent: { override: null, path: null },
-        gate: { override: null, path: null },
-      })
-      .describe(
-        "Per-lane system-prompt overrides for the three v3 LLM call sites (filter, descent, gate). Each entry takes an inline `override` string (highest precedence) and/or a file `path` whose contents replace the bundled prompt; absolute paths are used as-is, a leading `~/` expands to the home directory, otherwise the path resolves under the workspace root. An empty/whitespace inline override or a missing/unreadable/empty file falls back to the bundled prompt. Lets the prompts be iterated at runtime without a rebuild/restart — mirroring `memory.v2.router.router_prompt_path`.",
-      ),
-    gateCandidateSummaries: z
-      .boolean({
-        error: "memory.v3.gateCandidateSummaries must be a boolean",
-      })
-      .default(false)
-      .describe(
-        "When true, the selection gate sees each candidate as `slug — summary` instead of the bare slug, so it can judge relevance on page content. Off by default: with the bundled (precision-leaning) gate prompt this makes the gate more selective. It pays off paired with a recall-leaning gate prompt override, where the summaries let the gate recognize non-obvious associative/emotional matches it would otherwise pass over. Adds the candidate summaries to the gate prompt (larger input).",
-      ),
-  })
-  .default({
-    enabled: false,
-    shadow: false,
-    passCap: 3,
-    breadthBudget: 6,
-    maxDepth: 6,
-    denseQuota: { activeDomain: 30, offDomain: 8 },
-    hotLimit: 50,
-    lanes: { hot: true, sparse: true, dense: true, tree: true, edges: true },
-    ks: [5, 10, 25, 50],
-    write: {
-      enabled: false,
-      consolidateIntervalMs: 3600000,
-      coactivation: false,
-    },
-    prompts: {
-      filter: { override: null, path: null },
-      descent: { override: null, path: null },
-      gate: { override: null, path: null },
-    },
-    gateCandidateSummaries: false,
-  })
-  .describe(
-    "Memory v3 — multi-lane bounded-descent retrieval. Additive scaffolding, disabled by default.",
-  );
-
-export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

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

@@ -0,0 +1,47 @@
+import { z } from "zod";
+
+/**
+ * Memory v3 (topic-tree routing) working-set configuration.
+ *
+ * The working set is the per-conversation set of concept pages carried
+ * forward across turns. Eviction keeps it bounded: pages unseen for longer
+ * than `evictWindow` turns are dropped, and the set is capped at `maxPages`.
+ */
+export const MemoryV3WorkingSetSchema = z
+  .object({
+    maxPages: z
+      .number({ error: "memory.v3.workingSet.maxPages must be a number" })
+      .int("memory.v3.workingSet.maxPages must be an integer")
+      .positive("memory.v3.workingSet.maxPages must be a positive integer")
+      .default(150)
+      .describe(
+        "Upper bound on the number of pages retained in the working set. Once exceeded, the least-salient non-pinned pages are evicted until the set fits.",
+      ),
+    evictWindow: z
+      .number({ error: "memory.v3.workingSet.evictWindow must be a number" })
+      .int("memory.v3.workingSet.evictWindow must be an integer")
+      .positive("memory.v3.workingSet.evictWindow must be a positive integer")
+      .default(5)
+      .describe(
+        "Number of turns a non-pinned page may go unseen before it is evicted from the working set.",
+      ),
+  })
+  .describe("Memory v3 working-set retention/eviction tuning.");
+
+export const MemoryV3ConfigSchema = z
+  .object({
+    workingSet: MemoryV3WorkingSetSchema.default(
+      MemoryV3WorkingSetSchema.parse({}),
+    ),
+    l2Concurrency: z
+      .number({ error: "memory.v3.l2Concurrency must be a number" })
+      .int("memory.v3.l2Concurrency must be an integer")
+      .positive("memory.v3.l2Concurrency must be a positive integer")
+      .default(16)
+      .describe(
+        "Bounded fan-out for the per-leaf L2 selection (number of leaf selector calls in flight at once).",
+      ),
+  })
+  .describe("Memory v3 — topic-tree routing with a carry-forward working set");
+
+export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

package/src/config/schemas/memory.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import {
   MemoryCleanupConfigSchema,
   MemoryJobsConfigSchema,
+  MemoryMaintenanceConfigSchema,
   MemoryRetentionConfigSchema,
 } from "./memory-lifecycle.js";
 import {
@@ -16,7 +17,8 @@ import {
   MemorySegmentationConfigSchema,
   QdrantConfigSchema,
 } from "./memory-storage.js";
-import { MemoryV2ConfigSchema, MemoryV3ConfigSchema } from "./memory-v2.js";
+import { MemoryV2ConfigSchema } from "./memory-v2.js";
+import { MemoryV3ConfigSchema } from "./memory-v3.js";
 
 export const MemoryConfigSchema = z
   .object({
@@ -43,6 +45,9 @@ export const MemoryConfigSchema = z
     cleanup: MemoryCleanupConfigSchema.default(
       MemoryCleanupConfigSchema.parse({}),
     ),
+    maintenance: MemoryMaintenanceConfigSchema.default(
+      MemoryMaintenanceConfigSchema.parse({}),
+    ),
     extraction: MemoryExtractionConfigSchema.default(
       MemoryExtractionConfigSchema.parse({}),
     ),

package/src/config/schemas/platform.ts

@@ -87,6 +87,14 @@ export const DaemonConfigSchema = z
       .describe(
         "Whether the daemon records conversations even when no client is connected",
       ),
+    reapOrphanedSubprocesses: z
+      .boolean({
+        error: "daemon.reapOrphanedSubprocesses must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "Whether the daemon, when running as PID 1 in a container, periodically reaps orphaned subprocesses that reparented to it. Off by default while the behavior is being validated.",
+      ),
   })
   .describe("Background daemon process configuration");
 

package/src/config/schemas/services.ts

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

package/src/config/schemas/timeouts.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 
+import { DEFAULT_TOOL_EXECUTION_TIMEOUT_SEC } from "../../api/constants/tool-execution.js";
+
 export const TimeoutConfigSchema = z
   .object({
     shellMaxTimeoutSec: z
@@ -30,7 +32,7 @@ export const TimeoutConfigSchema = z
       .number({ error: "timeouts.toolExecutionTimeoutSec must be a number" })
       .finite("timeouts.toolExecutionTimeoutSec must be finite")
       .positive("timeouts.toolExecutionTimeoutSec must be a positive number")
-      .default(120)
+      .default(DEFAULT_TOOL_EXECUTION_TIMEOUT_SEC)
       .describe("Default timeout for tool execution in seconds"),
     providerStreamTimeoutSec: z
       .number({ error: "timeouts.providerStreamTimeoutSec must be a number" })

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

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

package/src/config/skills.ts

@@ -52,6 +52,7 @@ const VellumMetadataSchema = z
 
 const SkillMetadataSchema = z
   .object({
+    icon: z.string().optional(),
     emoji: z.string().optional(),
     vellum: VellumMetadataSchema.optional(),
   })
@@ -210,6 +211,7 @@ interface ParsedFrontmatter {
   displayName: string;
   description: string;
   body: string;
+  icon?: string;
   emoji?: string;
   includes?: string[];
   featureFlag?: string;
@@ -253,6 +255,7 @@ function parseFrontmatter(
   }
 
   // metadata is already a parsed object from YAML — validate with Zod schema
+  let icon: string | undefined;
   let emoji: string | undefined;
   let parsedMeta: z.infer<typeof SkillMetadataSchema> | undefined;
   let vellum: z.infer<typeof VellumMetadataSchema> | undefined;
@@ -271,6 +274,7 @@ function parseFrontmatter(
       if (zodResult.success) {
         parsedMeta = zodResult.data;
         vellum = parsedMeta.vellum;
+        icon = parsedMeta.icon;
         emoji = vellum?.emoji ?? parsedMeta.emoji;
       } else {
         // Zod validation failed — fall back to raw parsed object so we don't
@@ -284,6 +288,9 @@ function parseFrontmatter(
         const raw = metadataRaw as Record<string, unknown>;
         parsedMeta = raw as z.infer<typeof SkillMetadataSchema>;
         vellum = raw?.vellum as z.infer<typeof VellumMetadataSchema>;
+        if (typeof parsedMeta?.icon === "string") {
+          icon = parsedMeta.icon;
+        }
         if (vellum && typeof vellum === "object") {
           emoji = typeof vellum.emoji === "string" ? vellum.emoji : undefined;
         }
@@ -337,6 +344,7 @@ function parseFrontmatter(
     displayName,
     description,
     body: strippedBody,
+    icon,
     emoji,
     includes,
     featureFlag,
@@ -489,6 +497,7 @@ function readSkillFromDirectory(
       directoryPath,
       skillFilePath,
       body: parsed.body,
+      icon: parsed.icon,
       emoji: parsed.emoji,
 
       source,
@@ -540,6 +549,7 @@ function readBundledSkillFromDirectory(
       skillFilePath,
       body: parsed.body,
       bundled: true,
+      icon: parsed.icon,
       emoji: parsed.emoji,
 
       source: "bundled",
@@ -599,6 +609,7 @@ function loadBundledSkills(): SkillSummary[] {
       directoryPath: skill.directoryPath,
       skillFilePath: skill.skillFilePath,
       bundled: true,
+      icon: skill.icon,
       emoji: skill.emoji,
 
       source: "bundled",
@@ -649,6 +660,7 @@ function skillSummaryFromDefinition(
     directoryPath: skill.directoryPath,
     skillFilePath: skill.skillFilePath,
     bundled: skill.bundled,
+    icon: skill.icon,
     emoji: skill.emoji,
     source,
     toolManifest: skill.toolManifest,
@@ -836,6 +848,7 @@ export function loadSkillCatalog(
           description: parsed.description,
           directoryPath: directory,
           skillFilePath,
+          icon: parsed.icon,
           emoji: parsed.emoji,
 
           source: "workspace",