@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/compactor-tail-resolution.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "bun:test";
+
+import { canonicalDateTimeKey } from "../context/compactor.js";
+
+describe("canonicalDateTimeKey", () => {
+  const stored = "2026-04-02 (Thursday) 01:52:33 -05:00 (America/Chicago)";
+
+  it("reduces the verbatim stored format to date+time", () => {
+    expect(canonicalDateTimeKey(stored)).toBe("2026-04-02T01:52:33");
+  });
+
+  it("matches when the model drops the weekday parens", () => {
+    expect(
+      canonicalDateTimeKey("2026-04-02 01:52:33 -05:00 (America/Chicago)"),
+    ).toBe("2026-04-02T01:52:33");
+  });
+
+  it("matches when the model drops the timezone parens", () => {
+    expect(canonicalDateTimeKey("2026-04-02 (Thursday) 01:52:33 -05:00")).toBe(
+      "2026-04-02T01:52:33",
+    );
+  });
+
+  it("matches when the model emits ISO-8601 with a T separator", () => {
+    expect(canonicalDateTimeKey("2026-04-02T01:52:33-05:00")).toBe(
+      "2026-04-02T01:52:33",
+    );
+  });
+
+  it("matches when the model emits only date and time", () => {
+    expect(canonicalDateTimeKey("2026-04-02 01:52:33")).toBe(
+      "2026-04-02T01:52:33",
+    );
+  });
+
+  it("returns null when no date+time pair is present", () => {
+    expect(canonicalDateTimeKey("hello world")).toBeNull();
+    expect(canonicalDateTimeKey("2026-04-02")).toBeNull();
+    expect(canonicalDateTimeKey("01:52:33")).toBeNull();
+  });
+});

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

@@ -361,6 +361,27 @@ describe("AssistantConfigSchema", () => {
     });
   });
 
+  test("scratchpad injection defaults to enabled", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.memory.retrieval.scratchpadInjection).toEqual({
+      enabled: true,
+    });
+  });
+
+  test("scratchpad injection accepts disabled override", () => {
+    const result = AssistantConfigSchema.parse({
+      memory: { retrieval: { scratchpadInjection: { enabled: false } } },
+    });
+    expect(result.memory.retrieval.scratchpadInjection.enabled).toBe(false);
+  });
+
+  test("scratchpad injection rejects non-boolean enabled", () => {
+    const result = AssistantConfigSchema.safeParse({
+      memory: { retrieval: { scratchpadInjection: { enabled: "yes" } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
   test("applies memory.cleanup defaults", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.memory.cleanup).toEqual({

package/src/__tests__/config-set-route.test.ts

@@ -27,6 +27,8 @@ mock.module("../config/loader.js", () => ({
   deepMergeOverwrite: () => {},
   getConfig: () => rawConfig,
   invalidateConfigCache: () => {},
+  withSuppressedConfigDiskWrites: async (fn: () => unknown) => fn(),
+  withSuppressedConfigDiskWritesSync: (fn: () => unknown) => fn(),
   // setNestedValue is also exported by loader; handleSetConfig imports the
   // real one from this module, so we re-export a thin implementation that
   // mutates in place (matches loader's behavior).
@@ -143,6 +145,84 @@ describe("config_set route - request validation", () => {
       .calls as Record<string, unknown>;
     expect(calls.enabled).toBe(true);
   });
+
+  test("preserves user profiles and custom settings when setting unrelated key", async () => {
+    rawConfig = {
+      llm: {
+        activeProfile: "my-custom-profile",
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+          },
+          "my-custom-profile": {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-opus-4-6",
+            maxTokens: 32000,
+          },
+        },
+      },
+      memory: {
+        embeddings: { provider: "openai" },
+      },
+    };
+    savedRaw = null;
+    const result = await configSetRoute.handler({
+      body: {
+        path: "memory.cleanup.llmRequestLogRetentionMs",
+        value: 86400000,
+      },
+    });
+    expect(result).toEqual({ ok: true });
+    expect(savedRaw).not.toBeNull();
+
+    const saved = savedRaw as unknown as Record<string, unknown>;
+    const llm = saved.llm as Record<string, unknown>;
+    expect(llm.activeProfile).toBe("my-custom-profile");
+
+    const profiles = llm.profiles as Record<string, Record<string, unknown>>;
+    expect(profiles["my-custom-profile"]).toEqual({
+      source: "user",
+      provider: "anthropic",
+      model: "claude-opus-4-6",
+      maxTokens: 32000,
+    });
+    expect(profiles.balanced).toEqual({
+      source: "managed",
+      provider: "anthropic",
+      model: "claude-sonnet-4-6",
+    });
+
+    const memory = saved.memory as Record<string, unknown>;
+    expect((memory.embeddings as Record<string, unknown>).provider).toBe(
+      "openai",
+    );
+    expect(
+      (memory.cleanup as Record<string, unknown>).llmRequestLogRetentionMs,
+    ).toBe(86400000);
+  });
+
+  test("preserves all top-level keys when setting a nested path", async () => {
+    rawConfig = {
+      llm: { default: { provider: "anthropic" } },
+      calls: { enabled: true },
+      heartbeat: { activeHoursStart: "09:00", activeHoursEnd: "22:00" },
+    };
+    savedRaw = null;
+    await configSetRoute.handler({
+      body: { path: "memory.cleanup.conversationRetentionDays", value: 30 },
+    });
+    expect(savedRaw).not.toBeNull();
+    const saved = savedRaw as unknown as Record<string, unknown>;
+    expect(saved.llm).toEqual({ default: { provider: "anthropic" } });
+    expect(saved.calls).toEqual({ enabled: true });
+    expect(saved.heartbeat).toEqual({
+      activeHoursStart: "09:00",
+      activeHoursEnd: "22:00",
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------

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);
+  });
+});