@vellumai/assistant 0.7.2 → 0.7.3

package/src/config/loader.ts

@@ -7,6 +7,7 @@ import {
 } from "node:fs";
 import { basename, dirname, join } from "node:path";
 
+import { safeStatSync } from "../util/fs.js";
 import { getLogger } from "../util/logger.js";
 import {
   ensureDataDir,
@@ -22,8 +23,22 @@ export { API_KEY_PROVIDERS } from "../providers/provider-secret-catalog.js";
 const log = getLogger("config");
 
 let cached: AssistantConfig | null = null;
+let cachedFileSignature: ConfigFileSignature | null = null;
 let loading = false;
 
+type ConfigFileSignature =
+  | {
+      path: string;
+      exists: true;
+      size: number;
+      mtimeMs: number;
+      ctimeMs: number;
+    }
+  | {
+      path: string;
+      exists: false;
+    };
+
 function getConfigPath(): string {
   return getWorkspaceConfigPath();
 }
@@ -32,6 +47,48 @@ function ensureMigratedDataDir(): void {
   ensureDataDir();
 }
 
+function readConfigFileSignature(configPath: string): ConfigFileSignature {
+  const stats = safeStatSync(configPath);
+  if (!stats) {
+    return {
+      path: configPath,
+      exists: false,
+    };
+  }
+
+  return {
+    path: configPath,
+    exists: true,
+    size: stats.size,
+    mtimeMs: stats.mtimeMs,
+    ctimeMs: stats.ctimeMs,
+  };
+}
+
+function configFileSignaturesEqual(
+  a: ConfigFileSignature,
+  b: ConfigFileSignature,
+): boolean {
+  if (a.path !== b.path || a.exists !== b.exists) return false;
+  if (!a.exists || !b.exists) return true;
+  return (
+    a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs
+  );
+}
+
+function getCachedConfigIfFresh(): AssistantConfig | null {
+  if (!cached || !cachedFileSignature) return null;
+
+  const currentSignature = readConfigFileSignature(getConfigPath());
+  if (configFileSignaturesEqual(cachedFileSignature, currentSignature)) {
+    return cached;
+  }
+
+  cached = null;
+  cachedFileSignature = null;
+  return null;
+}
+
 /**
  * Parse a raw config through the Zod schema, applying all nested defaults.
  *
@@ -73,6 +130,10 @@ function getDeploymentContextDefaults(): Record<string, unknown> {
       "linear-oauth": managed,
       "github-oauth": managed,
       "notion-oauth": managed,
+      "asana-oauth": managed,
+      "todoist-oauth": managed,
+      "discord-oauth": managed,
+      "hubspot-oauth": managed,
     },
   };
 }
@@ -343,6 +404,13 @@ function stripNullLeaves(value: unknown): unknown {
   return out;
 }
 
+function readPlainObject(value: unknown): Record<string, unknown> | null {
+  if (value == null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
 /**
  * Deep-merge `overrides` into `target`, overwriting leaf values.
  * Recursively merges nested objects; scalars and arrays from `overrides`
@@ -406,6 +474,18 @@ export function deepMergeOverwrite(
   }
 }
 
+export type DefaultWorkspaceConfigMergeResult = {
+  providedLlmProfileNames: Set<string>;
+  providedLlmActiveProfile: boolean;
+};
+
+function emptyDefaultWorkspaceConfigMergeResult(): DefaultWorkspaceConfigMergeResult {
+  return {
+    providedLlmProfileNames: new Set(),
+    providedLlmActiveProfile: false,
+  };
+}
+
 /**
  * Merge default workspace config from the file referenced by
  * VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH into the workspace config on disk.
@@ -415,9 +495,11 @@ export function deepMergeOverwrite(
  * Schema defaults are no longer materialized into the file on load — the
  * in-memory `loadConfig()` cache applies them at access time instead.
  */
-export function mergeDefaultWorkspaceConfig(): void {
+export function mergeDefaultWorkspaceConfig(): DefaultWorkspaceConfigMergeResult {
   const defaultConfigPath = process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
-  if (!defaultConfigPath || !existsSync(defaultConfigPath)) return;
+  if (!defaultConfigPath || !existsSync(defaultConfigPath)) {
+    return emptyDefaultWorkspaceConfigMergeResult();
+  }
 
   let defaults: unknown;
   try {
@@ -428,7 +510,7 @@ export function mergeDefaultWorkspaceConfig(): void {
       "Failed to read default workspace config from %s",
       defaultConfigPath,
     );
-    return;
+    return emptyDefaultWorkspaceConfigMergeResult();
   }
 
   if (
@@ -436,16 +518,44 @@ export function mergeDefaultWorkspaceConfig(): void {
     typeof defaults !== "object" ||
     Array.isArray(defaults)
   ) {
-    return;
+    return emptyDefaultWorkspaceConfigMergeResult();
   }
 
+  const llmDefaults = readPlainObject(
+    (defaults as Record<string, unknown>).llm,
+  );
+  const providedProfiles = readPlainObject(llmDefaults?.profiles);
+  const mergeResult: DefaultWorkspaceConfigMergeResult = {
+    providedLlmProfileNames: new Set(
+      providedProfiles ? Object.keys(providedProfiles) : [],
+    ),
+    providedLlmActiveProfile:
+      llmDefaults != null &&
+      Object.prototype.hasOwnProperty.call(llmDefaults, "activeProfile"),
+  };
+
   const configPath = getConfigPath();
   let existing: Record<string, unknown> = {};
   if (existsSync(configPath)) {
     try {
       existing = JSON.parse(readFileSync(configPath, "utf-8"));
-    } catch {
-      // If existing config is corrupt, start fresh
+    } catch (err) {
+      quarantineCorruptConfig(configPath, err);
+      // After preserving the corrupt file, start fresh so the default overlay
+      // can still initialize a valid config for this startup.
+    }
+  }
+
+  if (mergeResult.providedLlmProfileNames.size > 0) {
+    // Default-config profile entries are authoritative fragments. Remove any
+    // old same-name profile first so recursive merge does not leave stale
+    // provider-specific leaves behind.
+    const existingLlm = readPlainObject(existing.llm);
+    const existingProfiles = readPlainObject(existingLlm?.profiles);
+    if (existingProfiles) {
+      for (const name of mergeResult.providedLlmProfileNames) {
+        delete existingProfiles[name];
+      }
     }
   }
 
@@ -456,6 +566,7 @@ export function mergeDefaultWorkspaceConfig(): void {
     mkdirSync(dir, { recursive: true });
   }
   writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
+  invalidateConfigCache();
 
   // Move the temp file into the workspace directory as a permanent record.
   // This prevents re-application on daemon restart (the env var still points
@@ -471,10 +582,13 @@ export function mergeDefaultWorkspaceConfig(): void {
   } catch {
     log.info("Merged default workspace config from %s", defaultConfigPath);
   }
+
+  return mergeResult;
 }
 
 export function loadConfig(): AssistantConfig {
-  if (cached) return cached;
+  const freshCached = getCachedConfigIfFresh();
+  if (freshCached) return freshCached;
 
   // Re-entrancy guard: log calls during loading (e.g. file-mode warning)
   // can trigger loadConfig again. Return defaults to break the cycle
@@ -593,12 +707,14 @@ export function loadConfig(): AssistantConfig {
     }
 
     cached = config;
+    cachedFileSignature = readConfigFileSignature(configPath);
 
     loading = false;
     return config;
   } catch (err) {
     // Loading failed — clear cached so the next call retries
     cached = null;
+    cachedFileSignature = null;
     loading = false;
     throw err;
   }
@@ -632,7 +748,8 @@ export function getConfig(): AssistantConfig {
  * workspace-existence check runs.
  */
 export function getConfigReadOnly(): AssistantConfig {
-  if (cached) return cached;
+  const freshCached = getCachedConfigIfFresh();
+  if (freshCached) return freshCached;
 
   const configPath = getConfigPath();
   let fileConfig: Record<string, unknown> = {};
@@ -649,6 +766,7 @@ export function getConfigReadOnly(): AssistantConfig {
 
 export function invalidateConfigCache(): void {
   cached = null;
+  cachedFileSignature = null;
   loading = false;
 }
 
@@ -686,6 +804,7 @@ export function saveRawConfig(config: Record<string, unknown>): void {
   writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 
   cached = null; // invalidate cache
+  cachedFileSignature = null;
 }
 
 export function getNestedValue(

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

@@ -7,7 +7,7 @@ describe("MemoryV2ConfigSchema", () => {
   test("parses an empty object to documented defaults", () => {
     const parsed = MemoryV2ConfigSchema.parse({});
     expect(parsed).toEqual({
-      enabled: false,
+      enabled: true,
       sweep_enabled: false,
       d: 0.3,
       c_user: 0.3,
@@ -15,9 +15,8 @@ describe("MemoryV2ConfigSchema", () => {
       c_now: 0.2,
       k: 0.5,
       hops: 2,
-      top_k: 20,
+      top_k: 25,
       ann_candidate_limit: null,
-      top_k_skills: 5,
       epsilon: 0.01,
       dense_weight: 0.85,
       sparse_weight: 0.15,
@@ -26,6 +25,13 @@ describe("MemoryV2ConfigSchema", () => {
       consolidation_interval_hours: 4,
       max_page_chars: 5000,
       consolidation_prompt_path: null,
+      rerank: {
+        enabled: false,
+        top_k: 50,
+        alpha: 0.3,
+        model: "Alibaba-NLP/gte-reranker-modernbert-base",
+        dtype: "q8",
+      },
     });
   });
 
@@ -155,12 +161,11 @@ describe("MemoryConfigSchema integration with v2 block", () => {
   test("parses an empty memory config and includes a v2 block with defaults", () => {
     const parsed = MemoryConfigSchema.parse({});
     expect(parsed.v2).toBeDefined();
-    expect(parsed.v2.enabled).toBe(false);
+    expect(parsed.v2.enabled).toBe(true);
     expect(parsed.v2.sweep_enabled).toBe(false);
     expect(parsed.v2.d).toBe(0.3);
     expect(parsed.v2.dense_weight).toBe(0.85);
     expect(parsed.v2.sparse_weight).toBe(0.15);
-    expect(parsed.v2.top_k_skills).toBe(5);
     expect(parsed.v2.consolidation_interval_hours).toBe(4);
     expect(parsed.v2.max_page_chars).toBe(5000);
   });

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

@@ -264,6 +264,20 @@ const CATALOG_RECORD: CatalogRecord = {
     description: "General-purpose LLM inference call site for skill use.",
     domain: "skills",
   },
+  proactiveArtifactDecision: {
+    id: "proactiveArtifactDecision",
+    displayName: "Proactive Artifact Decision",
+    description:
+      "Decides what personalized artifact to build for new users based on conversation context.",
+    domain: "agentLoop",
+  },
+  proactiveArtifactBuild: {
+    id: "proactiveArtifactBuild",
+    displayName: "Proactive Artifact Build",
+    description:
+      "Builds the personalized artifact in a background conversation with tool access.",
+    domain: "agentLoop",
+  },
 };
 
 // Source of truth for call-site display metadata. API responses and usage

package/src/config/schemas/channels.ts

@@ -121,8 +121,3 @@ export const SlackConfigSchema = z
       .describe("Slack bot display name"),
   })
   .describe("Slack channel configuration");
-
-export type TwilioConfig = z.infer<typeof TwilioConfigSchema>;
-export type WhatsAppConfig = z.infer<typeof WhatsAppConfigSchema>;
-export type TelegramConfig = z.infer<typeof TelegramConfigSchema>;
-export type SlackConfig = z.infer<typeof SlackConfigSchema>;

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(6 * 3_600_000)
+      .default(30 * 60_000)
       .describe("Time between heartbeat checks in milliseconds"),
     cronExpression: z
       .string()

package/src/config/schemas/llm.ts

@@ -70,6 +70,8 @@ export const LLMCallSiteEnum = z.enum([
   "inference",
   "feedEventCopy",
   "trustRuleSuggestion",
+  "proactiveArtifactDecision",
+  "proactiveArtifactBuild",
 ]);
 export type LLMCallSite = z.infer<typeof LLMCallSiteEnum>;
 

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

@@ -149,6 +149,19 @@ export const MemoryCleanupConfigSchema = z
       .describe(
         "Retention period for LLM request/response logs in milliseconds (null keeps forever, 0 prunes immediately)",
       ),
+    traceEventRetentionDays: z
+      .number({
+        error: "memory.cleanup.traceEventRetentionDays must be a number",
+      })
+      .int("memory.cleanup.traceEventRetentionDays must be an integer")
+      .nonnegative(
+        "memory.cleanup.traceEventRetentionDays must be non-negative",
+      )
+      .max(365, "memory.cleanup.traceEventRetentionDays must be <= 365 days")
+      .default(3)
+      .describe(
+        "Number of days to retain trace events before cleanup (0 disables pruning)",
+      ),
   })
   .describe("Automatic memory cleanup and garbage collection settings");
 

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

@@ -7,6 +7,33 @@ import { z } from "zod";
  */
 const WEIGHT_SUM_TOLERANCE = 0.001;
 
+/**
+ * Default cross-encoder model for memory v2 reranking.
+ * `Alibaba-NLP/gte-reranker-modernbert-base` (149M, Apache-2.0) — 2025
+ * ModernBERT-backbone reranker; smaller, newer, and cleaner-licensed than
+ * the bge family while matching or beating their retrieval-benchmark scores.
+ * Has ONNX exports at the standard `onnx/model.onnx` path.
+ */
+const DEFAULT_RERANK_MODEL = "Alibaba-NLP/gte-reranker-modernbert-base";
+
+/**
+ * ONNX weight precision passed to `@huggingface/transformers`. Sourced from
+ * transformers.js's supported `dtype` values; `q8` (int8) is ~3× faster than
+ * `fp32` on CPU with negligible reranker accuracy loss. Single source of
+ * truth for both the schema enum and the `LocalRerankBackend` type.
+ */
+export const RerankDtypeEnum = z.enum([
+  "fp32",
+  "fp16",
+  "q8",
+  "int8",
+  "uint8",
+  "q4",
+  "bnb4",
+  "q4f16",
+]);
+export type RerankDtype = z.infer<typeof RerankDtypeEnum>;
+
 /**
  * Memory v2 (concept-page activation model) configuration.
  *
@@ -21,7 +48,7 @@ export const MemoryV2ConfigSchema = z
   .object({
     enabled: z
       .boolean({ error: "memory.v2.enabled must be a boolean" })
-      .default(false)
+      .default(true)
       .describe(
         "Whether the v2 memory subsystem (concept-page activation model) is enabled. Independent of the memory-v2-enabled feature flag — both must be true for v2 to run.",
       ),
@@ -83,9 +110,9 @@ export const MemoryV2ConfigSchema = z
       .number({ error: "memory.v2.top_k must be a number" })
       .int("memory.v2.top_k must be an integer")
       .positive("memory.v2.top_k must be a positive integer")
-      .default(20)
+      .default(25)
       .describe(
-        "Number of top-activation concept pages considered for injection per turn",
+        "Number of top-activation entries (concept pages and skills combined) considered for injection per turn. Skills are scored alongside concepts in the same pool; this cap covers both.",
       ),
     ann_candidate_limit: z
       .number({ error: "memory.v2.ann_candidate_limit must be a number" })
@@ -96,14 +123,6 @@ export const MemoryV2ConfigSchema = z
       .describe(
         "Per-channel cap on the unrestricted ANN candidate query (dense and sparse each return up to this many hits before they are unioned and fed into the activation pipeline). `null` = unlimited (every page in the v2 collection is eligible). Increase or null this out to surface more candidates at the cost of higher per-turn embedding/scoring work.",
       ),
-    top_k_skills: z
-      .number({ error: "memory.v2.top_k_skills must be a number" })
-      .int()
-      .nonnegative()
-      .default(5)
-      .describe(
-        "Cap on the per-turn skill-autoinjection slate rendered in `### Skills You Can Use`. 0 disables skill autoinjection without code changes.",
-      ),
     epsilon: z
       .number({ error: "memory.v2.epsilon must be a number" })
       .min(0, "memory.v2.epsilon must be >= 0")
@@ -192,6 +211,51 @@ export const MemoryV2ConfigSchema = z
       .describe(
         "Optional path to a file whose contents replace the bundled consolidation prompt. Absolute paths are used as-is, a leading `~/` is expanded to the home directory, otherwise the path is resolved under the workspace root. The loaded contents may include `{{CUTOFF}}`, which is substituted with the run's ISO-8601 cutoff timestamp. If the file is missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
       ),
+    rerank: z
+      .object({
+        enabled: z
+          .boolean()
+          .default(false)
+          .describe(
+            "Whether to apply cross-encoder reranking as an additive A_o boost on the user + assistant channels. Disabled by default — opt in once measured.",
+          ),
+        top_k: z
+          .number()
+          .int()
+          .positive()
+          .max(200)
+          .default(50)
+          .describe(
+            "Number of candidates from the top of the pre-rerank-A_o pool to send through the reranker. Tail candidates contribute zero rerank boost and keep their pure fused activation.",
+          ),
+        alpha: z
+          .number()
+          .min(0)
+          .max(1)
+          .default(0.3)
+          .describe(
+            "Per-channel rerank weight: each top-K slug gets `alpha · normalized_rerank` added to A_o weighted by `c_user` (user channel) or `c_assistant` (assistant channel). Top reranker hit can lift A_o by up to `(c_user + c_assistant) · alpha`; bottom of top_k stays roughly unchanged.",
+          ),
+        model: z
+          .string()
+          .default(DEFAULT_RERANK_MODEL)
+          .describe(
+            "HuggingFace model id for the cross-encoder. Must have an ONNX export reachable from huggingface.co/<model>/resolve/main/onnx/model.onnx.",
+          ),
+        dtype: RerankDtypeEnum.default("q8").describe(
+          "ONNX weight precision passed to `@huggingface/transformers`. `q8` (int8) is ~3× faster than `fp32` on CPU with negligible reranker accuracy loss. The worker fails to spawn if the configured model has no matching quantized export — `reranker.ts` then falls back to pure fused scores for the turn.",
+        ),
+      })
+      .default({
+        enabled: false,
+        top_k: 50,
+        alpha: 0.3,
+        model: DEFAULT_RERANK_MODEL,
+        dtype: "q8",
+      })
+      .describe(
+        "Cross-encoder rerank configuration. When enabled, picks the top-K candidates by pre-rerank A_o, runs the cross-encoder once per channel (user, assistant) on that unified set, and adds an alpha-weighted normalized boost to A_o for each scored slug.",
+      ),
   })
   .describe(
     "Memory v2 — concept-page activation model with hourly LLM-driven consolidation",

package/src/config/schemas/platform.ts

@@ -1,5 +1,41 @@
 import { z } from "zod";
 
+const IANA_TIMEZONE_IDENTIFIER_RE =
+  /^(?:UTC|[A-Za-z][A-Za-z0-9_+-]*(?:\/[A-Za-z0-9_+-]+)+)$/;
+
+function canonicalizeIanaTimezone(timezone: string): string | null {
+  const trimmed = timezone.trim();
+  if (trimmed.length === 0) {
+    return "";
+  }
+  if (!IANA_TIMEZONE_IDENTIFIER_RE.test(trimmed)) {
+    return null;
+  }
+  try {
+    return new Intl.DateTimeFormat("en-US", {
+      timeZone: trimmed,
+    }).resolvedOptions().timeZone;
+  } catch {
+    return null;
+  }
+}
+
+function timezoneConfigField(path: string) {
+  return z
+    .string({ error: `${path} must be a string` })
+    .transform((value, ctx) => {
+      const canonical = canonicalizeIanaTimezone(value);
+      if (canonical === null) {
+        ctx.addIssue({
+          code: "custom",
+          message: `${path} must be a valid IANA timezone identifier or an empty string`,
+        });
+        return z.NEVER;
+      }
+      return canonical;
+    });
+}
+
 export const PlatformConfigSchema = z
   .object({
     baseUrl: z
@@ -56,11 +92,15 @@ export const DaemonConfigSchema = z
 
 export const UiConfigSchema = z
   .object({
-    userTimezone: z
-      .string({ error: "ui.userTimezone must be a string" })
+    userTimezone: timezoneConfigField("ui.userTimezone")
+      .optional()
+      .describe(
+        "Manual IANA timezone override used for assistant temporal grounding and date/time display (e.g. 'America/New_York'). Use an empty string to clear the setting.",
+      ),
+    detectedTimezone: timezoneConfigField("ui.detectedTimezone")
       .optional()
       .describe(
-        "IANA timezone identifier for displaying dates and times (e.g. 'America/New_York')",
+        "IANA timezone identifier detected from the client environment for assistant temporal grounding when no manual override is configured (e.g. 'America/New_York'). Use an empty string to clear the setting.",
       ),
   })
   .describe(

package/src/config/schemas/services.ts

@@ -72,6 +72,22 @@ const TwitterOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 
+const AsanaOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+
+const TodoistOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+
+const DiscordOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+
+const HubspotOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+
 /**
  * `services.meet.host.*` — daemon-side knobs for the externalized meet-join
  * skill process. Kept narrow: only the values the daemon reads before the
@@ -140,6 +156,18 @@ export const ServicesSchema = z.object({
   "twitter-oauth": TwitterOAuthServiceSchema.default(
     TwitterOAuthServiceSchema.parse({}),
   ),
+  "asana-oauth": AsanaOAuthServiceSchema.default(
+    AsanaOAuthServiceSchema.parse({}),
+  ),
+  "todoist-oauth": TodoistOAuthServiceSchema.default(
+    TodoistOAuthServiceSchema.parse({}),
+  ),
+  "discord-oauth": DiscordOAuthServiceSchema.default(
+    DiscordOAuthServiceSchema.parse({}),
+  ),
+  "hubspot-oauth": HubspotOAuthServiceSchema.default(
+    HubspotOAuthServiceSchema.parse({}),
+  ),
   meet: MeetDaemonServiceSchema.default(MeetDaemonServiceSchema.parse({})),
 });
 export type Services = z.infer<typeof ServicesSchema>;