@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/update-bulletin-format.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, test } from "bun:test";
 import {
   appendReleaseBlock,
   extractReleaseIds,
+  filterNewContentBlocks,
   hasReleaseBlock,
   releaseMarker,
 } from "../prompts/update-bulletin-format.js";
@@ -83,6 +84,64 @@ describe("appendReleaseBlock", () => {
   });
 });
 
+describe("filterNewContentBlocks", () => {
+  const blockA = [
+    "<!-- vellum-update-release:entry-a -->",
+    "## Entry A",
+    "Content for A.",
+    "<!-- /vellum-update-release:entry-a -->",
+  ].join("\n");
+
+  const blockB = [
+    "<!-- vellum-update-release:entry-b -->",
+    "## Entry B",
+    "Content for B.",
+    "<!-- /vellum-update-release:entry-b -->",
+  ].join("\n");
+
+  const blockC = [
+    "<!-- vellum-update-release:entry-c -->",
+    "## Entry C",
+    "Content for C.",
+    "<!-- /vellum-update-release:entry-c -->",
+  ].join("\n");
+
+  test("returns body unchanged when no block structure exists", () => {
+    const body = "## What's New\n\nPlain text notes.\n";
+    expect(filterNewContentBlocks(body, "anything")).toBe(body);
+  });
+
+  test("returns all blocks when none are present in existing content", () => {
+    const body = `${blockA}\n\n${blockB}`;
+    const result = filterNewContentBlocks(body, "no markers here");
+    expect(result).toContain("entry-a");
+    expect(result).toContain("entry-b");
+  });
+
+  test("returns empty string when all blocks are already present", () => {
+    const body = `${blockA}\n\n${blockB}`;
+    const existing = `<!-- vellum-update-release:0.9.0 -->\n${blockA}\n\n${blockB}\n`;
+    expect(filterNewContentBlocks(body, existing)).toBe("");
+  });
+
+  test("returns only new blocks when some are already present", () => {
+    const body = `${blockA}\n\n${blockB}\n\n${blockC}`;
+    const existing = `<!-- vellum-update-release:0.9.0 -->\n${blockA}\n\n${blockB}\n`;
+
+    const result = filterNewContentBlocks(body, existing);
+    expect(result).toContain("entry-c");
+    expect(result).toContain("Content for C.");
+    expect(result).not.toContain("entry-a");
+    expect(result).not.toContain("entry-b");
+  });
+
+  test("handles single-block template", () => {
+    const result = filterNewContentBlocks(blockA, "no markers");
+    expect(result).toContain("entry-a");
+    expect(result).toContain("Content for A.");
+  });
+});
+
 describe("extractReleaseIds", () => {
   test("returns all version strings from multiple markers", () => {
     const content = [

package/src/__tests__/update-bulletin.test.ts

@@ -31,6 +31,13 @@ mock.module("../memory/checkpoints.js", () => ({
   ),
 }));
 
+// --- Mutable config stub for updates.enabled tests ---
+const updatesConfig = { enabled: true };
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ updates: updatesConfig }),
+}));
+
 // --- Temp directory for template files ---
 // Avoids mutating the real source-controlled UPDATES.md template, preventing
 // race conditions with parallel test execution and working tree corruption
@@ -60,6 +67,7 @@ const COMMENT_ONLY_TEMPLATE =
 describe("syncUpdateBulletinOnStartup", () => {
   beforeEach(() => {
     store.clear();
+    updatesConfig.enabled = true;
     // Remove any leftover workspace UPDATES.md from a previous test
     if (existsSync(workspacePath)) {
       rmSync(workspacePath);
@@ -92,6 +100,18 @@ describe("syncUpdateBulletinOnStartup", () => {
     expect(content).toContain("What's New");
   });
 
+  it("skips materialization entirely when updates.enabled is false", () => {
+    updatesConfig.enabled = false;
+    expect(existsSync(workspacePath)).toBe(false);
+
+    syncUpdateBulletinOnStartup();
+
+    expect(existsSync(workspacePath)).toBe(false);
+    // No checkpoint writes should have happened either.
+    expect(store.get("updates:active_releases")).toBeUndefined();
+    expect(store.get("updates:completed_releases")).toBeUndefined();
+  });
+
   it("appends release block when workspace file exists without current marker", () => {
     const preExisting =
       "<!-- vellum-update-release:0.9.0 -->\nOld release notes.\n";
@@ -133,28 +153,34 @@ describe("syncUpdateBulletinOnStartup", () => {
   });
 
   it("marks active releases as completed when UPDATES.md is deleted", () => {
-    // Pre-populate active releases in the store
-    store.set("updates:active_releases", JSON.stringify(["0.8.0", "0.9.0"]));
+    // Pre-populate active releases including the current one — simulates
+    // a normal session where 1.0.0 was materialized alongside leftover
+    // entries from prior versions.
+    store.set(
+      "updates:active_releases",
+      JSON.stringify(["0.8.0", "0.9.0", "1.0.0"]),
+    );
 
     // Workspace file does not exist — simulates the assistant having deleted it
     expect(existsSync(workspacePath)).toBe(false);
 
     syncUpdateBulletinOnStartup();
 
-    // Active set should be cleared (except for the newly-added current release)
+    // Active set should be cleared
     const activeRaw = store.get("updates:active_releases");
     expect(activeRaw).toBeDefined();
     const active: string[] = JSON.parse(activeRaw!);
-    // The old releases should not be in the active set
     expect(active).not.toContain("0.8.0");
     expect(active).not.toContain("0.9.0");
+    expect(active).not.toContain("1.0.0");
 
-    // The old releases should now be completed
+    // All releases should now be completed
     const completedRaw = store.get("updates:completed_releases");
     expect(completedRaw).toBeDefined();
     const completed: string[] = JSON.parse(completedRaw!);
     expect(completed).toContain("0.8.0");
     expect(completed).toContain("0.9.0");
+    expect(completed).toContain("1.0.0");
   });
 
   it("does not recreate completed release after deletion", () => {
@@ -173,6 +199,82 @@ describe("syncUpdateBulletinOnStartup", () => {
     expect(existsSync(workspacePath)).toBe(false);
   });
 
+  it("treats an empty UPDATES.md as dismissal of the current release", () => {
+    // Pre-populate active so we're past the fresh-install guard.
+    store.set("updates:active_releases", JSON.stringify(["1.0.0"]));
+    writeFileSync(workspacePath, "", "utf-8");
+
+    syncUpdateBulletinOnStartup();
+
+    // File should be left alone (still empty, not refilled).
+    expect(existsSync(workspacePath)).toBe(true);
+    expect(readFileSync(workspacePath, "utf-8")).toBe("");
+
+    const completed: string[] = JSON.parse(
+      store.get("updates:completed_releases")!,
+    );
+    expect(completed).toContain("1.0.0");
+  });
+
+  it("treats a whitespace-only UPDATES.md as dismissal of the current release", () => {
+    // Pre-populate active with the current release so the dismissal branch
+    // is scoped correctly to this version.
+    store.set("updates:active_releases", JSON.stringify(["1.0.0"]));
+    writeFileSync(workspacePath, "   \n\n\t\n", "utf-8");
+
+    syncUpdateBulletinOnStartup();
+
+    // File should be left alone — content must not be re-appended.
+    const content = readFileSync(workspacePath, "utf-8");
+    expect(content).not.toContain("<!-- vellum-update-release:1.0.0 -->");
+
+    const completed: string[] = JSON.parse(
+      store.get("updates:completed_releases")!,
+    );
+    expect(completed).toContain("1.0.0");
+  });
+
+  it("materializes new version bulletin after a prior release was dismissed", () => {
+    // Verifies that a new version's bulletin is materialized even when a
+    // prior release exists in the completed set. Dismissal detection is
+    // scoped to the current release — only suppress if this version was
+    // already active or completed, not because an unrelated version was.
+    store.set("updates:completed_releases", JSON.stringify(["0.9.0"]));
+    expect(existsSync(workspacePath)).toBe(false);
+
+    syncUpdateBulletinOnStartup();
+
+    expect(existsSync(workspacePath)).toBe(true);
+    const content = readFileSync(workspacePath, "utf-8");
+    expect(content).toContain("<!-- vellum-update-release:1.0.0 -->");
+    expect(content).toContain("What's New");
+
+    // 1.0.0 must NOT have been auto-completed.
+    const completed: string[] = JSON.parse(
+      store.get("updates:completed_releases")!,
+    );
+    expect(completed).not.toContain("1.0.0");
+
+    // 1.0.0 should be in the active set.
+    const active: string[] = JSON.parse(store.get("updates:active_releases")!);
+    expect(active).toContain("1.0.0");
+  });
+
+  it("creates file on fresh install even though it is missing", () => {
+    // Both active and completed are empty — brand-new DB.
+    expect(store.get("updates:active_releases")).toBeUndefined();
+    expect(store.get("updates:completed_releases")).toBeUndefined();
+    expect(existsSync(workspacePath)).toBe(false);
+
+    syncUpdateBulletinOnStartup();
+
+    // Fresh install should materialize, not dismiss.
+    expect(existsSync(workspacePath)).toBe(true);
+    expect(readFileSync(workspacePath, "utf-8")).toContain(
+      "<!-- vellum-update-release:1.0.0 -->",
+    );
+  });
+
   it("merges pending old block with new release block", () => {
     // Pre-create workspace file with an old release block
     const oldContent =
@@ -239,6 +341,105 @@ describe("syncUpdateBulletinOnStartup", () => {
     expect(existsSync(workspacePath)).toBe(false);
   });
 
+  it("only appends new content blocks on version bump with extended template", () => {
+    // Workspace already has entries A and B from a prior release
+    const oldContent = [
+      "<!-- vellum-update-release:0.9.0 -->",
+      "<!-- vellum-update-release:entry-a -->",
+      "## Entry A",
+      "Content for A.",
+      "<!-- /vellum-update-release:entry-a -->",
+      "",
+      "<!-- vellum-update-release:entry-b -->",
+      "## Entry B",
+      "Content for B.",
+      "<!-- /vellum-update-release:entry-b -->",
+      "",
+    ].join("\n");
+    writeFileSync(workspacePath, oldContent, "utf-8");
+
+    // Template now has A, B, C — C is the only new entry
+    const extendedTemplate = [
+      "<!-- vellum-update-release:entry-a -->",
+      "## Entry A",
+      "Content for A.",
+      "<!-- /vellum-update-release:entry-a -->",
+      "",
+      "<!-- vellum-update-release:entry-b -->",
+      "## Entry B",
+      "Content for B.",
+      "<!-- /vellum-update-release:entry-b -->",
+      "",
+      "<!-- vellum-update-release:entry-c -->",
+      "## Entry C",
+      "New content for C.",
+      "<!-- /vellum-update-release:entry-c -->",
+      "",
+    ].join("\n");
+    writeFileSync(
+      join(tempTemplateDir, "UPDATES.md"),
+      extendedTemplate,
+      "utf-8",
+    );
+
+    syncUpdateBulletinOnStartup();
+
+    const content = readFileSync(workspacePath, "utf-8");
+
+    // New release block should be present
+    expect(content).toContain("<!-- vellum-update-release:1.0.0 -->");
+
+    // Entry C should appear
+    expect(content).toContain("entry-c");
+    expect(content).toContain("New content for C.");
+
+    // Entries A and B should NOT be duplicated
+    const countA = (
+      content.match(/<!-- vellum-update-release:entry-a -->/g) || []
+    ).length;
+    const countB = (
+      content.match(/<!-- vellum-update-release:entry-b -->/g) || []
+    ).length;
+    expect(countA).toBe(1);
+    expect(countB).toBe(1);
+  });
+
+  it("skips append when all template content blocks already exist in workspace", () => {
+    // Workspace already has entries A and B from a prior release
+    const oldContent = [
+      "<!-- vellum-update-release:0.9.0 -->",
+      "<!-- vellum-update-release:entry-a -->",
+      "## Entry A",
+      "<!-- /vellum-update-release:entry-a -->",
+      "",
+      "<!-- vellum-update-release:entry-b -->",
+      "## Entry B",
+      "<!-- /vellum-update-release:entry-b -->",
+      "",
+    ].join("\n");
+    writeFileSync(workspacePath, oldContent, "utf-8");
+
+    // Template has the same A and B — nothing new
+    const sameTemplate = [
+      "<!-- vellum-update-release:entry-a -->",
+      "## Entry A",
+      "<!-- /vellum-update-release:entry-a -->",
+      "",
+      "<!-- vellum-update-release:entry-b -->",
+      "## Entry B",
+      "<!-- /vellum-update-release:entry-b -->",
+      "",
+    ].join("\n");
+    writeFileSync(join(tempTemplateDir, "UPDATES.md"), sameTemplate, "utf-8");
+
+    syncUpdateBulletinOnStartup();
+
+    const content = readFileSync(workspacePath, "utf-8");
+
+    // No 1.0.0 block should be added — all content already present
+    expect(content).not.toContain("<!-- vellum-update-release:1.0.0 -->");
+  });
+
   it("preserves existing file when atomic write fails", () => {
     const originalContent =
       "<!-- vellum-update-release:0.9.0 -->\nOriginal content.\n";

package/src/__tests__/usage-routes.test.ts

@@ -202,11 +202,32 @@ describe("usage routes", () => {
   // -- daily buckets --
 
   describe("GET /v1/usage/daily", () => {
-    test("returns empty buckets array for empty range", async () => {
-      const res = await dispatch("GET", "usage/daily?from=0&to=999999999999");
+    test("returns zero-filled buckets when no events in range", async () => {
+      const from = new Date("2025-01-15T00:00:00Z").getTime();
+      const to = new Date("2025-01-17T23:59:59Z").getTime();
+      const res = await dispatch("GET", `usage/daily?from=${from}&to=${to}`);
       expect(res.status).toBe(200);
-      const body = (await res.json()) as { buckets: unknown[] };
-      expect(body.buckets).toEqual([]);
+      const body = (await res.json()) as {
+        buckets: Array<{
+          date: string;
+          eventCount: number;
+          totalInputTokens: number;
+          totalOutputTokens: number;
+          totalEstimatedCostUsd: number;
+        }>;
+      };
+      expect(body.buckets).toHaveLength(3);
+      expect(body.buckets.map((b) => b.date)).toEqual([
+        "2025-01-15",
+        "2025-01-16",
+        "2025-01-17",
+      ]);
+      for (const bucket of body.buckets) {
+        expect(bucket.eventCount).toBe(0);
+        expect(bucket.totalInputTokens).toBe(0);
+        expect(bucket.totalOutputTokens).toBe(0);
+        expect(bucket.totalEstimatedCostUsd).toBe(0);
+      }
     });
 
     test("returns daily buckets for seeded data", async () => {

package/src/__tests__/user-reference.test.ts

@@ -1,27 +1,26 @@
-import * as realFs from "node:fs";
-import { join } from "node:path";
+/**
+ * Tests for user-reference resolvers. After the drop-user-md migration,
+ * `readPreferredNameFromUserMd` and `resolveUserPronouns` source their
+ * content from the guardian's per-user persona file via
+ * `resolveGuardianPersonaStrict()` (no `default.md` fallback). We mock
+ * the persona-resolver module directly so tests can drive the input
+ * content without touching disk.
+ */
+
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
-
-// Mutable state the tests control
-let mockFileExists = false;
-let mockFileContent = "";
-
-mock.module("node:fs", () => ({
-  ...realFs,
-  existsSync: (path: string) => {
-    if (path === join(TEST_DIR, "USER.md")) return mockFileExists;
-    return false;
-  },
-  readFileSync: (path: string, _encoding: string) => {
-    if (path === join(TEST_DIR, "USER.md") && mockFileExists)
-      return mockFileContent;
-    throw new Error(`ENOENT: no such file: ${path}`);
-  },
+// Mutable state the tests control — represents the value returned by
+// `resolveGuardianPersonaStrict()` (comment-stripped string, or null
+// when no guardian / empty / missing guardian-specific file).
+let mockGuardianPersona: string | null = null;
+
+mock.module("../prompts/persona-resolver.js", () => ({
+  resolveGuardianPersona: () => mockGuardianPersona,
+  resolveGuardianPersonaStrict: () => mockGuardianPersona,
 }));
 
-// Import after mocks are in place
+// Import after mocks are in place so the module under test binds to
+// the stubbed implementation.
 const {
   resolveUserReference,
   resolveUserPronouns,
@@ -31,18 +30,16 @@ const {
 
 describe("resolveUserReference", () => {
   beforeEach(() => {
-    mockFileExists = false;
-    mockFileContent = "";
+    mockGuardianPersona = null;
   });
 
-  test('returns "my human" when USER.md does not exist', () => {
-    mockFileExists = false;
+  test('returns "my human" when no guardian persona exists', () => {
+    mockGuardianPersona = null;
     expect(resolveUserReference()).toBe("my human");
   });
 
   test('returns "my human" when preferred name field is empty', () => {
-    mockFileExists = true;
-    mockFileContent = [
+    mockGuardianPersona = [
       "## Onboarding Snapshot",
       "",
       "- Preferred name/reference:",
@@ -53,8 +50,7 @@ describe("resolveUserReference", () => {
   });
 
   test("returns the configured name when it is set", () => {
-    mockFileExists = true;
-    mockFileContent = [
+    mockGuardianPersona = [
       "## Onboarding Snapshot",
       "",
       "- Preferred name/reference: John",
@@ -65,27 +61,24 @@ describe("resolveUserReference", () => {
   });
 
   test("trims whitespace around the configured name", () => {
-    mockFileExists = true;
-    mockFileContent = "- Preferred name/reference:   Alice   \n";
+    mockGuardianPersona = "- Preferred name/reference:   Alice   \n";
     expect(resolveUserReference()).toBe("Alice");
   });
 });
 
 describe("resolveUserPronouns", () => {
   beforeEach(() => {
-    mockFileExists = false;
-    mockFileContent = "";
+    mockGuardianPersona = null;
   });
 
-  test("returns null when USER.md does not exist", () => {
-    mockFileExists = false;
+  test("returns null when no guardian persona exists", () => {
+    mockGuardianPersona = null;
     expect(resolveUserPronouns()).toBeNull();
   });
 
-  test("returns pronouns from flat USER.md (no Onboarding Snapshot)", () => {
-    mockFileExists = true;
-    mockFileContent = [
-      "# USER.md",
+  test("returns pronouns from flat persona file (no Onboarding Snapshot)", () => {
+    mockGuardianPersona = [
+      "# User Profile",
       "",
       "- Preferred name/reference: Alice",
       "- Pronouns: she/her",
@@ -95,9 +88,8 @@ describe("resolveUserPronouns", () => {
   });
 
   test("returns null when pronouns field is empty in flat format", () => {
-    mockFileExists = true;
-    mockFileContent = [
-      "# USER.md",
+    mockGuardianPersona = [
+      "# User Profile",
       "",
       "- Preferred name/reference: Alice",
       "- Pronouns:",
@@ -107,8 +99,7 @@ describe("resolveUserPronouns", () => {
   });
 
   test("returns pronouns from legacy Onboarding Snapshot section", () => {
-    mockFileExists = true;
-    mockFileContent = [
+    mockGuardianPersona = [
       "## Onboarding Snapshot",
       "",
       "- Pronouns: they/them",
@@ -117,8 +108,7 @@ describe("resolveUserPronouns", () => {
   });
 
   test("prefers pronouns above Onboarding Snapshot over inside it", () => {
-    mockFileExists = true;
-    mockFileContent = [
+    mockGuardianPersona = [
       "Pronouns: he/him",
       "",
       "## Onboarding Snapshot",
@@ -129,8 +119,7 @@ describe("resolveUserPronouns", () => {
   });
 
   test("returns null for declined_by_user", () => {
-    mockFileExists = true;
-    mockFileContent = [
+    mockGuardianPersona = [
       "- Preferred name/reference: Alice",
       "- Pronouns: declined_by_user",
     ].join("\n");
@@ -138,8 +127,7 @@ describe("resolveUserPronouns", () => {
   });
 
   test("strips inferred: prefix", () => {
-    mockFileExists = true;
-    mockFileContent = [
+    mockGuardianPersona = [
       "- Preferred name/reference: Alice",
       "- Pronouns: inferred: she/her",
     ].join("\n");
@@ -149,13 +137,11 @@ describe("resolveUserPronouns", () => {
 
 describe("resolveGuardianName", () => {
   beforeEach(() => {
-    mockFileExists = false;
-    mockFileContent = "";
+    mockGuardianPersona = null;
   });
 
-  test("returns USER.md name when present, ignoring guardianDisplayName", () => {
-    mockFileExists = true;
-    mockFileContent = [
+  test("returns persona name when present, ignoring guardianDisplayName", () => {
+    mockGuardianPersona = [
       "## Onboarding Snapshot",
       "",
       "- Preferred name/reference: John",
@@ -163,9 +149,8 @@ describe("resolveGuardianName", () => {
     expect(resolveGuardianName("Jane")).toBe("John");
   });
 
-  test('returns "my human" when USER.md explicitly sets name to default value', () => {
-    mockFileExists = true;
-    mockFileContent = [
+  test('returns "my human" when persona explicitly sets name to default value', () => {
+    mockGuardianPersona = [
       "## Onboarding Snapshot",
       "",
       "- Preferred name/reference: my human",
@@ -174,20 +159,20 @@ describe("resolveGuardianName", () => {
     expect(resolveGuardianName("Jane")).toBe("my human");
   });
 
-  test("falls back to guardianDisplayName when USER.md is empty", () => {
-    mockFileExists = false;
+  test("falls back to guardianDisplayName when persona is empty", () => {
+    mockGuardianPersona = null;
     expect(resolveGuardianName("Jane")).toBe("Jane");
   });
 
   test("falls back to DEFAULT_USER_REFERENCE when both are empty", () => {
-    mockFileExists = false;
+    mockGuardianPersona = null;
     expect(resolveGuardianName()).toBe(DEFAULT_USER_REFERENCE);
     expect(resolveGuardianName(null)).toBe(DEFAULT_USER_REFERENCE);
     expect(resolveGuardianName("")).toBe(DEFAULT_USER_REFERENCE);
   });
 
   test("trims whitespace on guardianDisplayName fallback", () => {
-    mockFileExists = false;
+    mockGuardianPersona = null;
     expect(resolveGuardianName("  Jane  ")).toBe("Jane");
   });
 });

package/src/__tests__/verification-control-plane-policy.test.ts

@@ -73,8 +73,12 @@ mock.module("../permissions/checker.js", () => ({
   generateScopeOptions: () => [],
 }));
 
+// Mock every export so downstream test files that dynamically import modules
+// with a static `from "../memory/tool-usage-store.js"` still see all symbols.
 mock.module("../memory/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
+  getRecentInvocations: () => [],
+  rotateToolInvocations: () => 0,
 }));
 
 mock.module("../tools/registry.js", () => ({