@vellumai/assistant 0.6.0 → 0.6.2

package/src/config/env-registry.ts

@@ -24,6 +24,13 @@ function flag(name: string): boolean {
   return raw === "true" || raw === "1";
 }
 
+function int(name: string): number | undefined {
+  const raw = str(name);
+  if (raw === undefined) return undefined;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) ? n : undefined;
+}
+
 // ── Registry ─────────────────────────────────────────────────────────────────
 // Each entry documents the env var name, type, default, and purpose.
 
@@ -74,6 +81,57 @@ export function getWorkspaceDirOverride(): string | undefined {
   return str("VELLUM_WORKSPACE_DIR");
 }
 
+// ── Profiler env vars ───────────────────────────────────────────────────
+// These are injected by the platform when running a managed assistant in
+// profiler mode. The runtime uses them to locate, scope, and budget-limit
+// profiler output on the workspace volume.
+
+/**
+ * VELLUM_PROFILER_RUN_ID — string, default: undefined
+ * Unique identifier for the current profiler run. When set, the profiler
+ * run store treats this run as "active" and will never prune its directory.
+ */
+export function getProfilerRunId(): string | undefined {
+  return str("VELLUM_PROFILER_RUN_ID");
+}
+
+/**
+ * VELLUM_PROFILER_MODE — string, default: undefined
+ * The profiling mode to activate (e.g. "cpu", "heap", "cpu+heap").
+ * When unset, profiling is disabled.
+ */
+export function getProfilerMode(): string | undefined {
+  return str("VELLUM_PROFILER_MODE");
+}
+
+/**
+ * VELLUM_PROFILER_MAX_BYTES — integer, default: undefined
+ * Maximum total bytes retained across all profiler runs (including active).
+ * The startup sweep prunes oldest completed runs to stay within budget.
+ */
+export function getProfilerMaxBytes(): number | undefined {
+  return int("VELLUM_PROFILER_MAX_BYTES");
+}
+
+/**
+ * VELLUM_PROFILER_MAX_RUNS — integer, default: undefined
+ * Maximum number of completed profiler runs retained on disk.
+ * The startup sweep prunes oldest completed runs to stay within budget.
+ */
+export function getProfilerMaxRuns(): number | undefined {
+  return int("VELLUM_PROFILER_MAX_RUNS");
+}
+
+/**
+ * VELLUM_PROFILER_MIN_FREE_MB — integer, default: undefined
+ * Minimum free disk space (in megabytes) that must remain after profiler
+ * runs are accounted for. The startup sweep prunes oldest completed runs
+ * until at least this much free space is available.
+ */
+export function getProfilerMinFreeMb(): number | undefined {
+  return int("VELLUM_PROFILER_MIN_FREE_MB");
+}
+
 // ── Known env var names ──────────────────────────────────────────────────────
 
 /**
@@ -97,6 +155,11 @@ const KNOWN_VELLUM_VARS = new Set([
   "VELLUM_HOOK_SETTINGS",
   "VELLUM_LOCKFILE_DIR",
   "VELLUM_PLATFORM_URL",
+  "VELLUM_PROFILER_MAX_BYTES",
+  "VELLUM_PROFILER_MAX_RUNS",
+  "VELLUM_PROFILER_MIN_FREE_MB",
+  "VELLUM_PROFILER_MODE",
+  "VELLUM_PROFILER_RUN_ID",
   "VELLUM_ROOT_DIR",
   "VELLUM_SSH_USER",
   "VELLUM_UNSAFE_AUTH_BYPASS",

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

@@ -121,6 +121,14 @@
       "description": "Show the Billing tab in Settings when signed in, displaying credits balance and top-up",
       "defaultEnabled": true
     },
+    {
+      "id": "referral-codes",
+      "scope": "macos",
+      "key": "referral-codes",
+      "label": "Referral Codes",
+      "description": "Surface the Earn Credits referral entry points (sidebar drawer row and Billing tab button) that open the referral modal",
+      "defaultEnabled": true
+    },
     {
       "id": "managed-sign-in",
       "scope": "macos",
@@ -199,7 +207,7 @@
       "key": "show-thinking-blocks",
       "label": "Show Thinking Blocks",
       "description": "Display the assistant's thinking/reasoning inline in chat messages as collapsible blocks",
-      "defaultEnabled": false
+      "defaultEnabled": true
     },
     {
       "id": "inline-skill-commands",
@@ -272,6 +280,14 @@
       "label": "Teleport",
       "description": "Enable teleport UI in General settings for moving assistants between hosting environments",
       "defaultEnabled": false
+    },
+    {
+      "id": "permission-controls-v2",
+      "scope": "assistant",
+      "key": "permission-controls-v2",
+      "label": "Permission Controls V2",
+      "description": "Replace risk-level permission system with two independent controls: 'Ask before acting' (LLM behavior toggle) and 'Host access' (system-enforced gate)",
+      "defaultEnabled": false
     }
   ]
 }

package/src/config/schema.ts

@@ -3,6 +3,11 @@ import { z } from "zod";
 import { getDataDir } from "../util/platform.js";
 
 // Re-export all domain schemas
+export type { PermissionMode } from "../permissions/permission-mode.js";
+export {
+  DEFAULT_PERMISSION_MODE,
+  PermissionModeSchema,
+} from "../permissions/permission-mode.js";
 export type { AcpAgentConfig, AcpConfig } from "./acp-schema.js";
 export { AcpAgentConfigSchema, AcpConfigSchema } from "./acp-schema.js";
 export type {
@@ -143,6 +148,7 @@ export type {
 export {
   PermissionsConfigSchema,
   SecretDetectionConfigSchema,
+  VALID_PERMISSIONS_MODES,
 } from "./schemas/security.js";
 export type {
   ImageGenerationService,
@@ -197,6 +203,7 @@ import {
   WhatsAppConfigSchema,
 } from "./schemas/channels.js";
 import { ElevenLabsConfigSchema } from "./schemas/elevenlabs.js";
+import { FilingConfigSchema } from "./schemas/filing.js";
 import { FishAudioConfigSchema } from "./schemas/fish-audio.js";
 import { HeartbeatConfigSchema } from "./schemas/heartbeat.js";
 import {
@@ -272,6 +279,7 @@ export const AssistantConfigSchema = z
       .describe(
         "Custom pricing overrides for specific provider/model combinations",
       ),
+    filing: FilingConfigSchema.default(FilingConfigSchema.parse({})),
     heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
     journal: JournalConfigSchema.default(JournalConfigSchema.parse({})),
     mcp: McpConfigSchema.default(McpConfigSchema.parse({})),

package/src/config/schemas/filing.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+
+import { SpeedSchema } from "./inference.js";
+
+export const FilingConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "filing.enabled must be a boolean" })
+      .default(true)
+      .describe(
+        "Whether periodic PKB filing is enabled — processes buffer.md into topic files and reviews knowledge base organization",
+      ),
+    intervalMs: z
+      .number({ error: "filing.intervalMs must be a number" })
+      .int("filing.intervalMs must be an integer")
+      .positive("filing.intervalMs must be a positive integer")
+      .default(4 * 3_600_000)
+      .describe("Time between filing runs in milliseconds"),
+    speed: SpeedSchema.default("standard").describe(
+      "Inference speed mode for filing conversations",
+    ),
+    activeHoursStart: z
+      .number({ error: "filing.activeHoursStart must be a number" })
+      .int("filing.activeHoursStart must be an integer")
+      .min(0, "filing.activeHoursStart must be >= 0")
+      .max(23, "filing.activeHoursStart must be <= 23")
+      .default(8)
+      .describe("Hour of the day (0-23) when filing runs begin"),
+    activeHoursEnd: z
+      .number({ error: "filing.activeHoursEnd must be a number" })
+      .int("filing.activeHoursEnd must be an integer")
+      .min(0, "filing.activeHoursEnd must be >= 0")
+      .max(23, "filing.activeHoursEnd must be <= 23")
+      .default(22)
+      .describe("Hour of the day (0-23) when filing runs stop"),
+  })
+  .describe(
+    "Periodic PKB (personal knowledge base) filing — processes the buffer into topic files and maintains knowledge organization",
+  )
+  .superRefine((config, ctx) => {
+    if (config.activeHoursStart === config.activeHoursEnd) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["activeHoursEnd"],
+        message:
+          "filing.activeHoursStart and filing.activeHoursEnd must not be equal (would create an empty window)",
+      });
+    }
+  });
+
+export type FilingConfig = z.infer<typeof FilingConfigSchema>;

package/src/config/schemas/heartbeat.ts

@@ -12,7 +12,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(3_600_000)
+      .default(6 * 3_600_000)
       .describe("Time between heartbeat checks in milliseconds"),
     speed: SpeedSchema.default("standard").describe(
       "Inference speed mode for heartbeat conversations — defaults to standard to avoid inheriting the global fast mode multiplier",
@@ -22,35 +22,38 @@ export const HeartbeatConfigSchema = z
       .int("heartbeat.activeHoursStart must be an integer")
       .min(0, "heartbeat.activeHoursStart must be >= 0")
       .max(23, "heartbeat.activeHoursStart must be <= 23")
-      .optional()
+      .nullable()
+      .default(8)
       .describe(
-        "Hour of the day (0-23) when heartbeat checks begin — must be set together with activeHoursEnd",
+        "Hour of the day (0-23) when heartbeat checks begin, or null to disable active hours restriction",
       ),
     activeHoursEnd: z
       .number({ error: "heartbeat.activeHoursEnd must be a number" })
       .int("heartbeat.activeHoursEnd must be an integer")
       .min(0, "heartbeat.activeHoursEnd must be >= 0")
       .max(23, "heartbeat.activeHoursEnd must be <= 23")
-      .optional()
+      .nullable()
+      .default(22)
       .describe(
-        "Hour of the day (0-23) when heartbeat checks stop — must be set together with activeHoursStart",
+        "Hour of the day (0-23) when heartbeat checks stop, or null to disable active hours restriction",
       ),
   })
   .describe("Periodic heartbeat configuration for health monitoring")
   .superRefine((config, ctx) => {
-    const hasStart = config.activeHoursStart != null;
-    const hasEnd = config.activeHoursEnd != null;
-    if (hasStart !== hasEnd) {
+    const startNull = config.activeHoursStart == null;
+    const endNull = config.activeHoursEnd == null;
+    if (startNull !== endNull) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
-        path: [hasStart ? "activeHoursEnd" : "activeHoursStart"],
+        path: [startNull ? "activeHoursStart" : "activeHoursEnd"],
         message:
-          "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must both be set or both be omitted",
+          "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must both be set or both be null",
       });
+      return;
     }
     if (
-      hasStart &&
-      hasEnd &&
+      config.activeHoursStart != null &&
+      config.activeHoursEnd != null &&
       config.activeHoursStart === config.activeHoursEnd
     ) {
       ctx.addIssue({

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

@@ -72,6 +72,18 @@ export const MemoryCleanupConfigSchema = z
       .describe(
         "Number of days to retain conversation data before cleanup (0 disables pruning)",
       ),
+    llmRequestLogRetentionMs: z
+      .number({
+        error: "memory.cleanup.llmRequestLogRetentionMs must be a number",
+      })
+      .int("memory.cleanup.llmRequestLogRetentionMs must be an integer")
+      .nonnegative(
+        "memory.cleanup.llmRequestLogRetentionMs must be non-negative",
+      )
+      .default(7 * 24 * 60 * 60 * 1000)
+      .describe(
+        "Retention period for LLM request/response logs in milliseconds (0 disables pruning)",
+      ),
   })
   .describe("Automatic memory cleanup and garbage collection settings");
 

package/src/config/schemas/security.ts

@@ -79,6 +79,20 @@ export const PermissionsConfigSchema = z
       .describe(
         "Permission mode — 'strict' requires explicit approval for all operations, 'workspace' allows operations within the workspace",
       ),
+    askBeforeActing: z
+      .boolean({
+        error: "permissions.askBeforeActing must be a boolean",
+      })
+      .default(true)
+      .describe("Whether the assistant should check in before taking actions"),
+    hostAccess: z
+      .boolean({
+        error: "permissions.hostAccess must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "Whether the assistant can execute commands on the host machine without prompting",
+      ),
   })
   .describe("Permission enforcement mode for tool operations");
 

package/src/config/schemas/services.ts

@@ -56,6 +56,11 @@ export const OutlookOAuthServiceSchema = BaseServiceSchema.extend({
 });
 export type OutlookOAuthService = z.infer<typeof OutlookOAuthServiceSchema>;
 
+export const LinearOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type LinearOAuthService = z.infer<typeof LinearOAuthServiceSchema>;
+
 export const ServicesSchema = z.object({
   inference: InferenceServiceSchema.default(InferenceServiceSchema.parse({})),
   "image-generation": ImageGenerationServiceSchema.default(
@@ -70,5 +75,8 @@ export const ServicesSchema = z.object({
   "outlook-oauth": OutlookOAuthServiceSchema.default(
     OutlookOAuthServiceSchema.parse({}),
   ),
+  "linear-oauth": LinearOAuthServiceSchema.default(
+    LinearOAuthServiceSchema.parse({}),
+  ),
 });
 export type Services = z.infer<typeof ServicesSchema>;

package/src/credential-execution/approval-bridge.ts

@@ -220,7 +220,6 @@ export async function bridgeCesApproval(
     [], // No allowlist options — CES manages its own grant patterns
     [], // No scope options — CES manages scope internally
     undefined, // No file diff
-    undefined, // Not sandboxed
     options?.conversationId,
     "host", // CES operations target the host
     false, // Persistent decisions are managed by CES, not trust.json

package/src/credential-execution/managed-catalog.ts

@@ -130,16 +130,12 @@ export async function fetchManagedCatalog(): Promise<FetchManagedCatalogResult>
 
     return { ok: true, descriptors };
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const safeMessage = message.replace(
-      /Api-Key\s+\S+/gi,
-      "Api-Key [REDACTED]",
-    );
-    log.warn(`Failed to fetch managed CES catalog: ${safeMessage}`);
+    const errorName = err instanceof Error ? err.constructor.name : "Unknown";
+    log.warn(`Failed to fetch managed CES catalog (${errorName})`);
     return {
       ok: false,
       descriptors: [],
-      error: `Failed to fetch managed CES catalog: ${safeMessage}`,
+      error: `Failed to fetch managed CES catalog (${errorName})`,
     };
   }
 }

package/src/daemon/app-source-watcher.ts

@@ -0,0 +1,93 @@
+/**
+ * Filesystem watcher for app source directories.
+ *
+ * Watches the apps root directory recursively using fs.watch (FSEvents on
+ * macOS). When a source file changes, debounces per app ID and calls the
+ * provided callback so the server can recompile + refresh surfaces.
+ *
+ * This catches ALL modification sources (file_edit, file_write, bash, etc.)
+ * without relying on individual tool hooks.
+ */
+
+import { existsSync, type FSWatcher, watch } from "node:fs";
+
+import {
+  getAppsDir,
+  resolveAppIdByDirName,
+} from "../memory/app-store.js";
+import { DebouncerMap } from "../util/debounce.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("app-source-watcher");
+
+const APP_REFRESH_DEBOUNCE_MS = 500;
+
+export type AppSourceChangeCallback = (appId: string) => void;
+
+/**
+ * Resolve app ID from a relative path within the apps directory.
+ * Returns null if the path is not an app source file (e.g. dist/, records/).
+ */
+function resolveAppIdFromRelPath(relPath: string): string | null {
+  const slashIdx = relPath.indexOf("/");
+  if (slashIdx === -1) return null; // file directly in apps/ (e.g. .json definition)
+
+  const dirName = relPath.slice(0, slashIdx);
+  const innerPath = relPath.slice(slashIdx + 1);
+
+  // Skip non-source directories (include bare directory names for fs.watch events)
+  if (
+    innerPath === "records" || innerPath.startsWith("records/") ||
+    innerPath === "dist" || innerPath.startsWith("dist/")
+  ) {
+    return null;
+  }
+
+  return resolveAppIdByDirName(dirName);
+}
+
+export class AppSourceWatcher {
+  private watcher: FSWatcher | null = null;
+  private debouncer = new DebouncerMap({
+    defaultDelayMs: APP_REFRESH_DEBOUNCE_MS,
+    maxEntries: 50,
+  });
+
+  start(onChange: AppSourceChangeCallback): void {
+    let appsDir: string;
+    try {
+      appsDir = getAppsDir();
+    } catch {
+      log.warn("Could not resolve apps directory; app source watching disabled");
+      return;
+    }
+
+    if (!existsSync(appsDir)) {
+      log.info("Apps directory does not exist yet; skipping source watcher");
+      return;
+    }
+
+    try {
+      this.watcher = watch(appsDir, { recursive: true }, (_eventType, filename) => {
+        if (!filename) return;
+
+        const appId = resolveAppIdFromRelPath(filename);
+        if (!appId) return;
+
+        this.debouncer.schedule(`app:${appId}`, () => {
+          onChange(appId);
+        });
+      });
+    } catch (err) {
+      log.warn({ err }, "Failed to watch apps directory; source watching disabled");
+    }
+  }
+
+  stop(): void {
+    this.debouncer.cancelAll();
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+}

package/src/daemon/config-watcher.ts

@@ -28,7 +28,10 @@ import { handleUserMessageSignal } from "../signals/user-message.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
 import {
+  AVATAR_IMAGE_FILENAME,
+  getAvatarDir,
   getSignalsDir,
+  getSoundsDir,
   getWorkspaceDir,
   getWorkspaceSkillsDir,
 } from "../util/platform.js";
@@ -110,7 +113,14 @@ export class ConfigWatcher {
    * files change and conversations need to be evicted for reload.
    * `onIdentityChanged` is called when IDENTITY.md changes on disk.
    */
-  start(onConversationEvict: () => void, onIdentityChanged?: () => void): void {
+  start(
+    onConversationEvict: () => void,
+    onIdentityChanged?: () => void,
+    onSoundsConfigChanged?: () => void,
+    onAvatarChanged?: () => void,
+    onConfigChanged?: () => void,
+    onFeatureFlagsChanged?: () => void,
+  ): void {
     const workspaceDir = getWorkspaceDir();
 
     const workspaceHandlers: Record<string, () => void> = {
@@ -122,6 +132,7 @@ export class ConfigWatcher {
           const changed = await this.refreshConfigFromSources();
           if (changed) {
             onConversationEvict();
+            onConfigChanged?.();
             const newConfig = getConfig();
             const newMcpFingerprint = JSON.stringify(newConfig.mcp ?? {});
             if (newMcpFingerprint !== prevMcpFingerprint) {
@@ -175,7 +186,14 @@ export class ConfigWatcher {
       "workspace directory for config/prompt changes",
     );
 
-    this.startFeatureFlagsWatcher();
+    if (onSoundsConfigChanged) {
+      this.startSoundsWatcher(onSoundsConfigChanged);
+    }
+    if (onAvatarChanged) {
+      this.startAvatarWatcher(onAvatarChanged);
+    }
+
+    this.startFeatureFlagsWatcher(onFeatureFlagsChanged);
     this.startSignalsWatcher();
     this.startSkillsWatchers(onConversationEvict);
   }
@@ -188,7 +206,70 @@ export class ConfigWatcher {
     this.watchers = [];
   }
 
-  private startFeatureFlagsWatcher(): void {
+  private startSoundsWatcher(onSoundsConfigChanged: () => void): void {
+    const soundsDir = getSoundsDir();
+    try {
+      if (!existsSync(soundsDir)) {
+        mkdirSync(soundsDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    try {
+      const watcher = watch(soundsDir, (_eventType, filename) => {
+        if (!filename) return;
+        this.debounceTimers.schedule("file:sounds", () => {
+          log.info(
+            { file: String(filename) },
+            "Sounds directory changed, notifying clients",
+          );
+          onSoundsConfigChanged();
+        });
+      });
+      this.watchers.push(watcher);
+      log.info({ dir: soundsDir }, "Watching sounds directory for changes");
+    } catch (err) {
+      log.warn(
+        { err, dir: soundsDir },
+        "Failed to watch sounds directory. Sound config changes will require a restart.",
+      );
+    }
+  }
+
+  private startAvatarWatcher(onAvatarChanged: () => void): void {
+    const avatarDir = getAvatarDir();
+    try {
+      if (!existsSync(avatarDir)) {
+        mkdirSync(avatarDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    try {
+      const watcher = watch(avatarDir, (_eventType, filename) => {
+        if (!filename) return;
+        if (String(filename) !== AVATAR_IMAGE_FILENAME) return;
+        this.debounceTimers.schedule("file:avatar", () => {
+          log.info(
+            { file: String(filename) },
+            "Avatar image changed, notifying clients",
+          );
+          onAvatarChanged();
+        });
+      });
+      this.watchers.push(watcher);
+      log.info({ dir: avatarDir }, "Watching avatar directory for changes");
+    } catch (err) {
+      log.warn(
+        { err, dir: avatarDir },
+        "Failed to watch avatar directory. Avatar changes will require a restart.",
+      );
+    }
+  }
+
+  private startFeatureFlagsWatcher(onFeatureFlagsChanged?: () => void): void {
     const protectedDir = process.env.GATEWAY_SECURITY_DIR
       ? process.env.GATEWAY_SECURITY_DIR
       : join(homedir(), ".vellum", "protected");
@@ -219,6 +300,7 @@ export class ConfigWatcher {
               "Feature flags file changed, invalidating cache",
             );
             clearFeatureFlagOverridesCache();
+            onFeatureFlagsChanged?.();
           },
           500,
         );

package/src/daemon/context-overflow-approval.ts

@@ -39,7 +39,6 @@ export async function requestCompressionApproval(
     undefined,
     undefined,
     undefined,
-    undefined,
     false,
     opts?.signal,
   );

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -27,6 +27,7 @@ import {
 } from "../memory/llm-request-log-store.js";
 import { backfillMemoryRecallLogMessageId } from "../memory/memory-recall-log-store.js";
 import type { ContentBlock, ImageContent } from "../providers/types.js";
+import { ProviderError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import type { DirectiveRequest } from "./assistant-attachments.js";
 import {
@@ -630,6 +631,25 @@ export function handleError(
       state.orderingErrorDetected = true;
       state.deferredOrderingError = event.error.message;
     } else {
+      if (classified.errorCategory === "provider_api_error") {
+        log.error(
+          {
+            conversationId: deps.ctx.conversationId,
+            errorCode: classified.code,
+            errorCategory: classified.errorCategory,
+            statusCode:
+              event.error instanceof ProviderError
+                ? event.error.statusCode
+                : undefined,
+            provider:
+              event.error instanceof ProviderError
+                ? event.error.provider
+                : undefined,
+            errorMessage: event.error.message,
+          },
+          "Provider rejected request with unclassified 4xx error",
+        );
+      }
       deps.onEvent(
         buildConversationErrorMessage(deps.ctx.conversationId, classified),
       );