@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/workspace-migration-057-repair-stale-gemini-model-ids.test.ts

@@ -217,6 +217,64 @@ describe("057-repair-stale-gemini-model-ids migration", () => {
     expect(config.llm.profiles.balanced.model).toBe("gemini-3-flash-preview");
   });
 
+  test("does not rewrite blocks whose effective provider is not Gemini", () => {
+    writeConfig({
+      llm: {
+        default: {
+          provider: "ollama",
+          model: "gemini-3-flash",
+        },
+        callSites: {
+          analyzeConversation: {
+            provider: "openrouter",
+            model: "gemini-3-flash",
+          },
+          recall: {
+            model: "gemini-3-flash",
+          },
+        },
+        profiles: {
+          custom: {
+            provider: "ollama",
+            model: "gemini-3-flash",
+          },
+        },
+      },
+    });
+    const before = readFileSync(configPath(), "utf-8");
+
+    repairStaleGeminiModelIdsMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath(), "utf-8")).toBe(before);
+  });
+
+  test("rewrites call-site/profile blocks without local provider when default is Gemini", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-3-flash-preview" },
+        callSites: {
+          memoryRetrieval: { model: "gemini-3-flash" },
+        },
+        profiles: {
+          balanced: { model: "gemini-3-flash" },
+        },
+      },
+    });
+
+    repairStaleGeminiModelIdsMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: {
+        callSites: Record<string, { model: string }>;
+        profiles: Record<string, { model: string }>;
+      };
+    };
+    expect(config.llm.callSites.memoryRetrieval.model).toBe(
+      "gemini-3.1-flash-lite-preview",
+    );
+    expect(config.llm.profiles.balanced.model).toBe("gemini-3-flash-preview");
+  });
+
   test("no-ops when config.json is missing or invalid", () => {
     repairStaleGeminiModelIdsMigration.run(workspaceDir);
     expect(existsSync(configPath())).toBe(false);

package/src/__tests__/workspace-migration-069-seed-onboarding-threads.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Tests for workspace migration `069-seed-onboarding-threads`.
+ *
+ * The migration writes onboarding bullet content to `memory/threads.md` only
+ * for newly-created workspaces (`ctx.isNewWorkspace === true`) when the file
+ * exists and is empty (or whitespace-only). For upgrading workspaces it must
+ * be a no-op even if `threads.md` is currently empty (the user may have
+ * cleaned it up themselves). It must preserve any existing content and be
+ * idempotent.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { memoryV2InitMigration } from "../workspace/migrations/060-memory-v2-init.js";
+import { seedOnboardingThreadsMigration } from "../workspace/migrations/069-seed-onboarding-threads.js";
+import type { MigrationRunContext } from "../workspace/migrations/types.js";
+
+const NEW_WORKSPACE_CTX: MigrationRunContext = { isNewWorkspace: true };
+const UPGRADE_CTX: MigrationRunContext = { isNewWorkspace: false };
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-069-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function readThreads(): string {
+  return readFileSync(join(workspaceDir, "memory", "threads.md"), "utf-8");
+}
+
+describe("069-seed-onboarding-threads migration", () => {
+  test("has correct id and description", () => {
+    expect(seedOnboardingThreadsMigration.id).toBe(
+      "069-seed-onboarding-threads",
+    );
+    expect(seedOnboardingThreadsMigration.description).toContain("threads.md");
+  });
+
+  test.each([
+    ["empty file", ""],
+    ["whitespace-only file", "   \n\n"],
+  ])(
+    "seeds onboarding bullets when new workspace and memory/threads.md is %s",
+    (_, initial) => {
+      mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+      writeFileSync(
+        join(workspaceDir, "memory", "threads.md"),
+        initial,
+        "utf-8",
+      );
+
+      seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+
+      const content = readThreads();
+      expect(content).toContain("Figure out what kind of personality");
+      expect(content).toContain("data/avatar/avatar-image.png");
+      expect(content).toContain("ChatGPT, Claude");
+      expect(content).toContain("Slack or Telegram");
+    },
+  );
+
+  test.each([
+    ["empty file", ""],
+    ["whitespace-only file", "   \n\n"],
+  ])(
+    "no-op on upgrade when memory/threads.md is %s (user may have cleared it)",
+    (_, initial) => {
+      mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+      writeFileSync(
+        join(workspaceDir, "memory", "threads.md"),
+        initial,
+        "utf-8",
+      );
+
+      seedOnboardingThreadsMigration.run(workspaceDir, UPGRADE_CTX);
+
+      expect(readThreads()).toBe(initial);
+    },
+  );
+
+  test("preserves existing content when memory/threads.md is non-empty", () => {
+    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+    const existing = "Follow up with Bob about the design review.\n";
+    writeFileSync(
+      join(workspaceDir, "memory", "threads.md"),
+      existing,
+      "utf-8",
+    );
+
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+
+    expect(readThreads()).toBe(existing);
+  });
+
+  test("no-op when memory/threads.md does not exist", () => {
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+    expect(existsSync(join(workspaceDir, "memory", "threads.md"))).toBe(false);
+  });
+
+  test("idempotent — second run does not duplicate or rewrite content", () => {
+    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+    writeFileSync(join(workspaceDir, "memory", "threads.md"), "", "utf-8");
+
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+    const afterFirst = readThreads();
+
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+    const afterSecond = readThreads();
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("composes with 060: fresh workspace -> 060 -> 069 produces seeded threads.md", () => {
+    memoryV2InitMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+
+    expect(readThreads()).toContain("Figure out what kind of personality");
+    // The other v2 prose files are untouched (still empty).
+    for (const filename of ["essentials.md", "recent.md", "buffer.md"]) {
+      expect(
+        readFileSync(join(workspaceDir, "memory", filename), "utf-8"),
+      ).toBe("");
+    }
+  });
+
+  test("down() is a no-op — seeded content remains", () => {
+    mkdirSync(join(workspaceDir, "memory"), { recursive: true });
+    writeFileSync(join(workspaceDir, "memory", "threads.md"), "", "utf-8");
+
+    seedOnboardingThreadsMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+    const seeded = readThreads();
+
+    seedOnboardingThreadsMigration.down(workspaceDir);
+
+    expect(readThreads()).toBe(seeded);
+  });
+});

package/src/__tests__/workspace-migration-071-remove-safe-storage-release-note.test.ts

@@ -0,0 +1,206 @@
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+
+import { removeSafeStorageReleaseNoteMigration } from "../workspace/migrations/071-remove-safe-storage-release-note.js";
+
+const MIGRATION_ID = "071-remove-safe-storage-release-note";
+const SAFE_STORAGE_MARKER =
+  "<!-- release-note-id:067-release-notes-safe-storage-limits -->";
+const LATER_MARKER =
+  "<!-- release-note-id:068-release-notes-local-timezone -->";
+
+const SAFE_STORAGE_RELEASE_NOTE = `${SAFE_STORAGE_MARKER}
+## Safe storage limits
+
+A new storage protection mode is available behind the safe-storage-limits
+rollout flag. When enabled, the assistant watches workspace disk usage and
+enters cleanup mode if the volume reaches the critical 95% threshold.
+
+In cleanup mode, background processes pause and remote messages, including
+trusted-contact messages, are blocked until the guardian frees enough space or
+explicitly overrides the lock. The macOS app now shows a storage cleanup banner
+that must be acknowledged before cleanup chat continues, then keeps a status
+banner visible while cleanup mode is active.
+`;
+
+let testRoot: string;
+let workspaceDir: string;
+
+beforeAll(() => {
+  testRoot = mkdtempSync(join(tmpdir(), "migration-071-remove-safe-storage-"));
+});
+
+afterAll(() => {
+  rmSync(testRoot, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(testRoot, "ws-"));
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+describe("workspace migration 071-remove-safe-storage-release-note", () => {
+  test("has the correct id and description", () => {
+    expect(removeSafeStorageReleaseNoteMigration.id).toBe(MIGRATION_ID);
+    expect(removeSafeStorageReleaseNoteMigration.description).toContain(
+      "safe storage release note",
+    );
+  });
+
+  test("missing UPDATES.md is a no-op", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    expect(existsSync(updatesPath())).toBe(false);
+  });
+
+  test("removes UPDATES.md when it only contains the safe-storage bulletin", () => {
+    writeFileSync(updatesPath(), SAFE_STORAGE_RELEASE_NOTE, "utf-8");
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    expect(existsSync(updatesPath())).toBe(false);
+  });
+
+  test("preserves prior unrelated release notes when removing the safe-storage block", () => {
+    const prior = `<!-- release-note-id:066-earlier-note -->
+## Earlier note
+
+This note should stay.
+`;
+    writeFileSync(
+      updatesPath(),
+      `${prior}\n${SAFE_STORAGE_RELEASE_NOTE}`,
+      "utf-8",
+    );
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content).toContain("## Earlier note");
+    expect(content).toContain("This note should stay.");
+    expect(content).not.toContain(SAFE_STORAGE_MARKER);
+    expect(content).not.toContain("Safe storage limits");
+  });
+
+  test("preserves a later release-note block after safe storage", () => {
+    const later = `${LATER_MARKER}
+## Local timezone grounding
+
+This later note should stay.
+`;
+    writeFileSync(
+      updatesPath(),
+      `${SAFE_STORAGE_RELEASE_NOTE}\n${later}`,
+      "utf-8",
+    );
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(LATER_MARKER)).toBe(true);
+    expect(content).toContain("## Local timezone grounding");
+    expect(content).toContain("This later note should stay.");
+    expect(content).not.toContain(SAFE_STORAGE_MARKER);
+    expect(content).not.toContain("Safe storage limits");
+  });
+
+  test("fallback preserves a later release-note block after a partial safe-storage block", () => {
+    const partialSafeStorage = `${SAFE_STORAGE_MARKER}
+## Safe storage limits
+
+Partially written note.
+`;
+    const later = `${LATER_MARKER}
+## Local timezone grounding
+
+This later note should stay.
+`;
+    writeFileSync(updatesPath(), `${partialSafeStorage}\n${later}`, "utf-8");
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(LATER_MARKER)).toBe(true);
+    expect(content).toContain("## Local timezone grounding");
+    expect(content).not.toContain(SAFE_STORAGE_MARKER);
+    expect(content).not.toContain("Partially written note.");
+  });
+
+  test("content without the safe-storage marker is byte-identical", () => {
+    const original =
+      "## Existing note\r\n\r\nNo safe storage marker appears here.\r\n";
+    writeFileSync(updatesPath(), original, "utf-8");
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(original);
+  });
+
+  test("preserves CRLF in unrelated content when removing the safe-storage block", () => {
+    const prior =
+      "<!-- release-note-id:066-earlier-note -->\r\n## Earlier note\r\n\r\nThis note should keep CRLF.\r\n";
+    writeFileSync(
+      updatesPath(),
+      `${prior}\r\n${SAFE_STORAGE_RELEASE_NOTE}`,
+      "utf-8",
+    );
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(prior);
+  });
+
+  test("running twice is idempotent", () => {
+    const prior = `<!-- release-note-id:066-earlier-note -->
+## Earlier note
+
+This note should stay.
+`;
+    const later = `${LATER_MARKER}
+## Local timezone grounding
+
+This later note should stay.
+`;
+    writeFileSync(
+      updatesPath(),
+      `${prior}\n${SAFE_STORAGE_RELEASE_NOTE}\n${later}`,
+      "utf-8",
+    );
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+    const afterFirst = readFileSync(updatesPath(), "utf-8");
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+    const afterSecond = readFileSync(updatesPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+    expect(afterSecond).toContain("## Earlier note");
+    expect(afterSecond).toContain("## Local timezone grounding");
+    expect(afterSecond).not.toContain(SAFE_STORAGE_MARKER);
+  });
+});

package/src/__tests__/workspace-migration-072-seed-reply-suggestion-callsite.test.ts

@@ -0,0 +1,191 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { seedReplySuggestionCallsiteMigration } from "../workspace/migrations/072-seed-reply-suggestion-callsite.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-072-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("072-seed-reply-suggestion-callsite migration", () => {
+  test("has correct migration id", () => {
+    expect(seedReplySuggestionCallsiteMigration.id).toBe(
+      "072-seed-reply-suggestion-callsite",
+    );
+  });
+
+  test("seeds haiku callsite entry on Anthropic workspace without override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+        callSites: {
+          conversationStarters: {
+            model: "claude-haiku-4-5-20251001",
+            effort: "low",
+            thinking: { enabled: false },
+          },
+        },
+      },
+    });
+
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.replySuggestion).toEqual({
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+    // Does not clobber unrelated entries.
+    expect(config.llm.callSites.conversationStarters).toEqual({
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("seeds openrouter-shaped model ID on openrouter workspace", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openrouter", model: "anthropic/claude-opus-4.7" },
+      },
+    });
+
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.replySuggestion).toEqual({
+      model: "anthropic/claude-haiku-4.5",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("skips when replySuggestion already has an explicit override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          replySuggestion: {
+            model: "claude-opus-4-7",
+            effort: "high",
+          },
+        },
+      },
+    });
+
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.replySuggestion).toEqual({
+      model: "claude-opus-4-7",
+      effort: "high",
+    });
+  });
+
+  test("skips entirely when non-Anthropic, non-OpenRouter provider is configured", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+      },
+    });
+
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    // No callSites object created at all.
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("runs on fresh install (no config.json) and writes seed config", () => {
+    expect(existsSync(configPath())).toBe(false);
+
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.replySuggestion).toEqual({
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("is idempotent — a second run is a no-op", () => {
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+    const afterFirst = readFileSync(configPath(), "utf-8");
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+    const afterSecond = readFileSync(configPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+});