@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/config-sounds-sync.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test";
+
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import {
+  publishConfigChanged,
+  publishSchedulesChanged,
+  publishSoundsConfigUpdated,
+} from "../runtime/sync/resource-sync-events.js";
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 500;
+  while (Date.now() < deadline) {
+    if (predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for config/sounds sync event");
+}
+
+describe("config and sounds sync events", () => {
+  test("config changes emit legacy config event and sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      publishConfigChanged();
+      await waitFor(() => received.length === 2);
+
+      expect(received.map((event) => event.message.type)).toEqual([
+        "config_changed",
+        "sync_changed",
+      ]);
+      expect(received[1].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantConfig],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("sounds config changes emit legacy sounds event and sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      publishSoundsConfigUpdated();
+      await waitFor(() => received.length === 2);
+
+      expect(received.map((event) => event.message.type)).toEqual([
+        "sounds_config_updated",
+        "sync_changed",
+      ]);
+      expect(received[1].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantSounds],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("schedule changes emit a sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      publishSchedulesChanged();
+      await waitFor(() => received.length === 1);
+
+      expect(received[0].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantSchedules],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+});

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

@@ -0,0 +1,453 @@
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+const WORKSPACE_DIR = mkdtempSync(join(tmpdir(), "vellum-skills-watch-"));
+const SKILLS_DIR = join(WORKSPACE_DIR, "skills");
+process.env.VELLUM_WORKSPACE_DIR = WORKSPACE_DIR;
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (v: string) => v,
+}));
+
+type WatchCallback = (eventType: string, filename: string | null) => void;
+
+interface CapturedWatcher {
+  dir: string;
+  callback: WatchCallback;
+  closed: boolean;
+}
+
+const capturedWatchers: CapturedWatcher[] = [];
+let recursiveWatchAvailable = false;
+
+mock.module("node:fs", () => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const actual = require("node:fs");
+  return {
+    ...actual,
+    watch: (dir: string, ...args: unknown[]) => {
+      let callback: WatchCallback;
+
+      if (typeof args[0] === "function") {
+        callback = args[0] as WatchCallback;
+      } else {
+        if (
+          (args[0] as { recursive?: boolean } | undefined)?.recursive &&
+          !recursiveWatchAvailable
+        ) {
+          throw new Error("recursive watch unavailable");
+        }
+        callback = args[1] as WatchCallback;
+      }
+
+      const capturedWatcher: CapturedWatcher = {
+        dir,
+        callback,
+        closed: false,
+      };
+      capturedWatchers.push(capturedWatcher);
+      return {
+        close: () => {
+          capturedWatcher.closed = true;
+        },
+        on: () => {},
+      };
+    },
+  };
+});
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    memory: { v2: { enabled: false } },
+  }),
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../memory/embedding-backend.js", () => ({
+  clearEmbeddingBackendCache: () => {},
+}));
+
+mock.module("../memory/cleanup-schedule-state.js", () => ({
+  resetCleanupScheduleThrottle: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  initializeProviders: async () => {},
+}));
+
+mock.module("../daemon/mcp-reload-service.js", () => ({
+  reloadMcpServers: async () => {},
+}));
+
+mock.module("../signals/bash.js", () => ({
+  handleBashSignal: () => {},
+}));
+
+mock.module("../signals/cancel.js", () => ({
+  handleCancelSignal: () => {},
+}));
+
+mock.module("../signals/conversation-undo.js", () => ({
+  handleConversationUndoSignal: () => {},
+}));
+
+mock.module("../signals/emit-event.js", () => ({
+  handleEmitEventSignal: () => {},
+}));
+
+mock.module("../signals/user-message.js", () => ({
+  handleUserMessageSignal: () => {},
+}));
+
+const { ConfigWatcher } = await import("../daemon/config-watcher.js");
+
+function findWatcher(dir: string): CapturedWatcher | undefined {
+  return capturedWatchers.find((w) => w.dir === dir && !w.closed);
+}
+
+function findCapturedWatcher(dir: string): CapturedWatcher | undefined {
+  return capturedWatchers.find((w) => w.dir === dir);
+}
+
+function capturedWatcherCount(dir: string): number {
+  return capturedWatchers.filter((w) => w.dir === dir).length;
+}
+
+describe("ConfigWatcher skills watcher reseeding", () => {
+  let watcher: InstanceType<typeof ConfigWatcher>;
+  let evictCalls: number;
+  let skillsChangedCalls: number;
+
+  beforeEach(() => {
+    capturedWatchers.length = 0;
+    recursiveWatchAvailable = false;
+    rmSync(SKILLS_DIR, { recursive: true, force: true });
+    mkdirSync(SKILLS_DIR, { recursive: true });
+    evictCalls = 0;
+    skillsChangedCalls = 0;
+    watcher = new ConfigWatcher();
+  });
+
+  afterEach(() => {
+    watcher.stop();
+  });
+
+  afterAll(() => {
+    rmSync(WORKSPACE_DIR, { recursive: true, force: true });
+  });
+
+  test("watched skill file changes evict conversations and refresh skill memories", async () => {
+    watcher.start(
+      () => {
+        evictCalls++;
+      },
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        skillsChangedCalls++;
+      },
+    );
+
+    const skillsWatcher = findWatcher(SKILLS_DIR);
+    expect(skillsWatcher).toBeDefined();
+    skillsWatcher!.callback("change", "example-skill/SKILL.md");
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(1);
+    expect(skillsChangedCalls).toBe(1);
+  });
+
+  test("recursive watcher ignores skipped dependency and staging paths", async () => {
+    recursiveWatchAvailable = true;
+
+    watcher.start(
+      () => {
+        evictCalls++;
+      },
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        skillsChangedCalls++;
+      },
+    );
+
+    const skillsWatcher = findWatcher(SKILLS_DIR);
+    expect(skillsWatcher).toBeDefined();
+    skillsWatcher!.callback(
+      "change",
+      "example-skill/node_modules/pkg/index.js",
+    );
+    skillsWatcher!.callback(
+      "change",
+      ".install-staging/example-skill/SKILL.md",
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(0);
+    expect(skillsChangedCalls).toBe(0);
+
+    skillsWatcher!.callback("change", "example-skill/references/foo.md");
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(1);
+    expect(skillsChangedCalls).toBe(1);
+  });
+
+  test("recursive watcher reloads skill memories for build output changes", async () => {
+    recursiveWatchAvailable = true;
+
+    watcher.start(
+      () => {
+        evictCalls++;
+      },
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        skillsChangedCalls++;
+      },
+    );
+
+    const skillsWatcher = findWatcher(SKILLS_DIR);
+    expect(skillsWatcher).toBeDefined();
+    skillsWatcher!.callback("change", "example-skill/dist/index.js");
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(1);
+    expect(skillsChangedCalls).toBe(1);
+  });
+
+  test("coalesces multiple skill file changes into one catalog refresh", async () => {
+    watcher.start(
+      () => {
+        evictCalls++;
+      },
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        skillsChangedCalls++;
+      },
+    );
+
+    const skillsWatcher = findWatcher(SKILLS_DIR);
+    expect(skillsWatcher).toBeDefined();
+    skillsWatcher!.callback("change", "example-skill/SKILL.md");
+    skillsWatcher!.callback("change", "example-skill/package.json");
+    skillsWatcher!.callback("change", "other-skill/SKILL.md");
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(1);
+    expect(skillsChangedCalls).toBe(1);
+  });
+
+  test("fallback watches existing nested skill directories", async () => {
+    const referencesDir = join(SKILLS_DIR, "example-skill", "references");
+    mkdirSync(referencesDir, { recursive: true });
+
+    watcher.start(
+      () => {
+        evictCalls++;
+      },
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        skillsChangedCalls++;
+      },
+    );
+
+    const referencesWatcher = findWatcher(referencesDir);
+    expect(referencesWatcher).toBeDefined();
+    referencesWatcher!.callback("change", "notes.md");
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(1);
+    expect(skillsChangedCalls).toBe(1);
+  });
+
+  test("fallback skips dependency and staging directories", async () => {
+    const skillDir = join(SKILLS_DIR, "example-skill");
+    const nodeModulesDir = join(skillDir, "node_modules");
+    const dependencyDir = join(nodeModulesDir, "pkg");
+    const stagingDir = join(SKILLS_DIR, ".install-staging");
+    const stagedSkillDir = join(stagingDir, "example-skill");
+    const referencesDir = join(skillDir, "references");
+    mkdirSync(dependencyDir, { recursive: true });
+    mkdirSync(stagedSkillDir, { recursive: true });
+    mkdirSync(referencesDir, { recursive: true });
+
+    watcher.start(
+      () => {
+        evictCalls++;
+      },
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        skillsChangedCalls++;
+      },
+    );
+
+    expect(findWatcher(nodeModulesDir)).toBeUndefined();
+    expect(findWatcher(dependencyDir)).toBeUndefined();
+    expect(findWatcher(stagingDir)).toBeUndefined();
+    expect(findWatcher(stagedSkillDir)).toBeUndefined();
+
+    const skillsWatcher = findWatcher(SKILLS_DIR);
+    const skillWatcher = findWatcher(skillDir);
+    expect(skillsWatcher).toBeDefined();
+    expect(skillWatcher).toBeDefined();
+
+    skillsWatcher!.callback("rename", ".install-staging");
+    skillWatcher!.callback("rename", "node_modules");
+    skillWatcher!.callback("change", "node_modules/pkg/index.js");
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(0);
+    expect(skillsChangedCalls).toBe(0);
+
+    const referencesWatcher = findWatcher(referencesDir);
+    expect(referencesWatcher).toBeDefined();
+    referencesWatcher!.callback("change", "foo.md");
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(1);
+    expect(skillsChangedCalls).toBe(1);
+  });
+
+  test("fallback watches skill build output directories", async () => {
+    const distDir = join(SKILLS_DIR, "example-skill", "dist");
+    const buildDir = join(SKILLS_DIR, "example-skill", "build");
+    mkdirSync(distDir, { recursive: true });
+    mkdirSync(buildDir, { recursive: true });
+
+    watcher.start(
+      () => {
+        evictCalls++;
+      },
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        skillsChangedCalls++;
+      },
+    );
+
+    const distWatcher = findWatcher(distDir);
+    const buildWatcher = findWatcher(buildDir);
+    expect(distWatcher).toBeDefined();
+    expect(buildWatcher).toBeDefined();
+
+    distWatcher!.callback("change", "index.js");
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(1);
+    expect(skillsChangedCalls).toBe(1);
+
+    buildWatcher!.callback("change", "tool.js");
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(evictCalls).toBe(2);
+    expect(skillsChangedCalls).toBe(2);
+  });
+
+  test("fallback adds watchers for new nested skill directories without duplicates", () => {
+    const skillDir = join(SKILLS_DIR, "example-skill");
+    const toolsDir = join(skillDir, "tools");
+    const generatedDir = join(toolsDir, "generated");
+    mkdirSync(skillDir, { recursive: true });
+
+    watcher.start(
+      () => {
+        evictCalls++;
+      },
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        skillsChangedCalls++;
+      },
+    );
+
+    const skillWatcher = findWatcher(skillDir);
+    expect(skillWatcher).toBeDefined();
+
+    mkdirSync(generatedDir, { recursive: true });
+    skillWatcher!.callback("rename", "tools");
+    skillWatcher!.callback("rename", "tools");
+
+    expect(findWatcher(toolsDir)).toBeDefined();
+    expect(findWatcher(generatedDir)).toBeDefined();
+    expect(capturedWatcherCount(toolsDir)).toBe(1);
+    expect(capturedWatcherCount(generatedDir)).toBe(1);
+  });
+
+  test("fallback closes stale nested watchers when directories are removed", () => {
+    const skillDir = join(SKILLS_DIR, "example-skill");
+    const referencesDir = join(skillDir, "references");
+    const deepDir = join(referencesDir, "deep");
+    mkdirSync(deepDir, { recursive: true });
+
+    watcher.start(
+      () => {
+        evictCalls++;
+      },
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        skillsChangedCalls++;
+      },
+    );
+
+    expect(findWatcher(referencesDir)).toBeDefined();
+    expect(findWatcher(deepDir)).toBeDefined();
+
+    rmSync(referencesDir, { recursive: true, force: true });
+    const skillWatcher = findWatcher(skillDir);
+    expect(skillWatcher).toBeDefined();
+    skillWatcher!.callback("rename", "references");
+
+    expect(findWatcher(referencesDir)).toBeUndefined();
+    expect(findWatcher(deepDir)).toBeUndefined();
+    expect(findCapturedWatcher(referencesDir)?.closed).toBe(true);
+    expect(findCapturedWatcher(deepDir)?.closed).toBe(true);
+  });
+});

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

@@ -5,6 +5,7 @@ import type { RecallSearchContext } from "../memory/context-search/types.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { rawRun } from "../memory/raw-query.js";
+import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 initializeDb();
 
 let seedId = 0;
@@ -225,6 +226,99 @@ describe("searchConversationSource", () => {
     );
   });
 
+  test("preserves external_content boundaries in recall evidence", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Slack recall",
+      content:
+        '<external_content source="slack" origin="@alice">\nThe recalltoken decision came from Slack.\n</external_content>',
+    });
+
+    const result = await searchConversationSource(
+      "recalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt:
+        '<external_content source="slack" origin="@alice">\nThe recalltoken decision came from Slack.\n</external_content>',
+    });
+  });
+
+  test("wraps raw non-guardian Slack recall evidence from metadata", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Raw Slack recall",
+      role: "user",
+      content: "The rawrecalltoken decision came from Slack.",
+      metadata: slackMetadata("1700000100.000000", {
+        provenanceTrustClass: "unknown",
+      }),
+    });
+
+    const result = await searchConversationSource(
+      "rawrecalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt:
+        '<external_content source="slack" origin="@alice">\nThe rawrecalltoken decision came from Slack.\n</external_content>',
+    });
+  });
+
+  test("wraps raw non-guardian Slack recall evidence that mentions external_content", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Raw Slack tag mention recall",
+      role: "user",
+      content:
+        "The tagmentionrecalltoken text mentions <external_content but is raw Slack content.",
+      metadata: slackMetadata("1700000102.000000", {
+        provenanceTrustClass: "unknown",
+      }),
+    });
+
+    const result = await searchConversationSource(
+      "tagmentionrecalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt:
+        '<external_content source="slack" origin="@alice">\nThe tagmentionrecalltoken text mentions <external_content but is raw Slack content.\n</external_content>',
+    });
+  });
+
+  test("does not wrap guardian Slack recall evidence", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Guardian Slack recall",
+      role: "user",
+      content: "The guardianrecalltoken decision came from Slack.",
+      metadata: slackMetadata("1700000101.000000", {
+        provenanceTrustClass: "guardian",
+      }),
+    });
+
+    const result = await searchConversationSource(
+      "guardianrecalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt: "The guardianrecalltoken decision came from Slack.",
+    });
+  });
+
   test("broadens overconstrained recall queries to salient terms", async () => {
     const specific = await seedConversation({
       title: "Birthday cake plan",
@@ -258,6 +352,7 @@ function seedConversation(opts: {
   memoryScopeId?: string;
   role?: string;
   content: string;
+  metadata?: string;
 }) {
   const id = ++seedId;
   const now = Date.now() + id;
@@ -297,19 +392,39 @@ function seedConversation(opts: {
       conversation_id,
       role,
       content,
-      created_at
-    ) VALUES (?, ?, ?, ?, ?)
+      created_at,
+      metadata
+    ) VALUES (?, ?, ?, ?, ?, ?)
     `,
     message.id,
     conversation.id,
     opts.role ?? "assistant",
     opts.content,
     now,
+    opts.metadata ?? null,
   );
 
   return { conversation, message };
 }
 
+function slackMetadata(
+  channelTs: string,
+  extra: Record<string, unknown>,
+): string {
+  return JSON.stringify({
+    userMessageChannel: "slack",
+    assistantMessageChannel: "slack",
+    slackMeta: writeSlackMetadata({
+      source: "slack",
+      channelId: "C0123",
+      channelTs,
+      eventKind: "message",
+      displayName: "@alice",
+    }),
+    ...extra,
+  });
+}
+
 function makeContext(
   overrides: Partial<RecallSearchContext> = {},
 ): RecallSearchContext {

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

@@ -41,7 +41,6 @@ mock.module("../memory/embedding-backend.js", () => ({
     model: "test-model",
     vectors: [denseEmbedReturn],
   }),
-  generateSparseEmbedding: () => ({ indices: [1], values: [1] }),
 }));
 
 interface QdrantHit {