@vellumai/assistant 0.7.2 → 0.7.3

package/src/__tests__/workspace-migration-065-bump-stale-heartbeat-interval.test.ts

@@ -0,0 +1,122 @@
+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 { bumpStaleHeartbeatIntervalMigration } from "../workspace/migrations/065-bump-stale-heartbeat-interval.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+
+const THIRTY_MINUTES_MS = 30 * 60 * 1000;
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-065-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(configPath(), JSON.stringify(data, null, 2) + "\n");
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath(), "utf-8"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("065-bump-stale-heartbeat-interval migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(bumpStaleHeartbeatIntervalMigration.id).toBe(
+      "065-bump-stale-heartbeat-interval",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "065-bump-stale-heartbeat-interval",
+    );
+  });
+
+  test("bumps stale baked 6-hour default to 30 minutes", () => {
+    writeConfig({
+      heartbeat: {
+        enabled: true,
+        intervalMs: 6 * 60 * 60 * 1000,
+        activeHoursStart: 8,
+        activeHoursEnd: 22,
+      },
+    });
+
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+
+    expect(readConfig()).toEqual({
+      heartbeat: {
+        enabled: true,
+        intervalMs: THIRTY_MINUTES_MS,
+        activeHoursStart: 8,
+        activeHoursEnd: 22,
+      },
+    });
+  });
+
+  test("bumps stale baked 3-hour default to 30 minutes", () => {
+    writeConfig({
+      heartbeat: {
+        intervalMs: 3 * 60 * 60 * 1000,
+      },
+    });
+
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+
+    expect((readConfig().heartbeat as Record<string, unknown>).intervalMs).toBe(
+      THIRTY_MINUTES_MS,
+    );
+  });
+
+  test("preserves custom heartbeat intervals", () => {
+    writeConfig({
+      heartbeat: {
+        intervalMs: 60 * 60 * 1000,
+      },
+    });
+
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+
+    expect(readConfig()).toEqual({
+      heartbeat: {
+        intervalMs: 60 * 60 * 1000,
+      },
+    });
+  });
+
+  test("is a no-op when config or heartbeat interval is absent", () => {
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+    expect(existsSync(configPath())).toBe(false);
+
+    writeConfig({ heartbeat: { enabled: true }, other: "value" });
+    bumpStaleHeartbeatIntervalMigration.run(workspaceDir);
+    expect(readConfig()).toEqual({
+      heartbeat: { enabled: true },
+      other: "value",
+    });
+  });
+});

package/src/__tests__/workspace-migration-066-seed-heartbeat-callsite-cost-default.test.ts

@@ -0,0 +1,285 @@
+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 { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+import { seedHeartbeatCallsiteCostDefaultMigration } from "../workspace/migrations/066-seed-heartbeat-callsite-cost-default.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-066-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(configPath(), JSON.stringify(data, null, 2) + "\n");
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath(), "utf-8"));
+}
+
+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("066-seed-heartbeat-callsite-cost-default migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(seedHeartbeatCallsiteCostDefaultMigration.id).toBe(
+      "066-seed-heartbeat-callsite-cost-default",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "066-seed-heartbeat-callsite-cost-default",
+    );
+  });
+
+  test("fresh config seeds explicit Anthropic cheap defaults", () => {
+    expect(existsSync(configPath())).toBe(false);
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      provider: "anthropic",
+      model: "claude-haiku-4-5-20251001",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("uses matching cost-optimized profile when present", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-sonnet-4-6" },
+        profiles: {
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+          },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      profile: "cost-optimized",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("fills missing leaves on legacy heartbeat speed override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          heartbeatAgent: { speed: "fast" },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      speed: "fast",
+      provider: "anthropic",
+      model: "claude-haiku-4-5-20251001",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("preserves explicit user model selection unchanged", () => {
+    const heartbeatAgent = {
+      provider: "openai",
+      model: "gpt-5.4-mini",
+      effort: "medium",
+      thinking: { enabled: true },
+      contextWindow: { enabled: false },
+    };
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          heartbeatAgent,
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual(heartbeatAgent);
+  });
+
+  test("preserves explicit user profile selection unchanged", () => {
+    const heartbeatAgent = {
+      profile: "quality-optimized",
+    };
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            effort: "max",
+            thinking: { enabled: true, streamThinking: true },
+          },
+        },
+        callSites: {
+          heartbeatAgent,
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual(heartbeatAgent);
+  });
+
+  test("seeds provider-specific cheap model for OpenAI workspaces", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+        profiles: {
+          "cost-optimized": {
+            provider: "anthropic",
+            model: "claude-haiku-4-5-20251001",
+          },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      provider: "openai",
+      model: "gpt-5.4-nano",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  test("seeds existing Gemini latency model for Gemini workspaces", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-3.1-pro-preview" },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.heartbeatAgent).toEqual({
+      provider: "gemini",
+      model: "gemini-3-flash",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16_000 },
+    });
+  });
+
+  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" } },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("resolved heartbeat config uses cheap model and bounded context", () => {
+    writeConfig({
+      llm: {
+        default: {
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
+          effort: "high",
+          thinking: { enabled: true, streamThinking: true },
+          contextWindow: { maxInputTokens: 200_000 },
+        },
+      },
+    });
+
+    seedHeartbeatCallsiteCostDefaultMigration.run(workspaceDir);
+
+    const onDisk = readConfig() as { llm: unknown };
+    const parsed = LLMSchema.parse(onDisk.llm);
+    const resolved = resolveCallSiteConfig("heartbeatAgent", parsed);
+    expect(resolved.provider).toBe("anthropic");
+    expect(resolved.model).toBe("claude-haiku-4-5-20251001");
+    expect(resolved.maxTokens).toBe(2048);
+    expect(resolved.effort).toBe("low");
+    expect(resolved.temperature).toBe(0);
+    expect(resolved.thinking).toEqual({
+      enabled: false,
+      streamThinking: false,
+    });
+    expect(resolved.contextWindow.maxInputTokens).toBe(16_000);
+  });
+});

package/src/__tests__/workspace-migration-068-release-notes-local-timezone.test.ts

@@ -0,0 +1,90 @@
+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 { releaseNotesLocalTimezoneMigration } from "../workspace/migrations/068-release-notes-local-timezone.js";
+
+const MIGRATION_ID = "068-release-notes-local-timezone";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-068-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+function markerCount(content: string): number {
+  return content.split(MARKER).length - 1;
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("workspace migration 068-release-notes-local-timezone", () => {
+  test("has the correct id", () => {
+    expect(releaseNotesLocalTimezoneMigration.id).toBe(MIGRATION_ID);
+  });
+
+  test("creates UPDATES.md with marker and key copy when file is absent", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content).toContain(MARKER);
+    expect(content).toContain("Local timezone grounding");
+    expect(content).toContain("device timezone");
+    expect(content).toContain("Manual timezone overrides still win");
+  });
+
+  test("is idempotent when run twice", () => {
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(markerCount(content)).toBe(1);
+    expect(content.match(/Local timezone grounding/g)?.length).toBe(1);
+  });
+
+  test("appends to existing UPDATES.md when marker is absent", () => {
+    const prior = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), prior, "utf-8");
+
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(prior)).toBe(true);
+    expect(content).toContain(MARKER);
+  });
+
+  test("is a no-op when marker is already present", () => {
+    const seeded = `## Prior\n\n${MARKER}\nAlready announced.\n`;
+    writeFileSync(updatesPath(), seeded, "utf-8");
+
+    releaseNotesLocalTimezoneMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(seeded);
+  });
+});

package/src/__tests__/workspace-migration-safe-storage-limits-release.test.ts

@@ -0,0 +1,90 @@
+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 { releaseNotesSafeStorageLimitsMigration } from "../workspace/migrations/067-release-notes-safe-storage-limits.js";
+
+const MIGRATION_ID = "067-release-notes-safe-storage-limits";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-067-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+function markerCount(content: string): number {
+  return content.split(MARKER).length - 1;
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("workspace migration 067-release-notes-safe-storage-limits", () => {
+  test("has the correct id", () => {
+    expect(releaseNotesSafeStorageLimitsMigration.id).toBe(MIGRATION_ID);
+  });
+
+  test("creates UPDATES.md with marker and key copy when file is absent", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content).toContain(MARKER);
+    expect(content).toContain("safe-storage-limits");
+    expect(content).toContain("critical 95% threshold");
+    expect(content).toContain("trusted-contact messages");
+  });
+
+  test("is idempotent when run twice", () => {
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(markerCount(content)).toBe(1);
+    expect(content.match(/Safe storage limits/g)?.length).toBe(1);
+  });
+
+  test("appends to existing UPDATES.md when marker is absent", () => {
+    const prior = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), prior, "utf-8");
+
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(prior)).toBe(true);
+    expect(content).toContain(MARKER);
+  });
+
+  test("is a no-op when marker is already present", () => {
+    const seeded = `## Prior\n\n${MARKER}\nAlready announced.\n`;
+    writeFileSync(updatesPath(), seeded, "utf-8");
+
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(seeded);
+  });
+});

package/src/approvals/guardian-decision-primitive.ts

@@ -355,6 +355,12 @@ export type CanonicalDecisionResult =
       resolverFailed?: boolean;
       resolverFailureReason?: string;
       resolverReplyText?: string;
+      activatedContact?: {
+        sourceChannel: string;
+        externalUserId: string;
+        externalChatId?: string;
+        displayName?: string;
+      };
     }
   | {
       applied: false;
@@ -521,6 +527,9 @@ export async function applyCanonicalGuardianDecision(
   let resolverFailed = false;
   let resolverFailureReason: string | undefined;
   let resolverReplyText: string | undefined;
+  let activatedContact:
+    | { sourceChannel: string; externalUserId: string; externalChatId?: string; displayName?: string }
+    | undefined;
   const resolver = getResolver(request.kind);
   if (resolver) {
     const resolverResult = await resolver.resolve({
@@ -549,6 +558,9 @@ export async function applyCanonicalGuardianDecision(
       resolverFailureReason = resolverResult.reason;
     } else {
       resolverReplyText = resolverResult.guardianReplyText;
+      if (resolverResult.activatedContact) {
+        activatedContact = resolverResult.activatedContact;
+      }
     }
   } else {
     log.info(
@@ -600,5 +612,6 @@ export async function applyCanonicalGuardianDecision(
     grantMinted,
     ...(resolverFailed ? { resolverFailed, resolverFailureReason } : {}),
     ...(resolverReplyText ? { resolverReplyText } : {}),
+    ...(activatedContact ? { activatedContact } : {}),
   };
 }

package/src/approvals/guardian-request-resolvers.ts

@@ -13,7 +13,6 @@
 
 import { answerCall } from "../calls/call-domain.js";
 import { findContactChannel } from "../contacts/contact-store.js";
-import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { findConversation } from "../daemon/conversation-store.js";
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import {
@@ -120,6 +119,12 @@ export type ResolverResult =
       applied: true;
       grantMinted?: boolean;
       guardianReplyText?: string;
+      activatedContact?: {
+        sourceChannel: string;
+        externalUserId: string;
+        externalChatId?: string;
+        displayName?: string;
+      };
     }
   | { ok: false; reason: string };
 
@@ -510,21 +515,6 @@ const accessRequestResolver: GuardianRequestResolver = {
     // a verification session. The caller is already on the line and the
     // relay server's in-call wait loop will detect the approved status.
     if (channel === "phone") {
-      try {
-        upsertContactChannel({
-          sourceChannel: "phone",
-          externalUserId: requesterExternalUserId,
-          externalChatId: requesterChatId,
-          status: "active",
-          policy: "allow",
-        });
-      } catch (err) {
-        log.error(
-          { err, requesterExternalUserId },
-          "Access request resolver: failed to activate voice caller as trusted contact",
-        );
-      }
-
       log.info(
         {
           event: "resolver_access_request_voice_approved",
@@ -549,7 +539,16 @@ const accessRequestResolver: GuardianRequestResolver = {
         );
       });
 
-      return { ok: true, applied: true };
+      return {
+        ok: true,
+        applied: true,
+        activatedContact: {
+          sourceChannel: "phone",
+          externalUserId: requesterExternalUserId,
+          ...(requesterChatId ? { externalChatId: requesterChatId } : {}),
+          ...(requesterDisplayName ? { displayName: requesterDisplayName } : {}),
+        },
+      };
     }
 
     // Non-voice approvals: mint an identity-bound verification session so the