@vellumai/assistant 0.7.1 → 0.7.3

package/src/__tests__/config-watcher.test.ts

@@ -29,10 +29,19 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // ---------------------------------------------------------------------------
-// Capture fs.watch calls so we can simulate file system events deterministically
+// Capture fs.watch and fs.watchFile calls so we can simulate file system
+// events deterministically. Bun's libuv-based fs.watchFile is too unreliable
+// on Linux CI to test against directly: first-poll latency is ~5s and
+// back-to-back changes to different files frequently miss events. Driving
+// the captured listener bypasses libuv entirely while still exercising the
+// real ConfigWatcher dispatch logic.
 // ---------------------------------------------------------------------------
 
 type WatchCallback = (eventType: string, filename: string | null) => void;
+type WatchFileListener = (
+  curr: { ino: number; mtimeMs: number },
+  prev: { ino: number; mtimeMs: number },
+) => void;
 
 interface CapturedWatcher {
   dir: string;
@@ -40,10 +49,17 @@ interface CapturedWatcher {
   options?: { recursive?: boolean };
 }
 
+interface CapturedFileWatch {
+  filePath: string;
+  listener: WatchFileListener;
+}
+
 const capturedWatchers: CapturedWatcher[] = [];
+const capturedFileWatches: CapturedFileWatch[] = [];
 
 const fakeWatcher = {
   close: () => {},
+  on: (_event: string, _handler: (...args: unknown[]) => void) => fakeWatcher,
 };
 
 mock.module("node:fs", () => {
@@ -65,6 +81,18 @@ mock.module("node:fs", () => {
       capturedWatchers.push({ dir, callback, options });
       return fakeWatcher;
     },
+    watchFile: (filePath: string, ...args: unknown[]) => {
+      // Signature is `watchFile(path, [options], listener)` — skip the
+      // optional options arg so we always grab the listener.
+      const listener = (
+        typeof args[0] === "function" ? args[0] : args[1]
+      ) as WatchFileListener;
+      capturedFileWatches.push({ filePath, listener });
+    },
+    unwatchFile: (filePath: string) => {
+      const idx = capturedFileWatches.findIndex((w) => w.filePath === filePath);
+      if (idx !== -1) capturedFileWatches.splice(idx, 1);
+    },
   };
 });
 
@@ -92,8 +120,8 @@ mock.module("../providers/registry.js", () => ({
   initializeProviders: () => {},
 }));
 
-mock.module("../signals/mcp-reload.js", () => ({
-  handleMcpReloadSignal: () => {},
+mock.module("../daemon/mcp-reload-service.js", () => ({
+  reloadMcpServers: async () => {},
 }));
 
 mock.module("../signals/conversation-undo.js", () => ({
@@ -115,16 +143,52 @@ const { ConfigWatcher } = await import("../daemon/config-watcher.js");
 // Helpers
 // ---------------------------------------------------------------------------
 
-/** Find the watcher for a given directory path. */
-function findWatcher(dir: string): CapturedWatcher | undefined {
-  return capturedWatchers.find((w) => w.dir === dir);
+const TEST_DEBOUNCE_MS = 10;
+// Sleep budget to wait out the debouncer + any async handler work.
+const WAIT_MS = TEST_DEBOUNCE_MS + 50;
+
+function findWatcher(path: string): CapturedWatcher | undefined {
+  return capturedWatchers.find((w) => w.dir === path);
+}
+
+function findFileWatch(filePath: string): CapturedFileWatch | undefined {
+  return capturedFileWatches.find((w) => w.filePath === filePath);
+}
+
+const WORKSPACE_FILES = new Set(["config.json", "SOUL.md", "IDENTITY.md"]);
+
+// Each call advances the inode + mtime so the listener's early-return guard
+// (curr.ino === prev.ino && curr.mtimeMs === prev.mtimeMs) doesn't fire.
+let mtimeCounter = 1_000;
+const inoMap = new Map<string, number>();
+
+function nextStat(filePath: string): { ino: number; mtimeMs: number } {
+  const ino = (inoMap.get(filePath) ?? 0) + 1;
+  inoMap.set(filePath, ino);
+  mtimeCounter += 1;
+  return { ino, mtimeMs: mtimeCounter };
 }
 
-/** Simulate a file change event and flush the debounce timer. */
 function simulateFileChange(dir: string, filename: string): void {
-  const watcher = findWatcher(dir);
-  if (!watcher) throw new Error(`No watcher found for ${dir}`);
-  watcher.callback("change", filename);
+  if (dir === WORKSPACE_DIR && WORKSPACE_FILES.has(filename)) {
+    const filePath = join(dir, filename);
+    const fw = findFileWatch(filePath);
+    if (!fw) {
+      throw new Error(`No watchFile subscription for ${filePath}`);
+    }
+    const prev = {
+      ino: inoMap.get(filePath) ?? 0,
+      mtimeMs: mtimeCounter,
+    };
+    const curr = nextStat(filePath);
+    fw.listener(curr, prev);
+    return;
+  }
+  const dirWatcher = findWatcher(dir);
+  if (!dirWatcher) {
+    throw new Error(`No watcher found for directory ${dir}`);
+  }
+  dirWatcher.callback("change", filename);
 }
 
 // ---------------------------------------------------------------------------
@@ -143,8 +207,10 @@ const onConversationEvict = () => {
 
 beforeEach(() => {
   capturedWatchers.length = 0;
+  capturedFileWatches.length = 0;
+  inoMap.clear();
   evictCallCount = 0;
-  watcher = new ConfigWatcher();
+  watcher = new ConfigWatcher(undefined, TEST_DEBOUNCE_MS);
 });
 
 afterEach(() => {
@@ -155,51 +221,44 @@ describe("ConfigWatcher workspace file handlers", () => {
   test("SOUL.md change triggers onConversationEvict", async () => {
     watcher.start(onConversationEvict);
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");
-
-    // Wait for the debounce timer to fire (default 200ms)
-    await new Promise((r) => setTimeout(r, 300));
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(1);
   });
 
   test("IDENTITY.md change triggers onConversationEvict", async () => {
     watcher.start(onConversationEvict);
     simulateFileChange(WORKSPACE_DIR, "IDENTITY.md");
-
-    await new Promise((r) => setTimeout(r, 300));
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(1);
   });
 
-  test("UPDATES.md change does NOT trigger onConversationEvict", async () => {
+  test("UPDATES.md is not subscribed (only the registered handler set is)", () => {
     watcher.start(onConversationEvict);
-    simulateFileChange(WORKSPACE_DIR, "UPDATES.md");
-
-    await new Promise((r) => setTimeout(r, 300));
-    expect(evictCallCount).toBe(0);
+    // Per-file watching only registers config.json, SOUL.md, IDENTITY.md.
+    // The whole workspace dir must not be watched either — that was the
+    // ENXIO-on-Unix-sockets bug.
+    expect(findFileWatch(join(WORKSPACE_DIR, "UPDATES.md"))).toBeUndefined();
+    expect(findWatcher(WORKSPACE_DIR)).toBeUndefined();
   });
 
   test("config.json change calls refreshConfigFromSources", async () => {
     let refreshCalled = false;
     watcher.refreshConfigFromSources = async () => {
       refreshCalled = true;
-      return false; // no change, so onConversationEvict should NOT be called
+      return false;
     };
-
     watcher.start(onConversationEvict);
     simulateFileChange(WORKSPACE_DIR, "config.json");
-
-    await new Promise((r) => setTimeout(r, 300));
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(refreshCalled).toBe(true);
-    // Config didn't change (returned false), so no eviction
     expect(evictCallCount).toBe(0);
   });
 
   test("config.json change triggers onConversationEvict when config actually changed", async () => {
     watcher.refreshConfigFromSources = async () => true;
-
     watcher.start(onConversationEvict);
     simulateFileChange(WORKSPACE_DIR, "config.json");
-
-    await new Promise((r) => setTimeout(r, 300));
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(1);
   });
 
@@ -209,77 +268,89 @@ describe("ConfigWatcher workspace file handlers", () => {
       refreshCalled = true;
       return true;
     };
-
     watcher.suppressConfigReload = true;
     watcher.start(onConversationEvict);
     simulateFileChange(WORKSPACE_DIR, "config.json");
-
-    await new Promise((r) => setTimeout(r, 300));
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(refreshCalled).toBe(false);
     expect(evictCallCount).toBe(0);
   });
-
-  test("unknown file does not trigger any handler", async () => {
-    watcher.start(onConversationEvict);
-    simulateFileChange(WORKSPACE_DIR, "UNKNOWN.md");
-
-    await new Promise((r) => setTimeout(r, 300));
-    expect(evictCallCount).toBe(0);
-  });
-
-  test("null filename does not trigger any handler", async () => {
-    watcher.start(onConversationEvict);
-    const wsWatcher = findWatcher(WORKSPACE_DIR);
-    expect(wsWatcher).toBeDefined();
-    wsWatcher!.callback("change", null);
-
-    await new Promise((r) => setTimeout(r, 300));
-    expect(evictCallCount).toBe(0);
-  });
 });
 
 describe("ConfigWatcher watcher lifecycle", () => {
-  test("start registers workspace and signals watchers", () => {
+  test("start does NOT subscribe to /workspace as a directory (regression: ENXIO on Unix sockets)", () => {
     watcher.start(onConversationEvict);
-    const wsWatcher = findWatcher(WORKSPACE_DIR);
-    expect(wsWatcher).toBeDefined();
+    expect(findWatcher(WORKSPACE_DIR)).toBeUndefined();
+    // The per-file watchFile subscriptions are tracked separately from
+    // capturedWatchers; assert the expected ones are present.
+    expect(findFileWatch(join(WORKSPACE_DIR, "config.json"))).toBeDefined();
+    expect(findFileWatch(join(WORKSPACE_DIR, "SOUL.md"))).toBeDefined();
+    expect(findFileWatch(join(WORKSPACE_DIR, "IDENTITY.md"))).toBeDefined();
   });
 
-  test("stop cancels all debounce timers and clears watchers", () => {
+  test("stop cancels pending debounce work, no eviction fires after", async () => {
     watcher.start(onConversationEvict);
-    // Trigger a file change but don't wait for the debounce
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");
     watcher.stop();
-
-    // The debounce should have been cancelled, so no eviction
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(0);
   });
 
-  test("multiple prompt file changes are debounced", async () => {
+  test("multiple rapid changes to the same workspace file are coalesced to one eviction", async () => {
     watcher.start(onConversationEvict);
-
-    // Rapid fire multiple changes to the same file
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");
-
-    await new Promise((r) => setTimeout(r, 300));
-    // Despite 3 events, debouncing should collapse them to 1 call
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(1);
   });
 
   test("changes to different files each trigger their own handler", async () => {
     watcher.start(onConversationEvict);
-
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");
     simulateFileChange(WORKSPACE_DIR, "IDENTITY.md");
-
-    await new Promise((r) => setTimeout(r, 300));
-    // Each file has its own debounce key, so both should fire
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(2);
   });
 });
 
+describe("ConfigWatcher per-file polling listener", () => {
+  test("ino change is treated as a file change (atomic-rename shape)", async () => {
+    // Simulates `writeFile(tmp) + rename(tmp, target)`: the inode at the
+    // path is replaced. The listener should fire once per debounced window.
+    watcher.refreshConfigFromSources = async () => true;
+    watcher.start(onConversationEvict);
+    const fw = findFileWatch(join(WORKSPACE_DIR, "config.json"));
+    expect(fw).toBeDefined();
+    fw!.listener({ ino: 2, mtimeMs: 1_001 }, { ino: 1, mtimeMs: 1_000 });
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(evictCallCount).toBe(1);
+  });
+
+  test("mtime change is treated as a file change (in-place edit)", async () => {
+    watcher.refreshConfigFromSources = async () => true;
+    watcher.start(onConversationEvict);
+    const fw = findFileWatch(join(WORKSPACE_DIR, "config.json"));
+    expect(fw).toBeDefined();
+    // Same inode, different mtime — what an `echo >> file` produces.
+    fw!.listener({ ino: 1, mtimeMs: 2_000 }, { ino: 1, mtimeMs: 1_000 });
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(evictCallCount).toBe(1);
+  });
+
+  test("identical curr/prev does NOT fire (the early-return guard)", async () => {
+    // fs.watchFile sometimes invokes the listener with curr === prev
+    // (e.g. on initial subscription); the watcher must not re-fire in that case.
+    watcher.refreshConfigFromSources = async () => true;
+    watcher.start(onConversationEvict);
+    const fw = findFileWatch(join(WORKSPACE_DIR, "config.json"));
+    expect(fw).toBeDefined();
+    fw!.listener({ ino: 1, mtimeMs: 1_000 }, { ino: 1, mtimeMs: 1_000 });
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(evictCallCount).toBe(0);
+  });
+});
+
 describe("ConfigWatcher users directory watcher", () => {
   const USERS_DIR = join(WORKSPACE_DIR, "users");
 
@@ -287,7 +358,7 @@ describe("ConfigWatcher users directory watcher", () => {
     watcher.start(onConversationEvict);
     simulateFileChange(USERS_DIR, "alice.md");
 
-    await new Promise((r) => setTimeout(r, 300));
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(1);
   });
 
@@ -297,7 +368,7 @@ describe("ConfigWatcher users directory watcher", () => {
     simulateFileChange(USERS_DIR, "notes.txt");
     simulateFileChange(USERS_DIR, "README");
 
-    await new Promise((r) => setTimeout(r, 300));
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(0);
   });
 
@@ -307,7 +378,7 @@ describe("ConfigWatcher users directory watcher", () => {
     expect(usersWatcher).toBeDefined();
     usersWatcher!.callback("change", null);
 
-    await new Promise((r) => setTimeout(r, 300));
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(0);
   });
 
@@ -317,7 +388,7 @@ describe("ConfigWatcher users directory watcher", () => {
     simulateFileChange(USERS_DIR, "bob.md");
     simulateFileChange(USERS_DIR, "bob.md");
 
-    await new Promise((r) => setTimeout(r, 300));
+    await new Promise((r) => setTimeout(r, WAIT_MS));
     expect(evictCallCount).toBe(1);
   });
 });

package/src/__tests__/context-search-agent-runner.test.ts

@@ -65,7 +65,6 @@ function makeContext(
 ): RecallSearchContext {
   return {
     workingDir,
-    memoryScopeId: "scope-123",
     conversationId: "conv-xyz",
     config: {} as AssistantConfig,
     ...(signal ? { signal } : {}),
@@ -963,7 +962,14 @@ describe("runAgenticRecall", () => {
     ]);
   });
 
-  test("routes provider calls through the recall call site with temperature zero", async () => {
+  test("routes provider calls through the recall call site with temperature zero and thinking disabled", async () => {
+    // `thinking: disabled` is required because the call hardcodes
+    // `temperature: 0`. Anthropic 400s on `temperature` ≠ 1 whenever
+    // thinking is enabled or in adaptive mode, so user profiles that
+    // resolve thinking-enabled (Opus 4.x at `effort: high|xhigh`, etc.)
+    // would fail without an explicit opt-out. Recall is tool-call-heavy
+    // reasoning where determinism (temp=0) matters more than extended
+    // chain-of-thought.
     const providerCalls: unknown[][] = [];
     configuredProvider = makeProvider(
       [textResponse("not a tool call")],
@@ -992,7 +998,59 @@ describe("runAgenticRecall", () => {
     expect(options.config).toEqual({
       callSite: "recall",
       temperature: 0,
+      thinking: { type: "disabled" },
+    });
+  });
+
+  test("final finish-only call also disables thinking", async () => {
+    // Regression guard for the second `temperature: 0` call site in
+    // `tryFinalFinishRecall`. Both recall provider calls (the agent loop
+    // round and the fallback finalize) must opt out of thinking; otherwise
+    // user profiles that resolve thinking-enabled trigger the Anthropic
+    // 400 on `temperature` ≠ 1.
+    const providerCalls: unknown[][] = [];
+    configuredProvider = makeProvider(
+      [
+        // First call: agent loop round — emits a search_sources tool use
+        // so the loop continues until the round budget is exhausted.
+        toolResponse("search_sources", {
+          query: "more notes",
+          sources: ["workspace"],
+          reason: "Need more.",
+        }),
+        // Second call: fallback finalize — handler we want to assert on.
+        toolResponse("finish_recall", {
+          answer: "Resolved.",
+          confidence: "medium",
+          citation_ids: ["workspace:more"],
+        }),
+      ],
+      providerCalls,
+    );
+
+    await runAgenticRecall(
+      { query: "launch notes", sources: ["workspace"], depth: "fast" },
+      makeContext(),
+      {
+        searchOptions: {
+          adapters: [
+            makeAdapter({
+              "launch notes": [makeEvidence("workspace:seed")],
+              "more notes": [makeEvidence("workspace:more")],
+            }),
+          ],
+        },
+      },
+    );
+
+    expect(providerCalls).toHaveLength(2);
+    const finalizeOptions = providerCalls[1]?.[3] as {
+      config?: Record<string, unknown>;
+    };
+    expect(finalizeOptions.config).toEqual({
+      callSite: "recall",
+      temperature: 0,
+      thinking: { type: "disabled" },
     });
-    expect(options.config).not.toHaveProperty("thinking");
   });
 });

package/src/__tests__/context-search-conversations-source.test.ts

@@ -68,29 +68,6 @@ describe("searchConversationSource", () => {
     ]);
   });
 
-  test("filters results to the requested memory scope", async () => {
-    const inScope = await seedConversation({
-      title: "In-scope conversation",
-      memoryScopeId: "scope-a",
-      content: "sharedtoken belongs to scope A.",
-    });
-    await seedConversation({
-      title: "Out-of-scope conversation",
-      memoryScopeId: "scope-b",
-      content: "sharedtoken belongs to scope B.",
-    });
-
-    const result = await searchConversationSource(
-      "sharedtoken",
-      makeContext({ memoryScopeId: "scope-a" }),
-      10,
-    );
-
-    expect(result.evidence.map((item) => item.locator)).toEqual([
-      `${inScope.conversation.id}#${inScope.message.id}`,
-    ]);
-  });
-
   test("does not return derived subagent or auto-analysis conversations", async () => {
     const visible = await seedConversation({
       title: "User conversation",
@@ -312,7 +289,6 @@ function makeContext(
 ): RecallSearchContext {
   return {
     workingDir: "/tmp/example-workspace",
-    memoryScopeId: "default",
     conversationId: "current-conversation",
     config: {} as RecallSearchContext["config"],
     ...overrides,

package/src/__tests__/context-search-fanout.test.ts

@@ -14,7 +14,6 @@ import type {
 function makeContext(): RecallSearchContext {
   return {
     workingDir: "/workspace",
-    memoryScopeId: "scope-123",
     conversationId: "conv-xyz",
     config: {} as AssistantConfig,
   };

package/src/__tests__/context-search-memory-source.test.ts

@@ -69,7 +69,6 @@ mock.module(embeddingBackendModule, () => ({
 type SearchCall = {
   vector: number[];
   limit: number;
-  scopeIds?: string[];
   sparseVector?: { indices: number[]; values: number[] };
 };
 
@@ -81,10 +80,9 @@ mock.module(graphSearchModule, () => ({
   searchGraphNodes: async (
     vector: number[],
     limit: number,
-    scopeIds?: string[],
     sparseVector?: { indices: number[]; values: number[] },
   ) => {
-    searchCalls.push({ vector, limit, scopeIds, sparseVector });
+    searchCalls.push({ vector, limit, sparseVector });
     if (searchShouldThrow) {
       throw new Error("qdrant unavailable");
     }
@@ -205,13 +203,13 @@ describe("searchMemorySource", () => {
     expect(second.lastAccessed).toBe(222);
   });
 
-  test("forwards memory scope and abort signal to graph search dependencies", async () => {
+  test("forwards abort signal to graph search dependencies", async () => {
     const controller = new AbortController();
     searchHits = [];
 
     await searchMemorySource(
       "deployment checklist",
-      makeContext({ memoryScopeId: "scope-abc", signal: controller.signal }),
+      makeContext({ signal: controller.signal }),
       3,
     );
 
@@ -226,7 +224,6 @@ describe("searchMemorySource", () => {
     expect(searchCalls[0]).toMatchObject({
       vector: [0.1, 0.2, 0.3],
       limit: 3,
-      scopeIds: ["scope-abc"],
     });
     expect(searchCalls[0]?.sparseVector?.indices.length).toBeGreaterThan(0);
   });
@@ -389,7 +386,6 @@ function makeContext(
 ): RecallSearchContext {
   return {
     workingDir: "/tmp/example-workspace",
-    memoryScopeId: "scope-default",
     conversationId: "conv-123",
     config: {} as AssistantConfig,
     ...overrides,

package/src/__tests__/context-search-memory-v2-source.test.ts

@@ -148,7 +148,6 @@ function makeConfig(): AssistantConfig {
         c_assistant: 0.5,
         c_now: 0.5,
         top_k: 8,
-        top_k_skills: 0,
       },
     },
   } as unknown as AssistantConfig;
@@ -157,7 +156,6 @@ function makeConfig(): AssistantConfig {
 function makeContext(workingDir: string): RecallSearchContext {
   return {
     workingDir,
-    memoryScopeId: "scope-default",
     conversationId: "conv-test",
     config: makeConfig(),
   };

package/src/__tests__/context-search-pkb-source.test.ts

@@ -173,7 +173,6 @@ function makeContext(
 ): RecallSearchContext {
   return {
     workingDir: "/workspace",
-    memoryScopeId: "active-conversation-scope",
     conversationId: "conv-xyz",
     config: {} as AssistantConfig,
     ...overrides,

package/src/__tests__/context-search-workspace-source.test.ts

@@ -38,7 +38,6 @@ function makeTempDir(): string {
 function makeContext(workingDir: string): RecallSearchContext {
   return {
     workingDir,
-    memoryScopeId: "scope-123",
     conversationId: "conversation-123",
     config: {} as AssistantConfig,
   };

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -1,12 +1,18 @@
 import { describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type {
   ContentBlock,
   Message,
   ProviderResponse,
 } from "../providers/types.js";
 
+// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
+// (registry default `true`) flips memory routing to v2 — disable it here so
+// the v1 paths under test stay active.
+_setOverridesForTesting({ "memory-v2-enabled": false });
+
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),