@vellumai/assistant 0.6.2 → 0.6.4

package/src/daemon/__tests__/lifecycle-startup-ordering.test.ts

@@ -0,0 +1,127 @@
+/**
+ * Invariant: the analyze-deps singleton must be populated before the memory
+ * worker starts, so any `conversation_analyze` job the worker claims on its
+ * first poll sees a non-null deps bundle.
+ *
+ * Assertions:
+ *   1. Source-ordering guard: `lifecycle.ts` constructs `RuntimeHttpServer`
+ *      (which synchronously calls `setAnalysisDeps()` inside
+ *      `buildRouteTable()`) before invoking `void initializeQdrantAndMemory()`
+ *      (which kicks off the memory worker).
+ *   2. Runtime check: constructing `RuntimeHttpServer` with `sendMessageDeps`
+ *      populates the analyze-deps singleton synchronously by the time the
+ *      constructor returns.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../config/env.js", () => ({
+  isHttpAuthDisabled: () => true,
+  hasUngatedHttpAuthDisabled: () => false,
+  getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
+  getGatewayPort: () => 7830,
+  getRuntimeHttpPort: () => 7821,
+  getRuntimeHttpHost: () => "127.0.0.1",
+  getRuntimeGatewayOriginSecret: () => undefined,
+  getIngressPublicBaseUrl: () => undefined,
+  setIngressPublicBaseUrl: () => {},
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { initializeDb, resetDb } from "../../memory/db.js";
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
+import { RuntimeHttpServer } from "../../runtime/http-server.js";
+import { getAnalysisDeps } from "../../runtime/services/analyze-deps-singleton.js";
+
+initializeDb();
+
+describe("daemon lifecycle startup ordering", () => {
+  let server: RuntimeHttpServer | null = null;
+
+  beforeEach(async () => {
+    await server?.stop();
+    server = null;
+  });
+
+  afterAll(async () => {
+    await server?.stop();
+    resetDb();
+  });
+
+  test("lifecycle.ts constructs RuntimeHttpServer before kicking off initializeQdrantAndMemory", () => {
+    // Source-level guard: read lifecycle.ts and assert the RuntimeHttpServer
+    // constructor call appears before the fire-and-forget memory init.
+    const lifecyclePath = join(
+      import.meta.dir,
+      "..",
+      "lifecycle.ts",
+    );
+    const content = readFileSync(lifecyclePath, "utf-8");
+
+    const httpServerCtorIdx = content.indexOf("new RuntimeHttpServer(");
+    const initQdrantIdx = content.indexOf("void initializeQdrantAndMemory(");
+
+    expect(
+      httpServerCtorIdx,
+      "Expected to find `new RuntimeHttpServer(` in lifecycle.ts",
+    ).toBeGreaterThan(-1);
+    expect(
+      initQdrantIdx,
+      "Expected to find `void initializeQdrantAndMemory(` in lifecycle.ts",
+    ).toBeGreaterThan(-1);
+
+    expect(
+      httpServerCtorIdx,
+      "lifecycle.ts must construct RuntimeHttpServer (which synchronously " +
+        "populates the analyze-deps singleton via buildRouteTable → " +
+        "setAnalysisDeps) BEFORE invoking `void initializeQdrantAndMemory()`. " +
+        "Otherwise the memory worker can claim a leftover " +
+        "`conversation_analyze` job before the deps singleton is populated, " +
+        "the handler throws, and the worker classifies the plain Error as " +
+        "fatal and drops the job.",
+    ).toBeLessThan(initQdrantIdx);
+  });
+
+  test("constructing RuntimeHttpServer with sendMessageDeps populates the analyze-deps singleton synchronously", async () => {
+    // Runtime guard: confirms the wiring inside buildRouteTable calls
+    // setAnalysisDeps when sendMessageDeps is provided. If that call ever
+    // moves out of buildRouteTable without an equivalent call site in
+    // lifecycle.ts, this assertion fires.
+    server = new RuntimeHttpServer({
+      port: 0,
+      bearerToken: "test-bearer-token",
+      sendMessageDeps: {
+        getOrCreateConversation: async () => {
+          throw new Error("not used in this test");
+        },
+        assistantEventHub,
+        resolveAttachments: () => [],
+      },
+    });
+
+    // The constructor populates the singleton synchronously — no start()
+    // call required. The memory worker's first tick runs as a microtask
+    // after lifecycle.ts kicks it off, so the singleton must be ready by
+    // the time the constructor returns.
+    expect(getAnalysisDeps()).not.toBeNull();
+  });
+});

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

@@ -24,6 +24,20 @@ const APP_REFRESH_DEBOUNCE_MS = 500;
 
 export type AppSourceChangeCallback = (appId: string) => void;
 
+/**
+ * Module-level callback so tool-side-effects can ensure the watcher starts
+ * after the apps directory is created (e.g. on first app_create).
+ */
+let ensureWatcherStarted: (() => void) | null = null;
+
+export function setEnsureAppSourceWatcher(fn: () => void): void {
+  ensureWatcherStarted = fn;
+}
+
+export function ensureAppSourceWatcher(): void {
+  ensureWatcherStarted?.();
+}
+
 /**
  * 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/).
@@ -48,12 +62,29 @@ function resolveAppIdFromRelPath(relPath: string): string | null {
 
 export class AppSourceWatcher {
   private watcher: FSWatcher | null = null;
+  private onChange: AppSourceChangeCallback | null = null;
   private debouncer = new DebouncerMap({
     defaultDelayMs: APP_REFRESH_DEBOUNCE_MS,
     maxEntries: 50,
   });
 
   start(onChange: AppSourceChangeCallback): void {
+    this.onChange = onChange;
+    this.tryWatch();
+  }
+
+  /**
+   * Ensure the watcher is running. Call after app creation so the watcher
+   * starts if the apps directory was created after daemon startup.
+   */
+  ensureStarted(): void {
+    if (this.watcher || !this.onChange) return;
+    this.tryWatch();
+  }
+
+  private tryWatch(): void {
+    if (this.watcher) return;
+
     let appsDir: string;
     try {
       appsDir = getAppsDir();
@@ -67,6 +98,9 @@ export class AppSourceWatcher {
       return;
     }
 
+    const onChange = this.onChange;
+    if (!onChange) return;
+
     try {
       this.watcher = watch(appsDir, { recursive: true }, (_eventType, filename) => {
         if (!filename) return;
@@ -78,6 +112,7 @@ export class AppSourceWatcher {
           onChange(appId);
         });
       });
+      log.info("App source watcher started");
     } catch (err) {
       log.warn({ err }, "Failed to watch apps directory; source watching disabled");
     }

package/src/daemon/config-watcher.ts

@@ -10,11 +10,12 @@ import {
   readdirSync,
   watch,
 } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 import { getConfig, invalidateConfigCache } from "../config/loader.js";
+import type { MemoryCleanupConfig } from "../config/schemas/memory-lifecycle.js";
+import { resetCleanupScheduleThrottle } from "../memory/cleanup-schedule-state.js";
 import { clearEmbeddingBackendCache } from "../memory/embedding-backend.js";
 import { clearCache as clearTrustCache } from "../permissions/trust-store.js";
 import { initializeProviders } from "../providers/registry.js";
@@ -30,6 +31,7 @@ import { getLogger } from "../util/logger.js";
 import {
   AVATAR_IMAGE_FILENAME,
   getAvatarDir,
+  getProtectedDir,
   getSignalsDir,
   getSoundsDir,
   getWorkspaceDir,
@@ -38,6 +40,17 @@ import {
 
 const log = getLogger("config-watcher");
 
+/**
+ * Attach a resilient error handler to an FSWatcher so that async errors
+ * (e.g. ENXIO when a Unix socket file like `gateway.sock` appears in a
+ * watched directory) are logged instead of crashing the process.
+ */
+function attachWatcherErrorHandler(watcher: FSWatcher, dir: string): void {
+  watcher.on("error", (err) => {
+    log.warn({ err, dir }, "FSWatcher error (non-fatal, continuing)");
+  });
+}
+
 export class ConfigWatcher {
   private watchers: FSWatcher[] = [];
   private debounceTimers = new DebouncerMap({
@@ -94,6 +107,7 @@ export class ConfigWatcher {
    * Returns true if config actually changed.
    */
   async refreshConfigFromSources(): Promise<boolean> {
+    const prevCleanup = safeGetCleanupConfig();
     invalidateConfigCache();
     const config = getConfig();
     const fingerprint = this.configFingerprint(config);
@@ -102,6 +116,13 @@ export class ConfigWatcher {
     }
     clearTrustCache();
     clearEmbeddingBackendCache();
+    // If cleanup retention settings changed, reset the cleanup scheduler
+    // throttle so the next worker tick re-enqueues jobs with the new values
+    // instead of waiting out the remaining enqueueIntervalMs (default 6h).
+    const nextCleanup = config.memory?.cleanup;
+    if (cleanupSettingsChanged(prevCleanup, nextCleanup)) {
+      resetCleanupScheduleThrottle();
+    }
     const isFirstInit = this.lastFingerprint === "";
     await initializeProviders(config);
     this.lastFingerprint = fingerprint;
@@ -151,7 +172,6 @@ export class ConfigWatcher {
         onConversationEvict();
         onIdentityChanged?.();
       },
-      "USER.md": () => onConversationEvict(),
       "UPDATES.md": () => onConversationEvict(),
     };
 
@@ -170,6 +190,7 @@ export class ConfigWatcher {
             handlers[file]();
           });
         });
+        attachWatcherErrorHandler(watcher, dir);
         this.watchers.push(watcher);
         log.info({ dir }, `Watching ${label}`);
       } catch (err) {
@@ -195,6 +216,7 @@ export class ConfigWatcher {
 
     this.startFeatureFlagsWatcher(onFeatureFlagsChanged);
     this.startSignalsWatcher();
+    this.startUsersWatcher(onConversationEvict);
     this.startSkillsWatchers(onConversationEvict);
   }
 
@@ -227,6 +249,7 @@ export class ConfigWatcher {
           onSoundsConfigChanged();
         });
       });
+      attachWatcherErrorHandler(watcher, soundsDir);
       this.watchers.push(watcher);
       log.info({ dir: soundsDir }, "Watching sounds directory for changes");
     } catch (err) {
@@ -237,6 +260,40 @@ export class ConfigWatcher {
     }
   }
 
+  private startUsersWatcher(onConversationEvict: () => void): void {
+    const usersDir = join(getWorkspaceDir(), "users");
+    try {
+      if (!existsSync(usersDir)) {
+        mkdirSync(usersDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    try {
+      const watcher = watch(usersDir, (_eventType, filename) => {
+        if (!filename) return;
+        const file = String(filename);
+        if (!file.endsWith(".md")) return;
+        this.debounceTimers.schedule(`file:users/${file}`, () => {
+          log.info({ file }, "Users persona file changed, reloading");
+          onConversationEvict();
+        });
+      });
+      attachWatcherErrorHandler(watcher, usersDir);
+      this.watchers.push(watcher);
+      log.info(
+        { dir: usersDir },
+        "Watching users directory for persona changes",
+      );
+    } catch (err) {
+      log.warn(
+        { err, dir: usersDir },
+        "Failed to watch users directory. Persona file changes will require a restart.",
+      );
+    }
+  }
+
   private startAvatarWatcher(onAvatarChanged: () => void): void {
     const avatarDir = getAvatarDir();
     try {
@@ -259,6 +316,7 @@ export class ConfigWatcher {
           onAvatarChanged();
         });
       });
+      attachWatcherErrorHandler(watcher, avatarDir);
       this.watchers.push(watcher);
       log.info({ dir: avatarDir }, "Watching avatar directory for changes");
     } catch (err) {
@@ -270,9 +328,7 @@ export class ConfigWatcher {
   }
 
   private startFeatureFlagsWatcher(onFeatureFlagsChanged?: () => void): void {
-    const protectedDir = process.env.GATEWAY_SECURITY_DIR
-      ? process.env.GATEWAY_SECURITY_DIR
-      : join(homedir(), ".vellum", "protected");
+    const protectedDir = process.env.GATEWAY_SECURITY_DIR || getProtectedDir();
 
     try {
       if (!existsSync(protectedDir)) {
@@ -305,6 +361,7 @@ export class ConfigWatcher {
           500,
         );
       });
+      attachWatcherErrorHandler(watcher, protectedDir);
       this.watchers.push(watcher);
       log.info(
         { dir: protectedDir },
@@ -367,6 +424,7 @@ export class ConfigWatcher {
           }
         }
       });
+      attachWatcherErrorHandler(watcher, signalsDir);
       this.watchers.push(watcher);
       log.info({ dir: signalsDir }, "Watching signals directory");
     } catch (err) {
@@ -396,6 +454,7 @@ export class ConfigWatcher {
           scheduleSkillsReload(filename ? String(filename) : "(unknown)");
         },
       );
+      attachWatcherErrorHandler(recursiveWatcher, skillsDir);
       this.watchers.push(recursiveWatcher);
       log.info({ dir: skillsDir }, "Watching skills directory recursively");
       return;
@@ -416,6 +475,7 @@ export class ConfigWatcher {
         const watcher = watch(dirPath, (_eventType, filename) => {
           onChange(filename ? String(filename) : "(unknown)");
         });
+        attachWatcherErrorHandler(watcher, dirPath);
         this.watchers.push(watcher);
         return watcher;
       } catch (err) {
@@ -481,3 +541,37 @@ export class ConfigWatcher {
     );
   }
 }
+
+/**
+ * Snapshot the current cleanup config so we can compare it against the
+ * post-reload value. Tolerant of config-load failures — if the config can't
+ * be read (e.g. first-load), returns undefined so the comparison below
+ * treats it as "no previous value".
+ */
+function safeGetCleanupConfig(): MemoryCleanupConfig | undefined {
+  try {
+    return getConfig().memory?.cleanup;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Return true if any cleanup field the user can change via the UI differs
+ * between the previous and next config snapshots. Used to decide whether to
+ * reset the cleanup-scheduler throttle after a config reload so retention
+ * changes take effect immediately instead of waiting up to 6 hours.
+ *
+ * Exported for unit testing.
+ */
+export function cleanupSettingsChanged(
+  prev: MemoryCleanupConfig | undefined,
+  next: MemoryCleanupConfig | undefined,
+): boolean {
+  if (!prev || !next) return false;
+  return (
+    prev.llmRequestLogRetentionMs !== next.llmRequestLogRetentionMs ||
+    prev.conversationRetentionDays !== next.conversationRetentionDays ||
+    prev.enabled !== next.enabled
+  );
+}

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

@@ -1,5 +1,6 @@
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import { isAllowDecision } from "../permissions/types.js";
+import { isPermissionControlsV2Enabled } from "../permissions/v2-consent-policy.js";
 
 /**
  * Reserved pseudo tool name used for context overflow compression approval
@@ -26,6 +27,10 @@ export async function requestCompressionApproval(
   prompter: PermissionPrompter,
   opts?: { signal?: AbortSignal },
 ): Promise<CompressionApprovalResult> {
+  if (isPermissionControlsV2Enabled()) {
+    return { approved: true };
+  }
+
   const result = await prompter.prompt(
     CONTEXT_OVERFLOW_TOOL_NAME,
     {

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

@@ -64,6 +64,8 @@ export interface EventHandlerState {
   exchangeCacheCreationInputTokens: number;
   exchangeCacheReadInputTokens: number;
   exchangeOutputTokens: number;
+  /** Input tokens from the most recent LLM API call (overwritten, not accumulated). */
+  lastCallInputTokens: number;
   /** Number of actual LLM API calls within this exchange. */
   exchangeLlmCallCount: number;
   readonly exchangeRawResponses: unknown[];
@@ -135,6 +137,7 @@ export function createEventHandlerState(): EventHandlerState {
     exchangeCacheCreationInputTokens: 0,
     exchangeCacheReadInputTokens: 0,
     exchangeOutputTokens: 0,
+    lastCallInputTokens: 0,
     exchangeLlmCallCount: 0,
     exchangeRawResponses: [],
     model: "",
@@ -590,6 +593,7 @@ function annotatePersistedAssistantMessage(
         data: surface.data,
         actions: surface.actions,
         display: surface.display,
+        ...(surface.persistent ? { persistent: true } : {}),
       } as unknown as ContentBlock);
     }
     modified = true;
@@ -759,6 +763,7 @@ export async function handleMessageComplete(
       data: surface.data,
       actions: surface.actions,
       display: surface.display,
+      ...(surface.persistent ? { persistent: true } : {}),
     } as unknown as ContentBlock);
   }
 
@@ -831,6 +836,7 @@ export function handleUsage(
   state.exchangeProviderName = providerName;
   state.exchangeLlmCallCount += 1;
   state.exchangeInputTokens += event.inputTokens;
+  state.lastCallInputTokens = event.inputTokens;
   state.exchangeCacheCreationInputTokens += event.cacheCreationInputTokens ?? 0;
   state.exchangeCacheReadInputTokens += event.cacheReadInputTokens ?? 0;
   state.exchangeOutputTokens += event.outputTokens;
@@ -932,10 +938,25 @@ export async function dispatchAgentEvent(
           "assistant_turn",
           deps.reqId,
         );
+
+        // Format web search results into a human-readable string for the client.
+        let resultText = "";
+        if (Array.isArray(event.content) && event.content.length > 0) {
+          resultText = (event.content as unknown[])
+            .filter(
+              (r): r is { type: string; title: string; url: string } =>
+                typeof r === "object" &&
+                r != null &&
+                (r as { type?: string }).type === "web_search_result",
+            )
+            .map((r) => `${r.title}\n${r.url}`)
+            .join("\n\n");
+        }
+
         deps.onEvent({
           type: "tool_result",
-          toolName: "",
-          result: "",
+          toolName: "web_search",
+          result: resultText,
           isError: event.isError,
           conversationId: deps.ctx.conversationId,
           toolUseId: event.toolUseId,