@vellumai/assistant 0.4.55 → 0.4.57

package/src/__tests__/ephemeral-permissions.test.ts

@@ -328,20 +328,19 @@ describe("ephemeral-permissions", () => {
       testConfig.permissions.mode = "workspace";
     });
 
-    test("workspace mode prompts for workspace-scoped file_write (medium risk)", async () => {
+    test("workspace mode auto-allows workspace-scoped file_write (low risk)", async () => {
       const filePath = join(testDir, "workspace-test-file.txt");
       const result = await check("file_write", { path: filePath }, testDir);
-      expect(result.decision).toBe("prompt");
-      expect(result.reason).toContain("medium risk");
+      expect(result.decision).toBe("allow");
     });
 
-    test("workspace mode still prompts for file_write outside workspace", async () => {
+    test("workspace mode auto-allows file_write outside workspace (low risk)", async () => {
       const result = await check(
         "file_write",
         { path: "/etc/config" },
         testDir,
       );
-      expect(result.decision).toBe("prompt");
+      expect(result.decision).toBe("allow");
     });
 
     test("explicit deny rule overrides workspace mode auto-allow", async () => {

package/src/__tests__/event-bus.test.ts

@@ -13,18 +13,17 @@ describe("EventBus", () => {
     });
     bus.on("tool.execution.started", async (event) => {
       await Promise.resolve();
-      seen.push(`second:${event.sessionId}`);
+      seen.push(`second:${event.conversationId}`);
     });
 
     await bus.emit("tool.execution.started", {
       conversationId: "conv-1",
-      sessionId: "sess-1",
       toolName: "bash",
       input: { command: "ls" },
       startedAtMs: Date.now(),
     });
 
-    expect(seen).toEqual(["first:bash", "second:sess-1"]);
+    expect(seen).toEqual(["first:bash", "second:conv-1"]);
   });
 
   test("supports onAny listeners with event envelopes", async () => {
@@ -34,18 +33,18 @@ describe("EventBus", () => {
 
     bus.onAny((event) => {
       seenType = event.type;
-      if (event.type === "daemon.session.created") {
+      if (event.type === "daemon.conversation.created") {
         seenConversationId = event.payload.conversationId;
       }
       expect(typeof event.emittedAtMs).toBe("number");
     });
 
-    await bus.emit("daemon.session.created", {
+    await bus.emit("daemon.conversation.created", {
       conversationId: "conv-2",
       createdAtMs: Date.now(),
     });
 
-    expect(seenType).toBe("daemon.session.created");
+    expect(seenType).toBe("daemon.conversation.created");
     expect(seenConversationId).toBe("conv-2");
   });
 
@@ -68,7 +67,6 @@ describe("EventBus", () => {
 
     await bus.emit("tool.permission.decided", {
       conversationId: "conv-2",
-      sessionId: "sess-2",
       toolName: "bash",
       decision: "allow",
       riskLevel: "medium",
@@ -162,7 +160,6 @@ describe("EventBus", () => {
     await expect(
       bus.emit("tool.execution.finished", {
         conversationId: "conv-3",
-        sessionId: "sess-3",
         toolName: "file_read",
         decision: "allow",
         riskLevel: "low",
@@ -201,7 +198,6 @@ describe("EventBus", () => {
     try {
       await bus.emit("tool.execution.failed", {
         conversationId: "conv-4",
-        sessionId: "sess-4",
         toolName: "bash",
         decision: "error",
         riskLevel: "high",

package/src/__tests__/file-edit-tool.test.ts

@@ -23,7 +23,6 @@ beforeAll(async () => {
 function makeContext(workingDir: string): ToolContext {
   return {
     workingDir,
-    sessionId: "test-session",
     conversationId: "test-conversation",
     trustClass: "guardian",
   };

package/src/__tests__/file-read-tool.test.ts

@@ -23,7 +23,6 @@ beforeAll(async () => {
 function makeContext(workingDir: string): ToolContext {
   return {
     workingDir,
-    sessionId: "test-session",
     conversationId: "test-conversation",
     trustClass: "guardian",
   };

package/src/__tests__/file-write-tool.test.ts

@@ -24,7 +24,6 @@ beforeAll(async () => {
 function makeContext(workingDir: string): ToolContext {
   return {
     workingDir,
-    sessionId: "test-session",
     conversationId: "test-conversation",
     trustClass: "guardian",
   };

package/src/__tests__/fixtures/mock-signup-server.ts

@@ -174,7 +174,7 @@ export function createMockSignupServer(): MockSignupServer {
   /** Stores the most recently generated verification code (for the test-only endpoint). */
   let lastVerificationCode = "";
 
-  function getOrCreateSession(cookieHeader: string | null): {
+  function getOrCreateConversation(cookieHeader: string | null): {
     session: SignupSession;
     id: string;
   } {
@@ -244,7 +244,7 @@ export function createMockSignupServer(): MockSignupServer {
       });
     }
 
-    const { session, id } = getOrCreateSession(cookieHeader);
+    const { session, id } = getOrCreateConversation(cookieHeader);
 
     // ── Step 1: Name form ─────────────────────────────────────────
     if (method === "GET" && path === "/signup") {

package/src/__tests__/followup-tools.test.ts

@@ -55,7 +55,6 @@ function getRawDb(): Database {
 
 const ctx: ToolContext = {
   workingDir: "/tmp",
-  sessionId: "test-session",
   conversationId: "test-conversation",
   trustClass: "guardian",
 };
@@ -79,7 +78,7 @@ describe("followup_create tool", () => {
     const result = await executeFollowupCreate(
       {
         channel: "email",
-        thread_id: "thread-123",
+        conversation_id: "conv-123",
       },
       ctx,
     );
@@ -87,7 +86,7 @@ describe("followup_create tool", () => {
     expect(result.isError).toBe(false);
     expect(result.content).toContain("Created follow-up");
     expect(result.content).toContain("email");
-    expect(result.content).toContain("thread-123");
+    expect(result.content).toContain("conv-123");
     expect(result.content).toContain("Status: pending");
   });
 
@@ -95,7 +94,7 @@ describe("followup_create tool", () => {
     const result = await executeFollowupCreate(
       {
         channel: "slack",
-        thread_id: "slack-thread-1",
+        conversation_id: "slack-thread-1",
         expected_response_hours: 24,
       },
       ctx,
@@ -109,7 +108,7 @@ describe("followup_create tool", () => {
     const result = await executeFollowupCreate(
       {
         channel: "email",
-        thread_id: "thread-456",
+        conversation_id: "conv-456",
         reminder_schedule_id: "sched-abc",
       },
       ctx,
@@ -122,7 +121,7 @@ describe("followup_create tool", () => {
   test("rejects missing channel", async () => {
     const result = await executeFollowupCreate(
       {
-        thread_id: "thread-123",
+        conversation_id: "conv-123",
       },
       ctx,
     );
@@ -135,7 +134,7 @@ describe("followup_create tool", () => {
     const result = await executeFollowupCreate(
       {
         channel: "   ",
-        thread_id: "thread-123",
+        conversation_id: "conv-123",
       },
       ctx,
     );
@@ -144,7 +143,7 @@ describe("followup_create tool", () => {
     expect(result.content).toContain("channel is required");
   });
 
-  test("rejects missing thread_id", async () => {
+  test("rejects missing conversation_id", async () => {
     const result = await executeFollowupCreate(
       {
         channel: "email",
@@ -153,14 +152,14 @@ describe("followup_create tool", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("thread_id is required");
+    expect(result.content).toContain("conversation_id is required");
   });
 
   test("rejects non-positive expected_response_hours", async () => {
     const result = await executeFollowupCreate(
       {
         channel: "email",
-        thread_id: "thread-123",
+        conversation_id: "conv-123",
         expected_response_hours: -1,
       },
       ctx,
@@ -176,7 +175,7 @@ describe("followup_create tool", () => {
     const result = await executeFollowupCreate(
       {
         channel: "email",
-        thread_id: "thread-123",
+        conversation_id: "conv-123",
         contact_id: "nonexistent-contact",
       },
       ctx,
@@ -201,11 +200,11 @@ describe("followup_list tool", () => {
 
   test("lists all follow-ups", async () => {
     await executeFollowupCreate(
-      { channel: "email", thread_id: "thread-1" },
+      { channel: "email", conversation_id: "conv-1" },
       ctx,
     );
     await executeFollowupCreate(
-      { channel: "slack", thread_id: "thread-2" },
+      { channel: "slack", conversation_id: "conv-2" },
       ctx,
     );
 
@@ -219,7 +218,7 @@ describe("followup_list tool", () => {
 
   test("filters by status", async () => {
     await executeFollowupCreate(
-      { channel: "email", thread_id: "thread-1" },
+      { channel: "email", conversation_id: "conv-1" },
       ctx,
     );
 
@@ -231,11 +230,11 @@ describe("followup_list tool", () => {
 
   test("filters by channel", async () => {
     await executeFollowupCreate(
-      { channel: "email", thread_id: "thread-1" },
+      { channel: "email", conversation_id: "conv-1" },
       ctx,
     );
     await executeFollowupCreate(
-      { channel: "slack", thread_id: "thread-2" },
+      { channel: "slack", conversation_id: "conv-2" },
       ctx,
     );
 
@@ -263,7 +262,7 @@ describe("followup_resolve tool", () => {
     const createResult = await executeFollowupCreate(
       {
         channel: "email",
-        thread_id: "thread-1",
+        conversation_id: "conv-1",
       },
       ctx,
     );
@@ -276,11 +275,11 @@ describe("followup_resolve tool", () => {
     expect(result.content).toContain("Status: resolved");
   });
 
-  test("resolves by channel and thread_id", async () => {
+  test("resolves by channel and conversation_id", async () => {
     await executeFollowupCreate(
       {
         channel: "email",
-        thread_id: "thread-1",
+        conversation_id: "conv-1",
       },
       ctx,
     );
@@ -288,7 +287,7 @@ describe("followup_resolve tool", () => {
     const result = await executeFollowupResolve(
       {
         channel: "email",
-        thread_id: "thread-1",
+        conversation_id: "conv-1",
       },
       ctx,
     );
@@ -299,18 +298,18 @@ describe("followup_resolve tool", () => {
 
   test("resolves multiple follow-ups by thread", async () => {
     await executeFollowupCreate(
-      { channel: "email", thread_id: "shared-thread" },
+      { channel: "email", conversation_id: "shared-thread" },
       ctx,
     );
     await executeFollowupCreate(
-      { channel: "email", thread_id: "shared-thread" },
+      { channel: "email", conversation_id: "shared-thread" },
       ctx,
     );
 
     const result = await executeFollowupResolve(
       {
         channel: "email",
-        thread_id: "shared-thread",
+        conversation_id: "shared-thread",
       },
       ctx,
     );
@@ -323,7 +322,7 @@ describe("followup_resolve tool", () => {
     const result = await executeFollowupResolve(
       {
         channel: "email",
-        thread_id: "nonexistent",
+        conversation_id: "nonexistent",
       },
       ctx,
     );
@@ -339,12 +338,12 @@ describe("followup_resolve tool", () => {
     expect(result.content).toContain("not found");
   });
 
-  test("rejects when neither id nor channel+thread_id provided", async () => {
+  test("rejects when neither id nor channel+conversation_id provided", async () => {
     const result = await executeFollowupResolve({}, ctx);
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain(
-      "Either id or both channel and thread_id are required",
+      "Either id or both channel and conversation_id are required",
     );
   });
 });

package/src/__tests__/frontmatter.test.ts

@@ -184,10 +184,10 @@ describe("parseFrontmatterFields", () => {
 
   test("boolean values are parsed as native booleans", () => {
     const result = parseFrontmatterFields(
-      "---\nuser-invocable: false\ndisable-model-invocation: true\n---\n",
+      "---\ndisable-feature: true\nsome-flag: false\n---\n",
     );
-    expect(result!.fields["user-invocable"]).toBe(false);
-    expect(result!.fields["disable-model-invocation"]).toBe(true);
+    expect(result!.fields["disable-feature"]).toBe(true);
+    expect(result!.fields["some-flag"]).toBe(false);
   });
 
   // -- CRLF handling --
@@ -219,7 +219,7 @@ describe("parseFrontmatterFields", () => {
       '  emoji: "\uD83D\uDD0C"',
       "  vellum:",
       '    display-name: "Test Skill"',
-      "    user-invocable: false",
+      "    some-custom-field: true",
       "---",
       "Body",
     ].join("\n");
@@ -230,7 +230,7 @@ describe("parseFrontmatterFields", () => {
       emoji: "\uD83D\uDD0C",
       vellum: {
         "display-name": "Test Skill",
-        "user-invocable": false,
+        "some-custom-field": true,
       },
     });
   });
@@ -242,13 +242,13 @@ describe("parseFrontmatterFields", () => {
       'description: "A test skill"',
       "metadata:",
       "  vellum:",
-      "    os:",
-      "      - darwin",
-      "      - linux",
       "    requires:",
       "      bins:",
       "        - node",
       "        - npm",
+      "      env:",
+      "        - API_KEY",
+      "        - SECRET",
       "---",
       "Body",
     ].join("\n");
@@ -256,8 +256,10 @@ describe("parseFrontmatterFields", () => {
     expect(result).not.toBeNull();
     const meta = result!.fields.metadata as Record<string, unknown>;
     const vellum = meta.vellum as Record<string, unknown>;
-    expect(vellum.os).toEqual(["darwin", "linux"]);
-    expect(vellum.requires).toEqual({ bins: ["node", "npm"] });
+    expect(vellum.requires).toEqual({
+      bins: ["node", "npm"],
+      env: ["API_KEY", "SECRET"],
+    });
   });
 
   test("returns null for invalid YAML frontmatter", () => {

package/src/__tests__/gateway-only-enforcement.test.ts

@@ -58,7 +58,7 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
     calls: {
       enabled: true,
@@ -80,7 +80,7 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
     ingress: {
       publicBaseUrl: "https://test.example.com",

package/src/__tests__/gateway-only-guard.test.ts

@@ -22,6 +22,7 @@ const ALLOWLIST = new Set([
   // Matched by prefix check below: gateway/
 
   // --- Intentional local daemon-control paths ---
+  "assistant/src/cli/commands/conversations.ts", // CLI wipe talks to runtime directly
   "clients/shared/Network/DaemonClient.swift",
   "clients/macos/vellum-assistant/App/AppDelegate.swift",
   "clients/macos/vellum-assistant/Features/Settings/SettingsConnectTab.swift",

package/src/__tests__/gemini-image-service.test.ts

@@ -111,7 +111,7 @@ describe("generateImage", () => {
     expect(result.images).toHaveLength(1);
     expect(result.images[0].mimeType).toBe("image/png");
     expect(result.images[0].dataBase64).toBe("abc123");
-    expect(result.resolvedModel).toBe("gemini-2.5-flash-image");
+    expect(result.resolvedModel).toBe("gemini-3.1-flash-image-preview");
   });
 
   test("generate mode collects text commentary from response", async () => {
@@ -168,7 +168,7 @@ describe("generateImage", () => {
 
     expect(lastGenerateParams).not.toBeNull();
     expect((lastGenerateParams as Record<string, unknown>).model).toBe(
-      "gemini-2.5-flash-image",
+      "gemini-3.1-flash-image-preview",
     );
   });
 
@@ -180,12 +180,12 @@ describe("generateImage", () => {
       {
         prompt: "test",
         mode: "generate",
-        model: "gemini-3-pro-image",
+        model: "gemini-3-pro-image-preview",
       },
     );
 
     expect((lastGenerateParams as Record<string, unknown>).model).toBe(
-      "gemini-3-pro-image",
+      "gemini-3-pro-image-preview",
     );
   });
 

package/src/__tests__/gemini-provider.test.ts

@@ -739,17 +739,14 @@ describe("GeminiProvider", () => {
     expect(lastConstructorOpts).toEqual({ apiKey: "test-key" });
   });
 
-  test("sets vertexai mode with httpOptions.baseUrl when managedBaseUrl is provided", () => {
+  test("sets httpOptions.baseUrl when managedBaseUrl is provided", () => {
     new GeminiProvider("managed-key", "gemini-3-flash", {
-      managedBaseUrl: "https://platform.example.com/v1/runtime-proxy/vertex",
+      managedBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
     });
     expect(lastConstructorOpts).toEqual({
-      vertexai: true,
-      project: "proxy",
-      location: "us-central1",
+      apiKey: "managed-key",
       httpOptions: {
-        baseUrl: "https://platform.example.com/v1/runtime-proxy/vertex",
-        headers: { Authorization: "Bearer managed-key" },
+        baseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
       },
     });
   });
@@ -759,7 +756,7 @@ describe("GeminiProvider", () => {
       "managed-key",
       "gemini-3-flash",
       {
-        managedBaseUrl: "https://platform.example.com/v1/runtime-proxy/vertex",
+        managedBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
       },
     );
 
@@ -784,7 +781,7 @@ describe("GeminiProvider", () => {
       "managed-key",
       "gemini-3-flash",
       {
-        managedBaseUrl: "https://platform.example.com/v1/runtime-proxy/vertex",
+        managedBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
       },
     );
 

package/src/__tests__/guardian-action-late-reply.test.ts

@@ -479,7 +479,7 @@ describe("guardian-action-late-reply", () => {
       );
       const code = req1.requestCode; // e.g. "A1B2C3"
 
-      // Simulate case-insensitive prefix matching as done in session-process.ts
+      // Simulate case-insensitive prefix matching as done in conversation-process.ts
       const userInput = `${code.toLowerCase()} the answer is 42`;
       const matched = userInput.toUpperCase().startsWith(code);
       expect(matched).toBe(true);

package/src/__tests__/guardian-action-no-hardcoded-copy.test.ts

@@ -21,7 +21,7 @@ const SCANNED_FILES = [
   "calls/guardian-action-sweep.ts",
   "runtime/routes/inbound-message-handler.ts",
   "runtime/guardian-action-conversation-turn.ts",
-  "daemon/session-process.ts",
+  "daemon/conversation-process.ts",
 ];
 
 const BANNED_PATTERNS: { pattern: RegExp; description: string }[] = [

package/src/__tests__/guardian-binding-drift-heal.test.ts

@@ -0,0 +1,128 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const testDir = mkdtempSync(
+  join(tmpdir(), "guardian-binding-drift-heal-test-"),
+);
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { findGuardianForChannel } from "../contacts/contact-store.js";
+import { createGuardianBinding } from "../contacts/contacts-write.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { healGuardianBindingDrift } from "../runtime/guardian-vellum-migration.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM contact_channels");
+  db.run("DELETE FROM contacts");
+}
+
+describe("healGuardianBindingDrift", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  afterAll(() => {
+    resetDb();
+    try {
+      rmSync(testDir, { recursive: true });
+    } catch {
+      // best-effort cleanup
+    }
+  });
+
+  test("heals drift when both principals have vellum-principal- prefix", () => {
+    // Simulate DB reset: new guardian binding with a different UUID
+    createGuardianBinding({
+      channel: "vellum",
+      guardianExternalUserId: "vellum-principal-new-uuid",
+      guardianDeliveryChatId: "local",
+      guardianPrincipalId: "vellum-principal-new-uuid",
+      verifiedVia: "startup-migration",
+    });
+
+    // Client arrives with the old JWT principal
+    const healed = healGuardianBindingDrift("vellum-principal-old-uuid");
+    expect(healed).toBe(true);
+
+    // Guardian binding now matches the old JWT
+    const guardian = findGuardianForChannel("vellum");
+    expect(guardian).not.toBeNull();
+    expect(guardian!.contact.principalId).toBe("vellum-principal-old-uuid");
+    expect(guardian!.channel.externalUserId).toBe("vellum-principal-old-uuid");
+  });
+
+  test("no-op when principals already match", () => {
+    createGuardianBinding({
+      channel: "vellum",
+      guardianExternalUserId: "vellum-principal-same",
+      guardianDeliveryChatId: "local",
+      guardianPrincipalId: "vellum-principal-same",
+      verifiedVia: "startup-migration",
+    });
+
+    const healed = healGuardianBindingDrift("vellum-principal-same");
+    expect(healed).toBe(false);
+  });
+
+  test("refuses to heal when incoming principal lacks vellum-principal- prefix", () => {
+    createGuardianBinding({
+      channel: "vellum",
+      guardianExternalUserId: "vellum-principal-aaa",
+      guardianDeliveryChatId: "local",
+      guardianPrincipalId: "vellum-principal-aaa",
+      verifiedVia: "startup-migration",
+    });
+
+    // External/platform principal — should NOT be adopted
+    const healed = healGuardianBindingDrift("platform-user-12345");
+    expect(healed).toBe(false);
+
+    // Guardian unchanged
+    const guardian = findGuardianForChannel("vellum");
+    expect(guardian!.contact.principalId).toBe("vellum-principal-aaa");
+  });
+
+  test("refuses to heal when stored principal lacks vellum-principal- prefix", () => {
+    createGuardianBinding({
+      channel: "vellum",
+      guardianExternalUserId: "verified-phone-guardian",
+      guardianDeliveryChatId: "local",
+      guardianPrincipalId: "verified-phone-guardian",
+      verifiedVia: "challenge",
+    });
+
+    // Even with a vellum-principal- incoming, don't overwrite a real binding
+    const healed = healGuardianBindingDrift("vellum-principal-attacker");
+    expect(healed).toBe(false);
+
+    const guardian = findGuardianForChannel("vellum");
+    expect(guardian!.contact.principalId).toBe("verified-phone-guardian");
+  });
+
+  test("returns false when no guardian binding exists", () => {
+    const healed = healGuardianBindingDrift("vellum-principal-orphan");
+    expect(healed).toBe(false);
+  });
+});